diff --git a/.dependabot/config.yml b/.dependabot/config.yml
new file mode 100644
index 0000000000..ed349bd7c0
--- /dev/null
+++ b/.dependabot/config.yml
@@ -0,0 +1,10 @@
+# See https://dependabot.com/docs/config-file/ for a reference.
+version: 1
+update_configs:
+ - package_manager: "rust:cargo"
+ directory: "/"
+ update_schedule: "live"
+ version_requirement_updates: "auto"
+ allowed_updates:
+ - match:
+ update_type: "security"
diff --git a/.github/actions/binary-compatible-builds/README.md b/.github/actions/binary-compatible-builds/README.md
new file mode 100644
index 0000000000..8368fd4f1a
--- /dev/null
+++ b/.github/actions/binary-compatible-builds/README.md
@@ -0,0 +1,9 @@
+# binary-compatible-builds
+
+A small (ish) action which is intended to be used and will configure builds of
+Rust projects to be "more binary compatible". On Windows and macOS this
+involves setting a few env vars, and on Linux this involves spinning up a CentOS
+6 container which is running in the background.
+
+All subsequent build commands need to be wrapped in `$CENTOS` to optionally run
+on `$CENTOS` on Linux to ensure builds happen inside the container.
diff --git a/.github/actions/binary-compatible-builds/action.yml b/.github/actions/binary-compatible-builds/action.yml
new file mode 100644
index 0000000000..de2e74ec77
--- /dev/null
+++ b/.github/actions/binary-compatible-builds/action.yml
@@ -0,0 +1,6 @@
+name: 'Set up a CentOS 6 container to build releases in'
+description: 'Set up a CentOS 6 container to build releases in'
+
+runs:
+ using: node12
+ main: 'main.js'
diff --git a/.github/actions/binary-compatible-builds/main.js b/.github/actions/binary-compatible-builds/main.js
new file mode 100755
index 0000000000..05fc93f8ab
--- /dev/null
+++ b/.github/actions/binary-compatible-builds/main.js
@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+const child_process = require('child_process');
+const stdio = { stdio: 'inherit' };
+
+// On OSX all we need to do is configure our deployment target as old as
+// possible. For now 10.9 is the limit.
+if (process.platform == 'darwin') {
+ console.log("::set-env name=MACOSX_DEPLOYMENT_TARGET::10.9");
+ console.log("::set-env name=python::python3");
+ return;
+}
+
+// On Windows we build against the static CRT to reduce dll dependencies
+if (process.platform == 'win32') {
+ console.log("::set-env name=RUSTFLAGS::-Ctarget-feature=+crt-static");
+ console.log("::set-env name=python::python");
+ 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', 'centos'];
+ for (const arg of process.argv.slice(2)) {
+ args.push(arg);
+ }
+ child_process.execFileSync('docker', args, stdio);
+ return;
+}
+
+// Add our rust mount onto PATH, but also add some stuff to PATH from
+// the packages that we install.
+let path = process.env.PATH;
+path = `${path}:/rust/bin`;
+path = `/opt/rh/devtoolset-8/root/usr/bin:${path}`;
+path = `/opt/rh/rh-python36/root/usr/bin:${path}`;
+
+// Spawn a container daemonized in the background which we'll connect to via
+// `docker exec`. This'll have access to the current directory.
+child_process.execFileSync('docker', [
+ 'run',
+ '-di',
+ '--name', 'centos',
+ '-v', `${process.cwd()}:${process.cwd()}`,
+ '-v', `${child_process.execSync('rustc --print sysroot').toString().trim()}:/rust:ro`,
+ '--env', `PATH=${path}`,
+ 'centos:6',
+], stdio);
+
+// Use ourselves to run future commands
+console.log(`::set-env name=CENTOS::${__filename}`)
+
+// See https://edwards.sdsu.edu/research/c11-on-centos-6/ for where these
+const exec = s => {
+ child_process.execSync(`docker exec centos ${s}`, stdio);
+};
+exec('yum install -y centos-release-scl cmake xz epel-release');
+exec('yum install -y rh-python36 patchelf unzip');
+exec('yum install -y devtoolset-8-gcc devtoolset-8-binutils devtoolset-8-gcc-c++');
+exec('yum install -y git');
+
+// Delete `libstdc++.so` to force gcc to link against `libstdc++.a` instead.
+// This is a hack and not the right way to do this, but it ends up doing the
+// right thing for now.
+exec('rm -f /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/libstdc++.so');
+console.log("::set-env name=python::python3");
diff --git a/.github/actions/define-dwarfdump-env/README.md b/.github/actions/define-dwarfdump-env/README.md
new file mode 100644
index 0000000000..035ac379a1
--- /dev/null
+++ b/.github/actions/define-dwarfdump-env/README.md
@@ -0,0 +1,3 @@
+# define-dwarfdump-env
+
+Defines `DWARFDUMP` path executable.
diff --git a/.github/actions/define-dwarfdump-env/action.yml b/.github/actions/define-dwarfdump-env/action.yml
new file mode 100644
index 0000000000..36f77b60b8
--- /dev/null
+++ b/.github/actions/define-dwarfdump-env/action.yml
@@ -0,0 +1,6 @@
+name: 'Set up a DWARFDUMP env'
+description: 'Set up a DWARFDUMP env (see tests/debug/dump.rs)'
+
+runs:
+ using: node12
+ main: 'main.js'
diff --git a/.github/actions/define-dwarfdump-env/main.js b/.github/actions/define-dwarfdump-env/main.js
new file mode 100755
index 0000000000..cddcc7f552
--- /dev/null
+++ b/.github/actions/define-dwarfdump-env/main.js
@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+// On OSX pointing to brew's LLVM location.
+if (process.platform == 'darwin') {
+ console.log("::set-env name=DWARFDUMP::/usr/local/opt/llvm/bin/llvm-dwarfdump");
+}
+
+// On Linux pointing to specific version
+if (process.platform == 'linux') {
+ console.log("::set-env name=DWARFDUMP::/usr/bin/llvm-dwarfdump-9");
+}
diff --git a/.github/actions/github-release/Dockerfile b/.github/actions/github-release/Dockerfile
new file mode 100644
index 0000000000..5849eac7d2
--- /dev/null
+++ b/.github/actions/github-release/Dockerfile
@@ -0,0 +1,8 @@
+FROM node:slim
+
+COPY . /action
+WORKDIR /action
+
+RUN npm install --production
+
+ENTRYPOINT ["node", "/action/main.js"]
diff --git a/.github/actions/github-release/README.md b/.github/actions/github-release/README.md
new file mode 100644
index 0000000000..c70ba8f495
--- /dev/null
+++ b/.github/actions/github-release/README.md
@@ -0,0 +1,18 @@
+# github-release
+
+An action used to publish GitHub releases for `wasmtime`.
+
+As of the time of this writing there's a few actions floating around which
+perform github releases but they all tend to have their set of drawbacks.
+Additionally nothing handles deleting releases which we need for our rolling
+`dev` release.
+
+To handle all this this action rolls-its-own implementation using the
+actions/toolkit repository and packages published there. These run in a Docker
+container and take various inputs to orchestrate the release from the build.
+
+More comments can be found in `main.js`.
+
+Testing this is really hard. If you want to try though run `npm install` and
+then `node main.js`. You'll have to configure a bunch of env vars though to get
+anything reasonably working.
diff --git a/.github/actions/github-release/action.yml b/.github/actions/github-release/action.yml
new file mode 100644
index 0000000000..51a074adfa
--- /dev/null
+++ b/.github/actions/github-release/action.yml
@@ -0,0 +1,15 @@
+name: 'wasmtime github releases'
+description: 'wasmtime github releases'
+inputs:
+ token:
+ description: ''
+ required: true
+ name:
+ description: ''
+ required: true
+ files:
+ description: ''
+ required: true
+runs:
+ using: 'docker'
+ image: 'Dockerfile'
diff --git a/.github/actions/github-release/main.js b/.github/actions/github-release/main.js
new file mode 100644
index 0000000000..567fe3967f
--- /dev/null
+++ b/.github/actions/github-release/main.js
@@ -0,0 +1,117 @@
+const core = require('@actions/core');
+const path = require("path");
+const fs = require("fs");
+const github = require('@actions/github');
+const glob = require('glob');
+
+function sleep(milliseconds) {
+ return new Promise(resolve => setTimeout(resolve, milliseconds))
+}
+
+async function runOnce() {
+ // Load all our inputs and env vars. Note that `getInput` reads from `INPUT_*`
+ const files = core.getInput('files');
+ const name = core.getInput('name');
+ const token = core.getInput('token');
+ const slug = process.env.GITHUB_REPOSITORY;
+ const owner = slug.split('/')[0];
+ const repo = slug.split('/')[1];
+ const sha = process.env.GITHUB_SHA;
+
+ core.info(`files: ${files}`);
+ core.info(`name: ${name}`);
+ core.info(`token: ${token}`);
+
+ const octokit = new github.GitHub(token);
+
+ // Delete the previous release since we can't overwrite one. This may happen
+ // due to retrying an upload or it may happen because we're doing the dev
+ // release.
+ const releases = await octokit.paginate("GET /repos/:owner/:repo/releases", { owner, repo });
+ for (const release of releases) {
+ if (release.tag_name !== name) {
+ continue;
+ }
+ const release_id = release.id;
+ core.info(`deleting release ${release_id}`);
+ await octokit.repos.deleteRelease({ owner, repo, release_id });
+ }
+
+ // We also need to update the `dev` tag while we're at it on the `dev` branch.
+ if (name == 'dev') {
+ try {
+ core.info(`updating dev tag`);
+ await octokit.git.updateRef({
+ owner,
+ repo,
+ ref: 'tags/dev',
+ sha,
+ force: true,
+ });
+ } catch (e) {
+ console.log("ERROR: ", JSON.stringify(e, null, 2));
+ core.info(`creating dev tag`);
+ await octokit.git.createTag({
+ owner,
+ repo,
+ tag: 'dev',
+ message: 'dev release',
+ object: sha,
+ type: 'commit',
+ });
+ }
+ }
+
+ // Creates an official GitHub release for this `tag`, and if this is `dev`
+ // then we know that from the previous block this should be a fresh release.
+ core.info(`creating a release`);
+ const release = await octokit.repos.createRelease({
+ owner,
+ repo,
+ tag_name: name,
+ prerelease: name === 'dev',
+ });
+
+ // Upload all the relevant assets for this release as just general blobs.
+ for (const file of glob.sync(files)) {
+ const size = fs.statSync(file).size;
+ core.info(`upload ${file}`);
+ await octokit.repos.uploadReleaseAsset({
+ data: fs.createReadStream(file),
+ headers: { 'content-length': size, 'content-type': 'application/octet-stream' },
+ name: path.basename(file),
+ url: release.data.upload_url,
+ });
+ }
+}
+
+async function run() {
+ const retries = 10;
+ for (let i = 0; i < retries; i++) {
+ try {
+ await runOnce();
+ break;
+ } catch (e) {
+ if (i === retries - 1)
+ throw e;
+ logError(e);
+ console.log("RETRYING after 10s");
+ await sleep(10000)
+ }
+ }
+}
+
+function logError(e) {
+ console.log("ERROR: ", e.message);
+ try {
+ console.log(JSON.stringify(e, null, 2));
+ } catch (e) {
+ // ignore json errors for now
+ }
+ console.log(e.stack);
+}
+
+run().catch(err => {
+ logError(err);
+ core.setFailed(err.message);
+});
diff --git a/.github/actions/github-release/package.json b/.github/actions/github-release/package.json
new file mode 100644
index 0000000000..abfc55f6ff
--- /dev/null
+++ b/.github/actions/github-release/package.json
@@ -0,0 +1,10 @@
+{
+ "name": "wasmtime-github-release",
+ "version": "0.0.0",
+ "main": "main.js",
+ "dependencies": {
+ "@actions/core": "^1.0.0",
+ "@actions/github": "^1.0.0",
+ "glob": "^7.1.5"
+ }
+}
diff --git a/.github/actions/install-rust/README.md b/.github/actions/install-rust/README.md
new file mode 100644
index 0000000000..df8e94dccc
--- /dev/null
+++ b/.github/actions/install-rust/README.md
@@ -0,0 +1,18 @@
+# install-rust
+
+A small github action to install `rustup` and a Rust toolchain. This is
+generally expressed inline, but it was repeated enough in this repository it
+seemed worthwhile to extract.
+
+Some gotchas:
+
+* Can't `--self-update` on Windows due to permission errors (a bug in Github
+ Actions)
+* `rustup` isn't installed on macOS (a bug in Github Actions)
+
+When the above are fixed we should delete this action and just use this inline:
+
+```yml
+- run: rustup update $toolchain && rustup default $toolchain
+ shell: bash
+```
diff --git a/.github/actions/install-rust/action.yml b/.github/actions/install-rust/action.yml
new file mode 100644
index 0000000000..7a19659184
--- /dev/null
+++ b/.github/actions/install-rust/action.yml
@@ -0,0 +1,12 @@
+name: 'Install Rust toolchain'
+description: 'Install both `rustup` and a Rust toolchain'
+
+inputs:
+ toolchain:
+ description: 'Default toolchan to install'
+ required: false
+ default: 'stable'
+
+runs:
+ using: node12
+ main: 'main.js'
diff --git a/.github/actions/install-rust/main.js b/.github/actions/install-rust/main.js
new file mode 100644
index 0000000000..b2355abfa1
--- /dev/null
+++ b/.github/actions/install-rust/main.js
@@ -0,0 +1,13 @@
+const child_process = require('child_process');
+const toolchain = process.env.INPUT_TOOLCHAIN;
+
+if (process.platform === 'darwin') {
+ child_process.execSync(`curl https://sh.rustup.rs | sh -s -- -y --default-toolchain=none --profile=minimal`);
+ const bindir = `${process.env.HOME}/.cargo/bin`;
+ console.log(`::add-path::${bindir}`);
+ process.env.PATH = `${process.env.PATH}:${bindir}`;
+}
+
+child_process.execFileSync('rustup', ['set', 'profile', 'minimal']);
+child_process.execFileSync('rustup', ['update', toolchain, '--no-self-update']);
+child_process.execFileSync('rustup', ['default', toolchain]);
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 0000000000..f1679f2e79
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,546 @@
+name: CI
+on:
+ push:
+ branches: [master]
+ tags-ignore: [dev]
+ pull_request:
+ branches: [master]
+
+jobs:
+ # Check Code style quickly by running `rustfmt` over all code
+ rustfmt:
+ name: Rustfmt
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ - run: cargo fmt --all -- --check
+
+ # Build `mdBook` documentation for `wasmtime`, and upload it as a temporary
+ # build artifact
+ doc_book:
+ name: Doc - build the book
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - run: |
+ set -e
+ curl -L https://github.com/rust-lang-nursery/mdBook/releases/download/v0.3.1/mdbook-v0.3.1-x86_64-unknown-linux-gnu.tar.gz | tar xzf -
+ echo ::add-path::`pwd`
+ - run: (cd docs && mdbook build)
+ - run: cargo build -p wasmtime
+ - run: (cd docs && mdbook test -L ../target/debug/deps)
+ - uses: actions/upload-artifact@v1
+ with:
+ name: doc-book
+ path: docs/book
+
+ # Build rustdoc API documentation for `wasmtime*` crates. Note that we don't
+ # want to document all our transitive dependencies, hence `--no-deps`. This is
+ # a temporary build artifact we upload to consume later.
+ doc_api:
+ name: Doc - build the API documentation
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ with:
+ toolchain: nightly
+ - run: cargo doc --no-deps --all --exclude wasmtime-cli --exclude test-programs
+ - uses: actions/upload-artifact@v1
+ with:
+ name: doc-api
+ path: target/doc
+
+ # Download our libFuzzer corpus and make sure that we can still handle all the
+ # inputs.
+ fuzz_corpora:
+ name: Fuzz Corpora
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: actions/checkout@v1
+ with:
+ repository: bytecodealliance/wasmtime-libfuzzer-corpus
+ path: ./wasmtime/fuzz/corpus
+ ref: refs/heads/master
+ - uses: ./.github/actions/install-rust
+ with:
+ toolchain: nightly
+ - run: cargo install cargo-fuzz --vers "^0.7"
+ - run: cargo fetch
+ working-directory: ./fuzz
+ - run: cargo fuzz build --release --debug-assertions
+ # Our corpora are too large to run in full on every pull request, they just
+ # take too long. Instead, we sample some of them and make sure that running
+ # our fuzzers over the sampled inputs still works OK.
+ - run: |
+ find fuzz/corpus/compile -type f \
+ | shuf \
+ | head -n 3000 \
+ | xargs cargo fuzz run compile --release --debug-assertions
+ - run: |
+ find fuzz/corpus/instantiate -type f \
+ | shuf \
+ | head -n 2000 \
+ | xargs cargo fuzz run instantiate --release --debug-assertions
+ - run: |
+ find fuzz/corpus/instantiate_translated -type f \
+ | shuf \
+ | head -n 1000 \
+ | xargs cargo fuzz run instantiate_translated --release --debug-assertions
+ - run: |
+ find fuzz/corpus/api_calls -type f \
+ | shuf \
+ | head -n 100 \
+ | xargs cargo fuzz run api_calls --release --debug-assertions
+ - run: |
+ find fuzz/corpus/differential -type f \
+ | shuf \
+ | head -n 100 \
+ | xargs cargo fuzz run differential --release --debug-assertions
+
+ # Install wasm32-unknown-emscripten target, and ensure `crates/wasi-common`
+ # compiles to Emscripten.
+ # TODO enable once rust-lang/rust#66308 is fixed
+ # emscripten:
+ # name: Emscripten
+ # runs-on: ubuntu-latest
+ # steps:
+ # - uses: actions/checkout@v1
+ # with:
+ # submodules: true
+ # - uses: ./.github/actions/install-rust
+ # - run: rustup target add wasm32-unknown-emscripten
+ # - run: cargo build --target wasm32-unknown-emscripten -p wasi-common
+
+ # Perform all tests (debug mode) for `wasmtime`. This runs stable/beta/nightly
+ # channels of Rust as well as macOS/Linux/Windows.
+ test:
+ name: Test
+ runs-on: ${{ matrix.os }}
+ strategy:
+ matrix:
+ build: [stable, beta, nightly, windows, macos]
+ include:
+ - build: stable
+ os: ubuntu-latest
+ rust: stable
+ - build: beta
+ os: ubuntu-latest
+ rust: beta
+ - build: nightly
+ os: ubuntu-latest
+ rust: nightly
+ - build: macos
+ os: macos-latest
+ rust: stable
+ - build: windows
+ os: windows-latest
+ rust: stable
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ with:
+ toolchain: ${{ matrix.rust }}
+ - uses: ./.github/actions/define-dwarfdump-env
+
+ - name: Install libclang
+ # Note: libclang is pre-installed on the macOS and linux images.
+ if: matrix.os == 'windows-latest'
+ run: |
+ Invoke-WebRequest http://releases.llvm.org/9.0.0/LLVM-9.0.0-win64.exe -OutFile llvm-installer.exe
+ 7z x llvm-installer.exe -oC:\llvm-binary
+ Write-Host ::set-env name=LIBCLANG_PATH::C:\llvm-binary\bin\libclang.dll
+ Write-Host ::add-path::C:\llvm-binary\bin
+
+ - name: Query Clang Version
+ if: matrix.os == 'windows-latest'
+ run: |
+ Get-Command clang.exe
+ clang.exe --version
+
+ # Install wasm32-wasi target in order to build wasi-common's integration
+ # tests
+ - run: rustup target add wasm32-wasi
+
+ - run: cargo fetch --locked
+ - run: cargo fetch --locked --manifest-path crates/test-programs/wasi-tests/Cargo.toml
+
+ # Build some various feature combinations
+ - run: cargo build --manifest-path crates/api/Cargo.toml --no-default-features
+ - run: cargo build --manifest-path crates/api/Cargo.toml --features wat
+ - run: cargo build --manifest-path crates/api/Cargo.toml --features lightbeam
+ if: matrix.rust == 'nightly'
+
+ # Build and test all features except for lightbeam
+ - run: cargo test --features test_programs --all --exclude lightbeam --exclude wasmtime-c-api -- --nocapture
+ env:
+ RUST_BACKTRACE: 1
+ RUSTFLAGS: "-D warnings"
+
+ # Build and test lightbeam if we're using the nightly toolchain. Note that
+ # Lightbeam tests fail right now, but we don't want to block on that.
+ - run: cargo build --package lightbeam
+ if: matrix.rust == 'nightly'
+ - run: cargo test --package lightbeam -- --nocapture
+ if: matrix.rust == 'nightly'
+ continue-on-error: true
+ env:
+ RUST_BACKTRACE: 1
+
+ # Build and test c-api examples. Skipping testing on Windows due to
+ # GNU make dependency when executing the wasm-c-api examples.
+ - run: cargo build --package wasmtime-c-api
+ if: matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest'
+ - run: cargo test --package wasmtime-c-api -- --nocapture --test-threads 1
+ if: matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest'
+ continue-on-error: true
+ env:
+ RUST_BACKTRACE: 1
+
+ # Builds a Python wheel (package) for Windows/Mac/Linux. Note that we're
+ # careful to create binary-compatible releases here to old releases of
+ # Windows/Mac/Linux. This will also build wheels for Python 3.6, 3.7 and 3.8.
+ wheels:
+ name: Python Wheel
+ runs-on: ${{ matrix.os }}
+ strategy:
+ matrix:
+ os: [ubuntu-latest, macos-latest, windows-latest]
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ with:
+ toolchain: nightly-2020-01-06
+ - uses: ./.github/actions/binary-compatible-builds
+ - run: mkdir crates/misc/py/wheelhouse
+ shell: bash
+
+ # Install Python & dependencies needed for our `setup.py` scripts
+ - name: Setup Python 3.6
+ uses: actions/setup-python@v1
+ with:
+ python-version: '3.6'
+ architecture: x64
+ - run: $CENTOS pip3 install setuptools wheel setuptools-rust
+ shell: bash
+ - run: (cd crates/misc/py && $CENTOS $python setup.py bdist_wheel)
+ shell: bash
+
+ # Clear the build directory between building different wheels for different
+ # Python versions to ensure that we don't package dynamic libraries twice by
+ # accident.
+ - run: $CENTOS rm -rf crates/misc/py/build
+ shell: bash
+
+ # Set up Python 3.7 (and build it on Linux), reinstall dependencies, then
+ # rebuild our wheels
+ - name: Setup Python 3.7
+ uses: actions/setup-python@v1
+ with:
+ python-version: '3.7'
+ architecture: x64
+ if: matrix.os != 'ubuntu-latest'
+ - name: Build Python 3.7
+ run: $CENTOS sh ci/setup_centos6_python3.sh 3.7.3
+ if: matrix.os == 'ubuntu-latest'
+ - run: $CENTOS pip3 install setuptools wheel setuptools-rust auditwheel
+ shell: bash
+ - run: (cd crates/misc/py && $CENTOS $python setup.py bdist_wheel)
+ shell: bash
+
+ # Clear the build directory between building different wheels for different
+ # Python versions to ensure that we don't package dynamic libraries twice by
+ # accident.
+ - run: $CENTOS rm -rf crates/misc/py/build
+ shell: bash
+
+ # Set up Python 3.8 (and build it on Linux), reinstall dependencies, then
+ # rebuild our wheels
+ - name: Setup Python 3.8
+ uses: actions/setup-python@v1
+ with:
+ python-version: '3.8'
+ architecture: x64
+ if: matrix.os != 'ubuntu-latest'
+ - name: Build Python 3.8
+ run: $CENTOS sh ci/setup_centos6_python3.sh 3.8.0
+ if: matrix.os == 'ubuntu-latest'
+ - run: $CENTOS pip3 install setuptools wheel setuptools-rust auditwheel
+ shell: bash
+ - run: (cd crates/misc/py && $CENTOS $python setup.py bdist_wheel)
+ shell: bash
+
+ # Move `dist/*.whl` into `wheelhouse/` so we can deploy them, but on Linux we
+ # need to run an `auditwheel` command as well to turn these into "manylinux"
+ # wheels to run across a number of distributions.
+ - run: cp crates/misc/py/dist/*.whl crates/misc/py/wheelhouse/
+ shell: bash
+ if: matrix.os != 'ubuntu-latest'
+ - run: |
+ set -e
+ cd crates/misc/py
+ for whl in dist/*.whl; do
+ $CENTOS auditwheel repair "$whl" -w wheelhouse/
+ done
+ shell: bash
+ if: matrix.os == 'ubuntu-latest'
+
+ # Upload this for the publishing stage of pipelines
+ - uses: actions/upload-artifact@v1
+ with:
+ name: wheels-${{ matrix.os }}
+ path: crates/misc/py/wheelhouse
+
+ # Perform release builds of `wasmtime` and `libwasmtime.so`. Builds on
+ # Windows/Mac/Linux, and artifacts are uploaded after the build is finished.
+ # Note that we also run tests here to test exactly what we're deploying.
+ build:
+ name: Build wasmtime
+ runs-on: ${{ matrix.os }}
+ strategy:
+ matrix:
+ os: [ubuntu-latest, macos-latest, windows-latest]
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ - uses: ./.github/actions/binary-compatible-builds
+
+ # Install wasm32-wasi target in order to build wasi-common's integration
+ # tests
+ - run: rustup target add wasm32-wasi
+
+ # Build `wasmtime` and executables
+ - run: $CENTOS cargo build --release --bin wasmtime --bin wasm2obj
+ shell: bash
+ # Build `libwasmtime.so`
+ - run: $CENTOS cargo build --release --manifest-path crates/c-api/Cargo.toml
+ shell: bash
+ # Test what we just built
+ - run: $CENTOS cargo test --features test_programs --release --all --exclude lightbeam --exclude wasmtime --exclude wasmtime-c-api --exclude wasmtime-fuzzing -- --skip test_debug_dwarf_
+ shell: bash
+ env:
+ RUST_BACKTRACE: 1
+
+ # 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
+ - run: install_name_tool -id "@rpath/libwasmtime.dylib" target/release/libwasmtime.dylib
+ if: matrix.os == 'macos-latest'
+
+ # ... and now perform some goop to move all the relevant artifacts into
+ # something that we'll upload from this action.
+
+ - run: mkdir dist
+ shell: bash
+
+ # Move binaries to dist folder
+ - run: cp target/release/{wasmtime,wasm2obj} dist
+ if: matrix.os != 'windows-latest'
+ - run: cp target/release/{wasmtime,wasm2obj}.exe dist
+ shell: bash
+ if: matrix.os == 'windows-latest'
+
+ # Move libwasmtime dylib to dist folder
+ - run: cp target/release/libwasmtime.{so,a} dist
+ if: matrix.os == 'ubuntu-latest'
+ - run: cp target/release/libwasmtime.{dylib,a} dist
+ if: matrix.os == 'macos-latest'
+ - run: cp target/release/wasmtime.{dll,lib} dist
+ shell: bash
+ if: matrix.os == 'windows-latest'
+
+ # Make a Windows MSI installer if we're on Windows
+ - run: |
+ 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/installer.msi target/wasmtime.wixobj -ext WixUtilExtension
+ rm dist/installer.wixpdb
+ shell: bash
+ if: matrix.os == 'windows-latest'
+
+ - uses: actions/upload-artifact@v1
+ with:
+ name: bins-${{ matrix.os }}
+ path: dist
+
+ # Build and test the .NET bindings
+ dotnet:
+ name: Test Wasmtime for .NET bindings
+ runs-on: ${{ matrix.os }}
+ strategy:
+ matrix:
+ build: [linux-debug, linux-release, macos-debug, macos-release, windows-debug, windows-release]
+ include:
+ - build: linux-debug
+ os: ubuntu-latest
+ config: debug
+ - build: linux-release
+ os: ubuntu-latest
+ config: release
+ - build: macos-debug
+ os: macos-latest
+ config: debug
+ - build: macos-release
+ os: macos-latest
+ config: release
+ - build: windows-debug
+ os: windows-latest
+ config: debug
+ - build: windows-release
+ os: windows-latest
+ config: release
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ - uses: ./.github/actions/binary-compatible-builds
+ - run: rustup target add wasm32-wasi
+ - uses: actions/setup-dotnet@v1
+ with:
+ dotnet-version: '3.0.101'
+ - name: Test
+ run: |
+ cd crates/misc/dotnet/tests
+ dotnet test -c ${{ matrix.config }}
+ - name: Create package
+ run: |
+ cd crates/misc/dotnet/src
+ dotnet pack -c ${{ matrix.config }}
+ if: matrix.os == 'macos-latest' # Currently the pack target only supports macOS
+
+ # Consumes all published artifacts from all the previous build steps, creates
+ # a bunch of tarballs for all of them, and then publishes the tarballs
+ # themselves as an artifact (for inspection) and then optionally creates
+ # github releases and/or tags for pushes.
+ publish:
+ name: Publish
+ needs: [doc_book, doc_api, wheels, build]
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ submodules: true
+ - run: rustup update stable && rustup default stable
+
+ # Download all the artifacts that we'll be publishing. Should keep an eye on
+ # the `download-artifact` repository to see if we can ever get something
+ # like "download all artifacts" or "download this list of artifacts"
+ - name: Download book
+ uses: actions/download-artifact@v1
+ with:
+ name: doc-book
+ - name: Download API docs
+ uses: actions/download-artifact@v1
+ with:
+ name: doc-api
+ - name: Download macOS Wheel
+ uses: actions/download-artifact@v1
+ with:
+ name: wheels-macos-latest
+ - name: Download macOS binaries
+ uses: actions/download-artifact@v1
+ with:
+ name: bins-macos-latest
+ - name: Download Linux Wheel
+ uses: actions/download-artifact@v1
+ with:
+ name: wheels-ubuntu-latest
+ - name: Download Linux binaries
+ uses: actions/download-artifact@v1
+ with:
+ name: bins-ubuntu-latest
+ - name: Download Windows Wheel
+ uses: actions/download-artifact@v1
+ with:
+ name: wheels-windows-latest
+ - name: Download Windows binaries
+ uses: actions/download-artifact@v1
+ with:
+ name: bins-windows-latest
+
+ - name: Assemble gh-pages
+ run: |
+ mv doc-book gh-pages
+ mv doc-api gh-pages/api
+
+ # If this is a push to the master branch push to the `gh-pages` using a
+ # deploy key. Note that a deploy key is necessary for now because otherwise
+ # using the default token for github actions doesn't actually trigger a page
+ # rebuild.
+ - name: Push to gh-pages
+ run: curl -LsSf https://git.io/fhJ8n | rustc - && (cd gh-pages && ../rust_out)
+ env:
+ GITHUB_DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
+ BUILD_REPOSITORY_ID: ${{ github.repository }}
+ BUILD_SOURCEVERSION: ${{ github.sha }}
+ if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+
+ - name: Calculate tag name
+ run: |
+ name=dev
+ if [[ $GITHUB_REF == refs/tags* ]]; then
+ name=${GITHUB_REF:10}
+ fi
+ echo ::set-output name=val::$name
+ echo ::set-env name=TAG::$name
+ id: tagname
+
+ # Assemble all the build artifacts into tarballs and zip archives.
+ - name: Assemble tarballs
+ run: |
+ ./ci/build-tarballs.sh x86_64-linux ubuntu-latest
+ ./ci/build-tarballs.sh x86_64-windows windows-latest .exe
+ ./ci/build-tarballs.sh x86_64-macos macos-latest
+
+ # Upload all assembled tarballs as an artifact of the github action run, so
+ # that way even PRs can inspect the output.
+ - uses: actions/upload-artifact@v1
+ with:
+ name: tarballs
+ path: dist
+
+ # The action 'pypa/gh-action-pypi-publish' will try to upload all files in the
+ # dist/ folder. This folder also contains non-package files, and therefore the
+ # action fails.
+ #
+ # To prevent the action from failing all .whl files are copied into a new
+ # directory.
+ - run: |
+ mkdir -p tmp/whl
+ find dist/ -name '*.whl' -type f -exec cp '{}' tmp/whl -v \;
+
+ - name: Publish Python wheels on Pypi
+ uses: pypa/gh-action-pypi-publish@37e305e7413032d8422456179fee28fac7d25187
+ if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags')
+ with:
+ user: __token__
+ password: ${{ secrets.pypi_password }}
+ packages_dir: tmp/whl
+
+ # ... and if this was an actual push (tag or `master`) then we publish a
+ # new release. This'll automatically publish a tag release or update `dev`
+ # with this `sha`
+ - name: Publish Release
+ uses: ./.github/actions/github-release
+ if: github.event_name == 'push' && (github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags'))
+ with:
+ files: "dist/*"
+ name: ${{ steps.tagname.outputs.val }}
+ token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000..daa279dbaf
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,13 @@
+*.bk
+*.swp
+*.swo
+*.swx
+tags
+target
+.*.rustfmt
+cranelift.dbg*
+rusty-tags.*
+*~
+\#*\#
+docs/book
+.vscode/
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000..59646f986c
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,9 @@
+[submodule "spec_testsuite"]
+ path = tests/spec_testsuite
+ url = https://github.com/WebAssembly/testsuite
+[submodule "crates/c-api/examples/wasm-c-api"]
+ path = crates/c-api/examples/wasm-c-api
+ url = https://github.com/WebAssembly/wasm-c-api
+[submodule "crates/wasi-common/WASI"]
+ path = crates/wasi-common/wig/WASI
+ url = https://github.com/WebAssembly/WASI
diff --git a/.rustfmt.toml b/.rustfmt.toml
new file mode 100644
index 0000000000..8148fc6346
--- /dev/null
+++ b/.rustfmt.toml
@@ -0,0 +1 @@
+# This file tells tools we use rustfmt. We use the default settings.
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000..b671a33264
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,49 @@
+# Contributor Covenant Code of Conduct
+
+*Note*: this Code of Conduct pertains to individuals' behavior. Please also see the [Organizational Code of Conduct][OCoC].
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the Bytecode Alliance CoC team at [report@bytecodealliance.org](mailto:report@bytecodealliance.org). The CoC team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The CoC team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the Bytecode Alliance's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[OCoC]: https://github.com/bytecodealliance/wasmtime/blob/master/ORG_CODE_OF_CONDUCT.md
+[homepage]: https://www.contributor-covenant.org
+[version]: https://www.contributor-covenant.org/version/1/4/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000000..ba67ac54da
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,13 @@
+# Contributing to Wasmtime
+
+Wasmtime is a [Bytecode Alliance] project, and follows the Bytecode Alliance's [Code of Conduct] and [Organizational Code of Conduct].
+
+Wasmtime follows the same development style as Cranelift, so check out
+[Cranelift's CONTRIBUTING.md]. Of course, for Wasmtime-specific issues, please
+use the [Wasmtime issue tracker].
+
+[Bytecode Alliance]: https://bytecodealliance.org/
+[Code of Conduct]: CODE_OF_CONDUCT.md
+[Organizational Code of Conduct]: ORG_CODE_OF_CONDUCT.md
+[Cranelift's CONTRIBUTING.md]: https://github.com/bytecodealliance/cranelift/blob/master/CONTRIBUTING.md
+[Wasmtime issue tracker]: https://github.com/bytecodealliance/wasmtime/issues/new
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000000..1df0ef9d1b
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,2376 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "adler32"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d2e7343e7fc9de883d1b0341e0b13970f764c14101234857d2ddafa1cb1cac2"
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743ad5a418686aad3b87fd14c43badd828cf26e214a00f92a384291cf22e1811"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7825f6833612eb2414095684fcf6c635becf3ce97fe48cf6421321e93bfbd53c"
+
+[[package]]
+name = "arbitrary"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64cf76cb6e2222ed0ea86b2b0ee2f71c96ec6edd5af42e84d59160e91b836ec4"
+
+[[package]]
+name = "arbitrary"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "491d5e42b1a073ff1fc1e0a02744b3f8bee9cf4bfd552053cac36c64b879795d"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+
+[[package]]
+name = "arrayvec"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
+
+[[package]]
+name = "backtrace"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4036b9bf40f3cf16aba72a3d65e8a520fc4bafcdc7079aea8f848c58c5b5536"
+dependencies = [
+ "backtrace-sys",
+ "cfg-if",
+ "libc",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "backtrace-sys"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d6575f128516de27e3ce99689419835fce9643a9b215a14d2b5b685be018491"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "base64"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"
+
+[[package]]
+name = "binaryen"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a51ad23b3c7ab468d9daa948201921879ef0052e561c250fd0b326e6f000f2dd"
+dependencies = [
+ "binaryen-sys",
+]
+
+[[package]]
+name = "binaryen-sys"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "023e318da5cf481b0d243295d3ca764a047f645f1d46ef7bb67263473e8c48c5"
+dependencies = [
+ "bindgen",
+ "cc",
+ "cmake",
+ "heck",
+ "regex",
+]
+
+[[package]]
+name = "bincode"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5753e2a71534719bf3f4e57006c3a4f0d2c672a4b676eec84161f763eca87dbf"
+dependencies = [
+ "byteorder",
+ "serde",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1c85344eb535a31b62f0af37be84441ba9e7f0f4111eb0530f43d15e513fe57"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "cfg-if",
+ "clang-sys",
+ "clap",
+ "env_logger 0.7.1",
+ "lazy_static",
+ "lazycell",
+ "log",
+ "peeking_take_while",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "which",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+
+[[package]]
+name = "blake2b_simd"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8fb2d74254a3a0b5cac33ac9f8ed0e44aa50378d9dbb2e5d83bd21ed1dc2c8a"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
+dependencies = [
+ "block-padding",
+ "byte-tools",
+ "byteorder",
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
+dependencies = [
+ "byte-tools",
+]
+
+[[package]]
+name = "byte-tools"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+
+[[package]]
+name = "byteorder"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+
+[[package]]
+name = "c2-chacha"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb"
+dependencies = [
+ "ppv-lite86",
+]
+
+[[package]]
+name = "capstone"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "031ba51c39151a1d6336ec859646153187204b0147c7b3f6fe2de636f1b8dbb3"
+dependencies = [
+ "capstone-sys",
+]
+
+[[package]]
+name = "capstone-sys"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fae25eddcb80e24f98c35952c37a91ff7f8d0f60dbbdafb9763e8d5cc566b8d7"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95e28fa049fda1c330bcf9d723be7663a899c4679724b34c81e9f5a326aab8cd"
+dependencies = [
+ "jobserver",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fce5b5fb86b0c57c20c834c1b412fd09c77c8a59b9473f86272709e78874cd1d"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "chrono"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31850b4a4d6bae316f7a09e691c944c28299298837edc0a03f755618c23cbc01"
+dependencies = [
+ "num-integer",
+ "num-traits",
+ "time",
+]
+
+[[package]]
+name = "clang-sys"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81de550971c976f176130da4b2978d3b524eaa0fd9ac31f3ceb5ae1231fb4853"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "clap"
+version = "2.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
+[[package]]
+name = "cmake"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81fb25b677f8bf1eb325017cb6bb8452f87969db0fedb4f757b297bee78a7c62"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+
+[[package]]
+name = "cpu-time"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9e393a7668fe1fad3075085b86c781883000b4ede868f43627b34a87c8b7ded"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "cranelift-bforest"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45a9c21f8042b9857bda93f6c1910b9f9f24100187a3d3d52f214a34e3dc5818"
+dependencies = [
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-codegen"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7853f77a6e4a33c67a69c40f5e1bb982bd2dc5c4a22e17e67b65bbccf9b33b2e"
+dependencies = [
+ "byteorder",
+ "cranelift-bforest",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-entity",
+ "gimli",
+ "log",
+ "serde",
+ "smallvec",
+ "target-lexicon",
+ "thiserror",
+]
+
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "084cd6d5fb0d1da28acd72c199471bfb09acc703ec8f3bf07b1699584272a3b9"
+dependencies = [
+ "cranelift-codegen-shared",
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "701b599783305a58c25027a4d73f2d6b599b2d8ef3f26677275f480b4d51e05d"
+
+[[package]]
+name = "cranelift-entity"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b88e792b28e1ebbc0187b72ba5ba880dad083abe9231a99d19604d10c9e73f38"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cranelift-frontend"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "518344698fa6c976d853319218415fdfb4f1bc6b42d0b2e2df652e55dff1f778"
+dependencies = [
+ "cranelift-codegen",
+ "log",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-native"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32daf082da21c0c05d93394ff4842c2ab7c4991b1f3186a1d952f8ac660edd0b"
+dependencies = [
+ "cranelift-codegen",
+ "raw-cpuid",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-wasm"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2aa816f554a3ef739a5d17ca3081a1f8983f04c944ea8ff60fb8d9dd8cd2d7b"
+dependencies = [
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "log",
+ "serde",
+ "thiserror",
+ "wasmparser 0.51.2",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba125de2af0df55319f41944744ad91c71113bf74a4646efff39afe1f6842db1"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "maybe-uninit",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+ "lazy_static",
+ "maybe-uninit",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c695eeca1e7173472a32221542ae469b3e9aac3a4fc81f7696bcad82029493db"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "lazy_static",
+]
+
+[[package]]
+name = "ctor"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd8ce37ad4184ab2ce004c33bf6379185d3b1c95801cab51026bd271bf68eedc"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cvt"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ac344c7efccb80cd25bc61b2170aec26f2f693fd40e765a539a1243db48c71"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dab2f0544254a47cabc58956cc7ebda74c3b796bb2761e3fe8f29fdde632ad95"
+dependencies = [
+ "proc-macro2",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+
+[[package]]
+name = "digest"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "directories"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "551a778172a450d7fc12e629ca3b0428d00f6afa9a43da1b630d54604e97371c"
+dependencies = [
+ "cfg-if",
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afa0b23de8fd801745c471deffa6e12d248f962c9fd4b4c33787b055599bde7b"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "dynasm"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42a814e1edeb85dd2a3c6fc0d6bf76d02ca5695d438c70ecee3d90774f3259c5"
+dependencies = [
+ "bitflags",
+ "byteorder",
+ "lazy_static",
+ "owning_ref",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dynasmrt"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a393aaeb4441a48bcf47b5b6155971f82cc1eb77e22855403ccc0415ac8328d"
+dependencies = [
+ "byteorder",
+ "memmap",
+]
+
+[[package]]
+name = "either"
+version = "1.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3"
+
+[[package]]
+name = "env_logger"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aafcde04e90a5226a6443b7aabdb016ba2f8307c847d524724bd9b346dd1a2d3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "errno"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a071601ed01b988f896ab14b95e67335d1eeb50190932a1320f7fe3cadc84e"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14ca354e36190500e1e1fb267c647932382b54053c50b14970856c0b00a35067"
+dependencies = [
+ "gcc",
+ "libc",
+]
+
+[[package]]
+name = "faerie"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74b9ed6159e4a6212c61d9c6a86bee01876b192a64accecf58d5b5ae3b667b52"
+dependencies = [
+ "anyhow",
+ "goblin",
+ "indexmap",
+ "log",
+ "scroll",
+ "string-interner",
+ "target-lexicon",
+ "thiserror",
+]
+
+[[package]]
+name = "failure"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8273f13c977665c5db7eb2b99ae520952fe5ac831ae4cd09d80c4c7042b5ed9"
+dependencies = [
+ "backtrace",
+ "failure_derive",
+]
+
+[[package]]
+name = "failure_derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bc225b78e0391e4b8683440bf2e63c2deeeb2ce5189eab46e2b68c6d3725d08"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "fake-simd"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+
+[[package]]
+name = "fallible-iterator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+
+[[package]]
+name = "file-per-thread-logger"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8505b75b31ef7285168dd237c4a7db3c1f3e0927e7d314e670bc98e854272fe9"
+dependencies = [
+ "env_logger 0.6.2",
+ "log",
+]
+
+[[package]]
+name = "filecheck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded7985594ab426ef685362e5183168eb3b5aacc9f4e26819e8d82d224f33449"
+dependencies = [
+ "failure",
+ "failure_derive",
+ "regex",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ff6d4dab0aa0c8e6346d46052e93b13a16cf847b54ed357087c35011048cc7d"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "winapi",
+]
+
+[[package]]
+name = "flate2"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd6d6f4752952feb71363cffc9ebac9411b75b87c6ab6058c40c8900cf43c0f"
+dependencies = [
+ "cfg-if",
+ "crc32fast",
+ "libc",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "gcc"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2"
+
+[[package]]
+name = "generic-array"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "ghost"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a36606a68532b5640dc86bb1f33c64b45c4682aad4c50f3937b317ea387f3d6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "gimli"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81dd6190aad0f05ddbbf3245c54ed14ca4aa6dd32f22312b70d8f168c3e3e633"
+dependencies = [
+ "arrayvec",
+ "byteorder",
+ "fallible-iterator",
+ "indexmap",
+ "smallvec",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+
+[[package]]
+name = "goblin"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3081214398d39e4bd7f2c1975f0488ed04614ffdd976c6fc7a0708278552c0da"
+dependencies = [
+ "log",
+ "plain",
+ "scroll",
+]
+
+[[package]]
+name = "heck"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2c55f143919fbc0bc77e427fe2d74cf23786d7c1875666f2fde3ac3c659bb67"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+dependencies = [
+ "quick-error",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
+
+[[package]]
+name = "indexmap"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "076f042c5b7b98f31d205f1249267e12a6518c1481e9dae9764af19b707d2292"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "indoc"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9553c1e16c114b8b77ebeb329e5f2876eed62a8d51178c8bc6bff0d65f98f8"
+dependencies = [
+ "indoc-impl",
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "indoc-impl"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b714fc08d0961716390977cdff1536234415ac37b509e34e5a983def8340fb75"
+dependencies = [
+ "proc-macro-hack",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "unindent",
+]
+
+[[package]]
+name = "inventory"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf98296081bd2cb540acc09ef9c97f22b7e487841520350293605db1b2c7a27"
+dependencies = [
+ "ctor",
+ "ghost",
+ "inventory-impl",
+]
+
+[[package]]
+name = "inventory-impl"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a8e30575afe28eea36a9a39136b70b2fb6b0dd0a212a5bd1f30a498395c0274"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "itertools"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f56a2d0bc861f9165be4eb3442afd3c236d8a98afd426f65d92324ae1091a484"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8b7a7c0c47db5545ed3fef7468ee7bb5b74691498139e4b3f6a20685dc6dd8e"
+
+[[package]]
+name = "jobserver"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
+
+[[package]]
+name = "leb128"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
+
+[[package]]
+name = "libc"
+version = "0.2.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb147597cdf94ed43ab7a9038716637d2d1bf2bc571da995d0028dec06bd3018"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e969cd2be7a2aae0acbbe205da49134148db2287fb45a811bf441ed72f09a35"
+dependencies = [
+ "arbitrary 0.3.3",
+ "cc",
+]
+
+[[package]]
+name = "libloading"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b111a074963af1d37a139918ac6d49ad1d0d5e47f72fd55388619691a7d753"
+dependencies = [
+ "cc",
+ "winapi",
+]
+
+[[package]]
+name = "lightbeam"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "capstone",
+ "cranelift-codegen",
+ "dynasm",
+ "dynasmrt",
+ "either",
+ "itertools",
+ "lazy_static",
+ "memoffset",
+ "more-asserts",
+ "multi_mut",
+ "quickcheck",
+ "smallvec",
+ "thiserror",
+ "typemap",
+ "wasmparser 0.51.2",
+ "wat",
+]
+
+[[package]]
+name = "log"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "mach"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86dd2487cdfea56def77b88438a2c915fb45113c5319bfe7e14306ca4cd0b0e1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "maybe-uninit"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+
+[[package]]
+name = "memchr"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
+
+[[package]]
+name = "memmap"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75189eb85871ea5c2e2c15abbdd541185f63b408415e5051f5cac122d8c774b9"
+dependencies = [
+ "rustc_version",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa679ff6578b1cddee93d7e82e263b94a575e0bfced07284eb0c037c1d2416a5"
+dependencies = [
+ "adler32",
+]
+
+[[package]]
+name = "more-asserts"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0debeb9fcf88823ea64d64e4a815ab1643f33127d995978e099942ce38f25238"
+
+[[package]]
+name = "multi_mut"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "816df386e5557ac1843a96f1ba8a7cbf4ab175d05ccc15c87a3cda27b4fbdece"
+
+[[package]]
+name = "nom"
+version = "4.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6"
+dependencies = [
+ "memchr",
+ "version_check 0.1.5",
+]
+
+[[package]]
+name = "num"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8536030f9fea7127f841b45bb6243b27255787fb4eb83958aa1ef9d2fdc0c36"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6b19411a9719e753aff12e5187b74d60d3dc449ec3f4dc21e3989c3f554bc95"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6ea62e9d81a77cd3ee9a2a5b9b609447857f3d358704331e4ef39eb247fcba"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfb0800a0291891dd9f4fe7bd9c19384f98f7fbe0cd0f39a2c6b88b9868bbc00"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da4dc79f9e6c81bef96148c8f6b8e72ad4541caa4a24373e900a36da07de03a3"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62be47e61d1842b9170f0fdeec8eba98e60e90e5446449a0545e5152acd7096"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46203554f085ff89c235cd12f7075f3233af9b11ed7c9e16dfe2560d03313ce6"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "object"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea44a4fd660ab0f38434934ca0212e90fbeaaee54126ef20a3451c30c95bafae"
+dependencies = [
+ "flate2",
+ "goblin",
+ "parity-wasm",
+ "scroll",
+ "target-lexicon",
+ "uuid",
+]
+
+[[package]]
+name = "opaque-debug"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
+
+[[package]]
+name = "os_pipe"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db4d06355a7090ce852965b2d08e11426c315438462638c6d721448d0b47aa22"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "owning_ref"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
+dependencies = [
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "parity-wasm"
+version = "0.41.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddfc878dac00da22f8f61e7af3157988424567ab01d9920b962ef7dcbd7cd865"
+
+[[package]]
+name = "paste"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "423a519e1c6e828f1e73b720f9d9ed2fa643dce8a7737fb43235ce0b41eeaa49"
+dependencies = [
+ "paste-impl",
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "paste-impl"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4214c9e912ef61bf42b81ba9a47e8aad1b2ffaf739ab162bf96d1e011f54e6c5"
+dependencies = [
+ "proc-macro-hack",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b"
+
+[[package]]
+name = "pretty_env_logger"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "717ee476b1690853d222af4634056d830b5197ffd747726a9a1eee6da9f49074"
+dependencies = [
+ "chrono",
+ "env_logger 0.6.2",
+ "log",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "052b3c9af39c7e5e94245f820530487d19eb285faedcb40e0c3275132293f242"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d175bef481c7902e63e3165627123fff3502f06ac043d3ef42d08c1246da9253"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+ "syn-mid",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecd45702f76d6d3c75a80564378ae228a85f0b59d2f3ed43c91b4a69eb2ebfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acb317c6ff86a4e579dfa00fc5e6cca91ecbb4e7eb2df0468805b674eb88548"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1bfe257586436fbe1296d917f14a167d4253d0873bf43e2c9b9bdd58a3f9f35"
+dependencies = [
+ "indoc",
+ "inventory",
+ "lazy_static",
+ "libc",
+ "num-traits",
+ "paste",
+ "pyo3cls",
+ "regex",
+ "serde",
+ "serde_json",
+ "spin",
+ "unindent",
+ "version_check 0.9.1",
+]
+
+[[package]]
+name = "pyo3-derive-backend"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4882d8237fd8c7373cc25cb802fe0dab9ff70830fd56f47ef6c7f3f287fcc057"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3cls"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdf321cfab555f7411298733c86d21e5136f5ded13f5872fabf9de3337beecda"
+dependencies = [
+ "proc-macro2",
+ "pyo3-derive-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quickcheck"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a44883e74aa97ad63db83c4bf8ca490f02b2fc02f92575e720c8551e843c945f"
+dependencies = [
+ "env_logger 0.7.1",
+ "log",
+ "rand",
+ "rand_core",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom",
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+ "rand_pcg",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853"
+dependencies = [
+ "c2-chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_pcg"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "raw-cpuid"
+version = "7.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4a349ca83373cfa5d6dbb66fd76e58b2cca08da71a5f6400de0a0a6a9bceeaf"
+dependencies = [
+ "bitflags",
+ "cc",
+ "rustc_version",
+]
+
+[[package]]
+name = "rayon"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db6ce3297f9c85e16621bb8cca38a06779ffc31bb8184e1be4bed2be4678a098"
+dependencies = [
+ "crossbeam-deque",
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08a89b46efaf957e52b18062fb2f4660f8b8a4dde1807ca002690868ef2c85a9"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-queue",
+ "crossbeam-utils",
+ "lazy_static",
+ "num_cpus",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
+
+[[package]]
+name = "redox_users"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09b23093265f8d200fa7b4c2c76297f47e681c655f6f1285a8780d6a022f7431"
+dependencies = [
+ "getrandom",
+ "redox_syscall",
+ "rust-argon2",
+]
+
+[[package]]
+name = "regex"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322cf97724bea3ee221b78fe25ac9c46114ebb51747ad5babd51a2fc6a8235a8"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+ "thread_local",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b28dfe3fe9badec5dbf0a79a9cccad2cfc2ab5484bdb3e44cbd1ae8b3ba2be06"
+
+[[package]]
+name = "region"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "448e868c6e4cfddfa49b6a72c95906c04e8547465e9536575b95c70a4044f856"
+dependencies = [
+ "bitflags",
+ "libc",
+ "mach",
+ "winapi",
+]
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a83fa3702a688b9359eccba92d153ac33fd2e8462f9e0e3fdf155239ea7792e"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "rust-argon2"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bc8af4bda8e1ff4932523b94d3dd20ee30a87232323eda55903ffd71d2fb017"
+dependencies = [
+ "base64",
+ "blake2b_simd",
+ "constant_time_eq",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3bba175698996010c4f6dce5e7f173b6eb781fce25d2cfc45e27091ce0b79f6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa8506c1de11c9c4e4c38863ccbe02a305c8188e85a05a784c9e11e1c3910c8"
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "scroll"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abb2332cb595d33f7edd5700f4cbf94892e680c7f0ae56adab58a35190b66cb1"
+dependencies = [
+ "scroll_derive",
+]
+
+[[package]]
+name = "scroll_derive"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8584eea9b9ff42825b46faf46a8c24d2cff13ec152fa2a50df788b87c07ee28"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+
+[[package]]
+name = "serde"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414115f25f818d7dfccec8ee535d76949ae78584fc4f79a6f45a904bf8ab4449"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "128f9e303a5a29922045a830221b8f78ec74a5f544944f3d5984f8ec3895ef64"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9371ade75d4c2d6cb154141b9752cf3781ec9c05e0e5cf35060e1e70ee7b9c25"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27044adfd2e1f077f649f59deb9490d3941d674002f7d062870a60ebe9bd47a0"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "fake-simd",
+ "opaque-debug",
+]
+
+[[package]]
+name = "shlex"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fdf1b9db47230893d76faad238fd6097fd6d6a9245cd7a4d90dbd639536bbd2"
+
+[[package]]
+name = "smallvec"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2fb2ec9bcd216a5b0d0ccf31ab17b5ed1d627960edff65bbe95d3ce221cefc"
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
+
+[[package]]
+name = "string-interner"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd710eadff449a1531351b0e43eb81ea404336fa2f56c777427ab0e32a4cf183"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "structopt"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1bcbed7d48956fcbb5d80c6b95aedb553513de0a1b451ea92679d999c010e98"
+dependencies = [
+ "clap",
+ "lazy_static",
+ "structopt-derive",
+]
+
+[[package]]
+name = "structopt-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "095064aa1f5b94d14e635d0a5684cf140c43ae40a0fd990708d38f5d669e5f64"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0294dc449adc58bb6592fff1a23d3e5e6e235afc6a0ffca2657d19e7bbffe5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "syn-mid"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7be3539f6c128a931cf19dcee741c1af532c7fd387baa739c03dd2e96479338a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67656ea1dc1b41b1451851562ea232ec2e5a80242139f7e679ceccfb5d61f545"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "unicode-xid",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab0e7238dcc7b40a7be719a25365910f6807bd864f4cce6b2e6b873658e2b19d"
+
+[[package]]
+name = "tempfile"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "rand",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "test-programs"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "os_pipe",
+ "pretty_env_logger",
+ "target-lexicon",
+ "tempfile",
+ "wasi-common",
+ "wasmtime",
+ "wasmtime-wasi",
+ "wat",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee14bf8e6767ab4c687c9e8bc003879e042a96fd67a3ba5934eadb6536bef4db"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7b51e1fbc44b5a0840be594fbc0f960be09050f2617e61e6aa43bef97cd3ef4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "time"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
+dependencies = [
+ "libc",
+ "redox_syscall",
+ "winapi",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "traitobject"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efd1f82c56340fdf16f2a953d7bda4f8fdffba13d93b00844c25572110b26079"
+
+[[package]]
+name = "typemap"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "653be63c80a3296da5551e1bfd2cca35227e13cdd08c6668903ae2f4f77aa1f6"
+dependencies = [
+ "unsafe-any",
+]
+
+[[package]]
+name = "typenum"
+version = "1.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d2783fe2d6b8c1101136184eb41be8b1ad379e4657050b8aaff0c79ee7575f9"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caaa9d531767d1ff2150b9332433f32a24622147e5ebb1f26409d5da67afd479"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+
+[[package]]
+name = "unindent"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63f18aa3b0e35fed5a0048f029558b1518095ffe2a0a31fb87c93dece93a4993"
+
+[[package]]
+name = "unsafe-any"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f30360d7979f5e9c6e6cea48af192ea8fab4afb3cf72597154b8f08935bc9c7f"
+dependencies = [
+ "traitobject",
+]
+
+[[package]]
+name = "uuid"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fde2f6a4bea1d6e007c4ad38c6839fa71cbb63b6dbf5b595aa38dc9b1093c11"
+
+[[package]]
+name = "vec_map"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
+
+[[package]]
+name = "version_check"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
+
+[[package]]
+name = "version_check"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078775d0255232fb988e6fccf26ddc9d1ac274299aaedcedce21c6f72cc533ce"
+
+[[package]]
+name = "walrus"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84651d7b04ebbecf715a28859d1dc5053b98c6a5a20bd7343d8f015947b86481"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "leb128",
+ "log",
+ "walrus-macro",
+ "wasmparser 0.48.2",
+]
+
+[[package]]
+name = "walrus-macro"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b1845ca33b1fcec5624f0e5ea617e41a8adea37f71eb117d3ff81a089d5e3f9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi-common"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cpu-time",
+ "filetime",
+ "getrandom",
+ "lazy_static",
+ "libc",
+ "log",
+ "num",
+ "thiserror",
+ "wig",
+ "winapi",
+ "winx",
+ "yanix",
+]
+
+[[package]]
+name = "wasm-webidl-bindings"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42298d64a28700ecd5aa47d8037bcf832b7be0c88ad6b272ebb5d92d7e052a8c"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "leb128",
+ "walrus",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "073da89bf1c84db000dd68ce660c1b4a08e3a2d28fd1e3394ab9e7abdde4a0f8"
+
+[[package]]
+name = "wasmparser"
+version = "0.51.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a40d24f114a3f24b459ec292019220cff6388673b4a2c0a11483665b599ef15c"
+
+[[package]]
+name = "wasmprinter"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bd423d45b95fcee11775472bfdce66c63c45ada23c1b338e0a63d623a6c475b"
+dependencies = [
+ "anyhow",
+ "wasmparser 0.51.2",
+]
+
+[[package]]
+name = "wasmtime"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "backtrace",
+ "cfg-if",
+ "file-per-thread-logger",
+ "lazy_static",
+ "libc",
+ "pretty_env_logger",
+ "rayon",
+ "region",
+ "rustc-demangle",
+ "target-lexicon",
+ "tempfile",
+ "wasi-common",
+ "wasmparser 0.51.2",
+ "wasmtime-environ",
+ "wasmtime-jit",
+ "wasmtime-profiling",
+ "wasmtime-runtime",
+ "wat",
+ "winapi",
+]
+
+[[package]]
+name = "wasmtime-c-api"
+version = "0.12.0"
+dependencies = [
+ "wasi-common",
+ "wasmtime",
+ "wasmtime-wasi",
+]
+
+[[package]]
+name = "wasmtime-cli"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "faerie",
+ "file-per-thread-logger",
+ "filecheck",
+ "libc",
+ "more-asserts",
+ "pretty_env_logger",
+ "rayon",
+ "structopt",
+ "target-lexicon",
+ "tempfile",
+ "test-programs",
+ "wasi-common",
+ "wasm-webidl-bindings",
+ "wasmtime",
+ "wasmtime-debug",
+ "wasmtime-environ",
+ "wasmtime-interface-types",
+ "wasmtime-jit",
+ "wasmtime-obj",
+ "wasmtime-profiling",
+ "wasmtime-runtime",
+ "wasmtime-wasi",
+ "wasmtime-wast",
+ "wat",
+]
+
+[[package]]
+name = "wasmtime-debug"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "faerie",
+ "gimli",
+ "more-asserts",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser 0.51.2",
+ "wasmtime-environ",
+]
+
+[[package]]
+name = "wasmtime-environ"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "base64",
+ "bincode",
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-wasm",
+ "directories",
+ "errno",
+ "file-per-thread-logger",
+ "filetime",
+ "indexmap",
+ "lazy_static",
+ "libc",
+ "lightbeam",
+ "log",
+ "more-asserts",
+ "pretty_env_logger",
+ "rand",
+ "rayon",
+ "serde",
+ "sha2",
+ "target-lexicon",
+ "tempfile",
+ "thiserror",
+ "toml",
+ "wasmparser 0.51.2",
+ "winapi",
+ "zstd",
+]
+
+[[package]]
+name = "wasmtime-fuzz"
+version = "0.12.0"
+dependencies = [
+ "arbitrary 0.2.0",
+ "libfuzzer-sys",
+ "wasmtime",
+ "wasmtime-fuzzing",
+]
+
+[[package]]
+name = "wasmtime-fuzzing"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "arbitrary 0.3.3",
+ "binaryen",
+ "env_logger 0.7.1",
+ "log",
+ "wasmparser 0.51.2",
+ "wasmprinter",
+ "wasmtime",
+ "wat",
+]
+
+[[package]]
+name = "wasmtime-interface-types"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "walrus",
+ "wasm-webidl-bindings",
+ "wasmparser 0.51.2",
+ "wasmtime",
+ "wasmtime-environ",
+ "wasmtime-jit",
+ "wasmtime-runtime",
+ "wasmtime-wasi",
+]
+
+[[package]]
+name = "wasmtime-jit"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "cranelift-wasm",
+ "more-asserts",
+ "region",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser 0.51.2",
+ "wasmtime-debug",
+ "wasmtime-environ",
+ "wasmtime-profiling",
+ "wasmtime-runtime",
+ "winapi",
+]
+
+[[package]]
+name = "wasmtime-obj"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "faerie",
+ "more-asserts",
+ "wasmtime-environ",
+]
+
+[[package]]
+name = "wasmtime-profiling"
+version = "0.12.0"
+dependencies = [
+ "gimli",
+ "goblin",
+ "lazy_static",
+ "libc",
+ "object",
+ "scroll",
+ "serde",
+ "target-lexicon",
+]
+
+[[package]]
+name = "wasmtime-py"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "pyo3",
+ "region",
+ "target-lexicon",
+ "wasmparser 0.51.2",
+ "wasmtime",
+ "wasmtime-interface-types",
+ "wasmtime-wasi",
+]
+
+[[package]]
+name = "wasmtime-runtime"
+version = "0.12.0"
+dependencies = [
+ "backtrace",
+ "cc",
+ "cfg-if",
+ "indexmap",
+ "libc",
+ "memoffset",
+ "more-asserts",
+ "region",
+ "thiserror",
+ "wasmtime-environ",
+ "wasmtime-profiling",
+ "winapi",
+]
+
+[[package]]
+name = "wasmtime-rust"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "wasmtime",
+ "wasmtime-interface-types",
+ "wasmtime-rust-macro",
+ "wasmtime-wasi",
+]
+
+[[package]]
+name = "wasmtime-rust-macro"
+version = "0.12.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "wasmtime-wasi"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "log",
+ "wasi-common",
+ "wasmtime",
+ "wasmtime-runtime",
+ "wig",
+]
+
+[[package]]
+name = "wasmtime-wast"
+version = "0.12.0"
+dependencies = [
+ "anyhow",
+ "wasmtime",
+ "wast 9.0.0",
+]
+
+[[package]]
+name = "wast"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233648f540f07fce9b972436f2fbcae8a750c1121b6d32d949e1a44b4d9fc7b1"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wast"
+version = "9.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee7b16105405ca2aa2376ba522d8d4b1a11604941dd3bb7df9fd2ece60f8d16a"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wat"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56173f7f4fb59aebe35a7e71423845e1c6c7144bfb56362d497931b6b3bed0f6"
+dependencies = [
+ "wast 9.0.0",
+]
+
+[[package]]
+name = "which"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5475d47078209a02e60614f7ba5e645ef3ed60f771920ac1906d7c1cc65024c8"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "wig"
+version = "0.12.0"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "witx",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ccfbf554c6ad11084fb7517daca16cfdcaccbdadba4fc336f032a8b12c2ad80"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "winx"
+version = "0.12.0"
+dependencies = [
+ "bitflags",
+ "cvt",
+ "winapi",
+]
+
+[[package]]
+name = "witx"
+version = "0.8.0"
+dependencies = [
+ "anyhow",
+ "diff",
+ "log",
+ "pretty_env_logger",
+ "structopt",
+ "thiserror",
+ "wast 3.0.4",
+]
+
+[[package]]
+name = "yanix"
+version = "0.12.0"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "log",
+ "thiserror",
+]
+
+[[package]]
+name = "zstd"
+version = "0.5.1+zstd.1.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c5d978b793ae64375b80baf652919b148f6a496ac8802922d9999f5a553194f"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "2.0.3+zstd.1.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee25eac9753cfedd48133fa1736cbd23b774e253d89badbeac7d12b23848d3f"
+dependencies = [
+ "libc",
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "1.4.15+zstd.1.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89719b034dc22d240d5b407fb0a3fe6d29952c181cff9a9f95c0bd40b4f8f7d8"
+dependencies = [
+ "cc",
+ "glob",
+ "libc",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000000..6aa979ad64
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,83 @@
+[package]
+name = "wasmtime-cli"
+version = "0.12.0"
+authors = ["The Wasmtime Project Developers"]
+description = "Command-line interface for Wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+documentation = "https://cranelift.readthedocs.io/"
+categories = ["wasm"]
+keywords = ["webassembly", "wasm"]
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+edition = "2018"
+default-run = "wasmtime"
+publish = false
+
+[lib]
+doctest = false
+
+[[bin]]
+name = "wasmtime"
+path = "src/bin/wasmtime.rs"
+doc = false
+
+[dependencies]
+# Enable all supported architectures by default.
+wasmtime = { path = "crates/api" }
+wasmtime-debug = { path = "crates/debug" }
+wasmtime-environ = { path = "crates/environ" }
+wasmtime-interface-types = { path = "crates/interface-types" }
+wasmtime-jit = { path = "crates/jit" }
+wasmtime-obj = { path = "crates/obj" }
+wasmtime-profiling = { path = "crates/profiling" }
+wasmtime-wast = { path = "crates/wast" }
+wasmtime-wasi = { path = "crates/wasi" }
+wasi-common = { path = "crates/wasi-common" }
+structopt = { version = "0.3.5", features = ["color", "suggestions"] }
+faerie = "0.14.0"
+anyhow = "1.0.19"
+target-lexicon = { version = "0.10.0", default-features = false }
+pretty_env_logger = "0.3.0"
+file-per-thread-logger = "0.1.1"
+wat = "1.0.10"
+libc = "0.2.60"
+rayon = "1.2.1"
+wasm-webidl-bindings = "0.8"
+
+[dev-dependencies]
+wasmtime-runtime = { path = "crates/runtime" }
+more-asserts = "0.2.1"
+# This feature requires the wasm32-wasi target be installed. It enables
+# wasm32-wasi integration tests. To enable, run
+# `cargo test --features test-programs`.
+test-programs = { path = "crates/test-programs" }
+tempfile = "3.1.0"
+filecheck = "0.4.0"
+
+[build-dependencies]
+anyhow = "1.0.19"
+
+[profile.release.build-override]
+opt-level = 0
+
+[workspace]
+members = [
+ "crates/fuzzing",
+ "crates/misc/rust",
+ "crates/misc/py",
+ "crates/c-api",
+ "fuzz",
+]
+
+[features]
+lightbeam = [
+ "wasmtime-environ/lightbeam",
+ "wasmtime-jit/lightbeam",
+ "wasmtime-wast/lightbeam",
+ "wasmtime/lightbeam",
+]
+jitdump = ["wasmtime-profiling/jitdump"]
+test_programs = ["test-programs/test_programs"]
+
+[badges]
+maintenance = { status = "actively-developed" }
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000..f9d81955f4
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,220 @@
+
+ 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/ORG_CODE_OF_CONDUCT.md b/ORG_CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000..6f4fb3f537
--- /dev/null
+++ b/ORG_CODE_OF_CONDUCT.md
@@ -0,0 +1,143 @@
+# Bytecode Alliance Organizational Code of Conduct (OCoC)
+
+*Note*: this Code of Conduct pertains to organizations' behavior. Please also see the [Individual Code of Conduct](CODE_OF_CONDUCT.md).
+
+## Preamble
+
+The Bytecode Alliance (BA) welcomes involvement from organizations,
+including commercial organizations. This document is an
+*organizational* code of conduct, intended particularly to provide
+guidance to commercial organizations. It is distinct from the
+[Individual Code of Conduct (ICoC)](CODE_OF_CONDUCT.md), and does not
+replace the ICoC. This OCoC applies to any group of people acting in
+concert as a BA member or as a participant in BA activities, whether
+or not that group is formally incorporated in some jurisdiction.
+
+The code of conduct described below is not a set of rigid rules, and
+we did not write it to encompass every conceivable scenario that might
+arise. For example, it is theoretically possible there would be times
+when asserting patents is in the best interest of the BA community as
+a whole. In such instances, consult with the BA, strive for
+consensus, and interpret these rules with an intent that is generous
+to the community the BA serves.
+
+While we may revise these guidelines from time to time based on
+real-world experience, overall they are based on a simple principle:
+
+*Bytecode Alliance members should observe the distinction between
+ public community functions and private functions — especially
+ commercial ones — and should ensure that the latter support, or at
+ least do not harm, the former.*
+
+## Guidelines
+
+ * **Do not cause confusion about Wasm standards or interoperability.**
+
+ Having an interoperable WebAssembly core is a high priority for
+ the BA, and members should strive to preserve that core. It is fine
+ to develop additional non-standard features or APIs, but they
+ should always be clearly distinguished from the core interoperable
+ Wasm.
+
+ Treat the WebAssembly name and any BA-associated names with
+ respect, and follow BA trademark and branding guidelines. If you
+ distribute a customized version of software originally produced by
+ the BA, or if you build a product or service using BA-derived
+ software, use names that clearly distinguish your work from the
+ original. (You should still provide proper attribution to the
+ original, of course, wherever such attribution would normally be
+ given.)
+
+ Further, do not use the WebAssembly name or BA-associated names in
+ other public namespaces in ways that could cause confusion, e.g.,
+ in company names, names of commercial service offerings, domain
+ names, publicly-visible social media accounts or online service
+ accounts, etc. It may sometimes be reasonable, however, to
+ register such a name in a new namespace and then immediately donate
+ control of that account to the BA, because that would help the project
+ maintain its identity.
+
+ For further guidance, see the BA Trademark and Branding Policy
+ [TODO: create policy, then insert link].
+
+ * **Do not restrict contributors.** If your company requires
+ employees or contractors to sign non-compete agreements, those
+ agreements must not prevent people from participating in the BA or
+ contributing to related projects.
+
+ This does not mean that all non-compete agreements are incompatible
+ with this code of conduct. For example, a company may restrict an
+ employee's ability to solicit the company's customers. However, an
+ agreement must not block any form of technical or social
+ participation in BA activities, including but not limited to the
+ implementation of particular features.
+
+ The accumulation of experience and expertise in individual persons,
+ who are ultimately free to direct their energy and attention as
+ they decide, is one of the most important drivers of progress in
+ open source projects. A company that limits this freedom may hinder
+ the success of the BA's efforts.
+
+ * **Do not use patents as offensive weapons.** If any BA participant
+ prevents the adoption or development of BA technologies by
+ asserting its patents, that undermines the purpose of the
+ coalition. The collaboration fostered by the BA cannot include
+ members who act to undermine its work.
+
+ * **Practice responsible disclosure** for security vulnerabilities.
+ Use designated, non-public reporting channels to disclose technical
+ vulnerabilities, and give the project a reasonable period to
+ respond, remediate, and patch. [TODO: optionally include the
+ security vulnerability reporting URL here.]
+
+ Vulnerability reporters may patch their company's own offerings, as
+ long as that patching does not significantly delay the reporting of
+ the vulnerability. Vulnerability information should never be used
+ for unilateral commercial advantage. Vendors may legitimately
+ compete on the speed and reliability with which they deploy
+ security fixes, but withholding vulnerability information damages
+ everyone in the long run by risking harm to the BA project's
+ reputation and to the security of all users.
+
+ * **Respect the letter and spirit of open source practice.** While
+ there is not space to list here all possible aspects of standard
+ open source practice, some examples will help show what we mean:
+
+ * Abide by all applicable open source license terms. Do not engage
+ in copyright violation or misattribution of any kind.
+
+ * Do not claim others' ideas or designs as your own.
+
+ * When others engage in publicly visible work (e.g., an upcoming
+ demo that is coordinated in a public issue tracker), do not
+ unilaterally announce early releases or early demonstrations of
+ that work ahead of their schedule in order to secure private
+ advantage (such as marketplace advantage) for yourself.
+
+ The BA reserves the right to determine what constitutes good open
+ source practices and to take action as it deems appropriate to
+ encourage, and if necessary enforce, such practices.
+
+## Enforcement
+
+Instances of organizational behavior in violation of the OCoC may
+be reported by contacting the Bytecode Alliance CoC team at
+[report@bytecodealliance.org](mailto:report@bytecodealliance.org). The
+CoC team will review and investigate all complaints, and will respond
+in a way that it deems appropriate to the circumstances. The CoC team
+is obligated to maintain confidentiality with regard to the reporter of
+an incident. Further details of specific enforcement policies may be
+posted separately.
+
+When the BA deems an organization in violation of this OCoC, the BA
+will, at its sole discretion, determine what action to take. The BA
+will decide what type, degree, and duration of corrective action is
+needed, if any, before a violating organization can be considered for
+membership (if it was not already a member) or can have its membership
+reinstated (if it was a member and the BA canceled its membership due
+to the violation).
+
+In practice, the BA's first approach will be to start a conversation,
+with punitive enforcement used only as a last resort. Violations
+often turn out to be unintentional and swiftly correctable with all
+parties acting in good faith.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000..afac75192a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,99 @@
+
+
+## Installation
+
+The Wasmtime CLI can be installed on Linux and macOS with a small install
+script:
+
+```sh
+$ curl https://wasmtime.dev/install.sh -sSf | bash
+```
+
+Windows or otherwise interested users can download installers and
+binaries directly from the [GitHub
+Releases](https://github.com/bytecodealliance/wasmtime/releases) page.
+
+## Example
+
+If you've got the [Rust compiler
+installed](https://www.rust-lang.org/tools/install) then you can take some Rust
+source code:
+
+```rust
+fn main() {
+ println!("Hello, world!");
+}
+```
+
+and compile/run it with:
+
+```sh
+$ rustup target add wasm32-wasi
+$ rustc hello.rs --target wasm32-wasi
+$ wasmtime hello.wasm
+Hello, world!
+```
+
+## Features
+
+* **Lightweight**. Wasmtime is a standalone runtime for WebAssembly that scales
+ with your needs. It fits on tiny chips as well as makes use of huge servers.
+ Wasmtime can be embedded into almost any application too.
+
+* **Fast**. Wasmtime is built on the optimizing Cranelift code generator to
+ quickly generate high-quality machine code at runtime.
+
+* **Configurable**. Whether you need to precompile your wasm ahead of time,
+ generate code blazingly fast with Lightbeam, or interpret it at runtime,
+ Wasmtime has you covered for all your wasm-executing needs.
+
+* **WASI**. Wasmtime supports a rich set of APIs for interacting with the host
+ environment through the [WASI standard](https://wasi.dev).
+
+* **Standards Compliant**. Wasmtime passes the [official WebAssembly test
+ suite](https://github.com/WebAssembly/testsuite), implements the [official C
+ API of wasm](https://github.com/WebAssembly/wasm-c-api), and implements
+ [future proposals to WebAssembly](https://github.com/WebAssembly/proposals) as
+ well. Wasmtime developers are intimately engaged with the WebAssembly
+ standards process all along the way too.
+
+## Documentation
+
+[📚 Read the Wasmtime guide here! 📚][guide]
+
+The [wasmtime guide][guide] is the best starting point to learn about what
+Wasmtime can do for you or help answer your questions about Wasmtime. If you're
+curious in contributing to Wasmtime, [it can also help you do
+that][contributing]!.
+
+[contributing]: https://bytecodealliance.github.io/wasmtime/contributing.html
+[guide]: https://bytecodealliance.github.io/wasmtime
+
+---
+
+It's Wasmtime.
diff --git a/RELEASES.md b/RELEASES.md
new file mode 100644
index 0000000000..202f673e51
--- /dev/null
+++ b/RELEASES.md
@@ -0,0 +1,50 @@
+# Wasmtime Releases
+
+--------------------------------------------------------------------------------
+
+## 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)
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000..3513b9cb35
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,29 @@
+# Security Policy
+
+Building secure foundations for software development is at the core of what we do in the Bytecode Alliance. Contributions of external security researchers are a vital part of that.
+
+## Scope
+
+If you believe you've found a security issue in any website, service, or software owned or operated by the Bytecode Alliance, we encourage you to notify us.
+
+## How to Submit a Report
+
+To submit a vulnerability report to the Bytecode Alliance, please contact us at [security@bytecodealliance.org](mailto:security@bytecodealliance.org). Your submission will be reviewed and validated by a member of our security team.
+
+## Safe Harbor
+
+The Bytecode Alliance supports safe harbor for security researchers who:
+
+* Make a good faith effort to avoid privacy violations, destruction of data, and interruption or degradation of our services.
+* Only interact with accounts you own or with explicit permission of the account holder. If you do encounter Personally Identifiable Information (PII) contact us immediately, do not proceed with access, and immediately purge any local information.
+* Provide us with a reasonable amount of time to resolve vulnerabilities prior to any disclosure to the public or a third-party.
+
+We will consider activities conducted consistent with this policy to constitute "authorized" conduct and will not pursue civil action or initiate a complaint to law enforcement. We will help to the extent we can if legal action is initiated by a third party against you.
+
+Please submit a report to us before engaging in conduct that may be inconsistent with or unaddressed by this policy.
+
+## Preferences
+
+* Please provide detailed reports with reproducible steps and a clearly defined impact.
+* Submit one vulnerability per report.
+* Social engineering (e.g. phishing, vishing, smishing) is prohibited.
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000000..f8a847abe2
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,211 @@
+//! 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::process::Command;
+
+fn main() -> anyhow::Result<()> {
+ 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",
+ #[cfg(feature = "lightbeam")]
+ "Lightbeam",
+ ] {
+ writeln!(out, "#[cfg(test)]")?;
+ writeln!(out, "#[allow(non_snake_case)]")?;
+ 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/bulk-memory-operations", strategy)?;
+ test_directory_module(out, "tests/misc_testsuite/reference-types", 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/simd", strategy)?;
+ test_directory_module(out, "tests/spec_testsuite/proposals/multi-value", strategy)?;
+ test_directory_module(
+ out,
+ "tests/spec_testsuite/proposals/reference-types",
+ strategy,
+ )?;
+ test_directory_module(
+ out,
+ "tests/spec_testsuite/proposals/bulk-memory-operations",
+ 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,
+ strategy: &str,
+) -> anyhow::Result {
+ let path = path.as_ref();
+ let testsuite = &extract_name(path);
+ with_test_module(out, testsuite, |out| test_directory(out, path, strategy))
+}
+
+fn test_directory(
+ out: &mut String,
+ path: impl AsRef,
+ strategy: &str,
+) -> anyhow::Result {
+ 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)?;
+ }
+
+ Ok(dir_entries.len())
+}
+
+/// Extract a valid Rust identifier from the stem of a path.
+fn extract_name(path: impl AsRef) -> String {
+ path.as_ref()
+ .file_stem()
+ .expect("filename should have a stem")
+ .to_str()
+ .expect("filename should be representable as a string")
+ .replace("-", "_")
+ .replace("/", "_")
+}
+
+fn with_test_module(
+ out: &mut String,
+ testsuite: &str,
+ f: impl FnOnce(&mut String) -> anyhow::Result,
+) -> anyhow::Result {
+ 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,
+ testsuite: &str,
+ strategy: &str,
+) -> anyhow::Result<()> {
+ let path = path.as_ref();
+ let testname = extract_name(path);
+
+ writeln!(out, "#[test]")?;
+ if ignore(testsuite, &testname, strategy) {
+ writeln!(out, "#[ignore]")?;
+ }
+ writeln!(out, "fn r#{}() -> anyhow::Result<()> {{", &testname)?;
+ writeln!(
+ out,
+ "crate::run_wast(r#\"{}\"#, crate::Strategy::{})",
+ path.display(),
+ strategy
+ )?;
+ writeln!(out, "}}")?;
+ writeln!(out)?;
+ Ok(())
+}
+
+/// Ignore tests that aren't supported yet.
+fn ignore(testsuite: &str, testname: &str, strategy: &str) -> bool {
+ match strategy {
+ #[cfg(feature = "lightbeam")]
+ "Lightbeam" => match (testsuite, testname) {
+ ("simd", _) => return true,
+ ("multi_value", _) => return true,
+ ("reference_types", _) => return true,
+ ("bulk_memory_operations", _) => return true,
+ // Lightbeam doesn't support float arguments on the stack.
+ ("spec_testsuite", "call") => return true,
+ _ => (),
+ },
+ "Cranelift" => match (testsuite, testname) {
+ ("simd", "simd_bit_shift") => return true, // FIXME Unsupported feature: proposed SIMD operator I8x16Shl
+ ("simd", "simd_conversions") => return true, // FIXME Unsupported feature: proposed SIMD operator I16x8NarrowI32x4S
+ ("simd", "simd_f32x4") => return true, // FIXME expected V128(F32x4([CanonicalNan, CanonicalNan, Value(Float32 { bits: 0 }), Value(Float32 { bits: 0 })])), got V128(18428729675200069632)
+ ("simd", "simd_f64x2") => return true, // FIXME expected V128(F64x2([Value(Float64 { bits: 9221120237041090560 }), Value(Float64 { bits: 0 })])), got V128(0)
+ ("simd", "simd_f64x2_arith") => return true, // FIXME expected V128(F64x2([Value(Float64 { bits: 9221120237041090560 }), Value(Float64 { bits: 13835058055282163712 })])), got V128(255211775190703847615975447847722024960)
+ ("simd", "simd_i64x2_arith") => return true, // FIXME Unsupported feature: proposed SIMD operator I64x2Mul
+ ("simd", "simd_lane") => return true, // FIXME invalid u8 number: constant out of range: (v8x16.shuffle -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14...
+ ("simd", "simd_load") => return true, // FIXME Unsupported feature: proposed SIMD operator I8x16Shl
+ ("simd", "simd_load_extend") => return true, // FIXME Unsupported feature: proposed SIMD operator I16x8Load8x8S { memarg: MemoryImmediate { flags: 0, offset: 0 } }
+ ("simd", "simd_load_splat") => return true, // FIXME Unsupported feature: proposed SIMD operator V8x16LoadSplat { memarg: MemoryImmediate { flags: 0, offset: 0 } }
+ ("simd", "simd_splat") => return true, // FIXME Unsupported feature: proposed SIMD operator I8x16ShrS
+
+ // Still working on implementing these. See #929.
+ ("reference_types", "table_copy_on_imported_tables") => return false,
+ ("reference_types", _) => return true,
+
+ // Still working on implementing these. See #928
+ ("bulk_memory_operations", "bulk")
+ | ("bulk_memory_operations", "data")
+ | ("bulk_memory_operations", "memory_init")
+ | ("bulk_memory_operations", "imports") => return true,
+
+ _ => {}
+ },
+ _ => panic!("unrecognized strategy"),
+ }
+
+ false
+}
diff --git a/ci/build-tarballs.sh b/ci/build-tarballs.sh
new file mode 100755
index 0000000000..433450116b
--- /dev/null
+++ b/ci/build-tarballs.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+# A small shell script invoked from CI on the final Linux builder which actually
+# assembles the release artifacts for a particular platform. This will take the
+# binary artifacts of previous builders and create associated tarballs to
+# publish to GitHub.
+#
+# The first argument of this is the "platform" name to put into the tarball, and
+# the second argument is the name of the github actions platform which is where
+# we source binaries from. The final third argument is ".exe" on Windows to
+# handle executable extensions right.
+
+set -ex
+
+platform=$1
+src=$2
+exe=$3
+
+rm -rf tmp
+mkdir tmp
+mkdir -p dist
+
+mktarball() {
+ dir=$1
+ if [ "$exe" = "" ]; then
+ tar cJf dist/$dir.tar.xz -C tmp $dir
+ else
+ (cd tmp && zip -r ../dist/$dir.zip $dir)
+ fi
+}
+
+# Create the main tarball of binaries
+bin_pkgname=wasmtime-$TAG-$platform
+mkdir tmp/$bin_pkgname
+cp LICENSE README.md tmp/$bin_pkgname
+mv bins-$src/{wasmtime,wasm2obj}$exe tmp/$bin_pkgname
+chmod +x tmp/$bin_pkgname/{wasmtime,wasm2obj}$exe
+mktarball $bin_pkgname
+
+if [ "$exe" = ".exe" ]; then
+ mv bins-$src/installer.msi dist/$bin_pkgname.msi
+fi
+
+# Create tarball of API libraries
+api_pkgname=wasmtime-$TAG-$platform-c-api
+mkdir tmp/$api_pkgname
+mkdir tmp/$api_pkgname/lib
+mkdir tmp/$api_pkgname/include
+cp LICENSE README.md tmp/$api_pkgname
+mv bins-$src/* tmp/$api_pkgname/lib
+cp crates/c-api/examples/wasm-c-api/include/wasm.h tmp/$api_pkgname/include
+mktarball $api_pkgname
+
+# Move wheels to dist folder
+mv wheels-$src/* dist
diff --git a/ci/setup_centos6_python3.sh b/ci/setup_centos6_python3.sh
new file mode 100644
index 0000000000..35ab465469
--- /dev/null
+++ b/ci/setup_centos6_python3.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+set -e
+
+VERSION=${1:-3.7.3}
+
+# Python 3.6 stands in our way -- nuking it
+yum erase -y rh-python36
+rm -rf /opt/rh/rh-python36
+
+yum install -y gcc bzip2-devel libffi-devel zlib-devel
+
+cd /usr/src/
+
+# pip3.7 needs new openssl
+curl -O -L https://github.com/openssl/openssl/archive/OpenSSL_1_1_1c.tar.gz
+tar -zxvf OpenSSL_1_1_1c.tar.gz
+cd openssl-OpenSSL_1_1_1c
+./Configure shared zlib linux-x86_64
+make -sj4
+make install
+cd ..
+rm -rf openssl-OpenSSL_1_1_1c
+
+# Fixing libssl.so.1.1: cannot open shared object file
+echo "/usr/local/lib64" >> /etc/ld.so.conf && ldconfig
+
+curl -O -L https://www.python.org/ftp/python/${VERSION}/Python-${VERSION}.tgz
+tar xzf Python-${VERSION}.tgz
+cd Python-${VERSION}
+./configure
+make -sj4
+make install
+cd ..
+rm -rf Python-${VERSION}
diff --git a/ci/wasmtime.wxs b/ci/wasmtime.wxs
new file mode 100644
index 0000000000..8110932cb9
--- /dev/null
+++ b/ci/wasmtime.wxs
@@ -0,0 +1,89 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 0000000000..152f137769
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1 @@
+doc-valid-idents = ["WebAssembly"]
diff --git a/crates/api/Cargo.toml b/crates/api/Cargo.toml
new file mode 100644
index 0000000000..b4adb27975
--- /dev/null
+++ b/crates/api/Cargo.toml
@@ -0,0 +1,52 @@
+[package]
+name = "wasmtime"
+version = "0.12.0"
+authors = ["The Wasmtime Project Developers"]
+description = "High-level API to expose the Wasmtime runtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+edition = "2018"
+
+[dependencies]
+wasmtime-runtime = { path = "../runtime", version = "0.12.0" }
+wasmtime-environ = { path = "../environ", version = "0.12.0" }
+wasmtime-jit = { path = "../jit", version = "0.12.0" }
+wasmtime-profiling = { path = "../profiling", version = "0.12.0" }
+wasmparser = "0.51.2"
+target-lexicon = { version = "0.10.0", default-features = false }
+anyhow = "1.0.19"
+region = "2.0.0"
+libc = "0.2"
+cfg-if = "0.1.9"
+backtrace = "0.3.42"
+rustc-demangle = "0.1.16"
+lazy_static = "1.4"
+wat = { version = "1.0.10", optional = true }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = "0.3.7"
+
+[dev-dependencies]
+# for wasmtime.rs
+wasi-common = { path = "../wasi-common", version = "0.12.0" }
+pretty_env_logger = "0.3.0"
+rayon = "1.2.1"
+file-per-thread-logger = "0.1.1"
+wat = "1.0.10"
+tempfile = "3.1"
+
+[badges]
+maintenance = { status = "actively-developed" }
+
+[features]
+default = ['wat']
+
+# Enables experimental support for the lightbeam codegen backend, an alternative
+# to cranelift. Requires Nightly Rust currently, and this is not enabled by
+# default.
+lightbeam = ["wasmtime-jit/lightbeam"]
+
+[[test]]
+name = "host-segfault"
+harness = false
diff --git a/crates/api/LICENSE b/crates/api/LICENSE
new file mode 100644
index 0000000000..f9d81955f4
--- /dev/null
+++ b/crates/api/LICENSE
@@ -0,0 +1,220 @@
+
+ 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/api/README.md b/crates/api/README.md
new file mode 100644
index 0000000000..49ca113c15
--- /dev/null
+++ b/crates/api/README.md
@@ -0,0 +1,8 @@
+## Wasmtime Embedding API
+
+The `wasmtime` crate is an embedding API of the `wasmtime` WebAssembly runtime.
+This is intended to be used in Rust projects and provides a high-level API of
+working with WebAssembly modules.
+
+If you're interested in embedding `wasmtime` in other languages, you may wish to
+take a look a the [C embedding API](../c-api) instead!
diff --git a/crates/api/examples/gcd.rs b/crates/api/examples/gcd.rs
new file mode 100644
index 0000000000..5f68b87417
--- /dev/null
+++ b/crates/api/examples/gcd.rs
@@ -0,0 +1,60 @@
+//! Example of instantiating of the WebAssembly module and
+//! invoking its exported function.
+
+use wasmtime::*;
+
+const WAT: &str = r#"
+(module
+ (func $gcd (param i32 i32) (result i32)
+ (local i32)
+ block ;; label = @1
+ block ;; label = @2
+ local.get 0
+ br_if 0 (;@2;)
+ local.get 1
+ local.set 2
+ br 1 (;@1;)
+ end
+ loop ;; label = @2
+ local.get 1
+ local.get 0
+ local.tee 2
+ i32.rem_u
+ local.set 0
+ local.get 2
+ local.set 1
+ local.get 0
+ br_if 0 (;@2;)
+ end
+ end
+ local.get 2
+ )
+ (export "gcd" (func $gcd))
+)
+"#;
+
+fn main() -> anyhow::Result<()> {
+ // Load our WebAssembly (parsed WAT in our case), and then load it into a
+ // `Module` which is attached to a `Store` cache.
+ let store = Store::default();
+ let module = Module::new(&store, WAT)?;
+
+ // Find index of the `gcd` export.
+ let gcd_index = module
+ .exports()
+ .iter()
+ .enumerate()
+ .find(|(_, export)| export.name().to_string() == "gcd")
+ .unwrap()
+ .0;
+
+ // Instantiate the module.
+ let instance = Instance::new(&module, &[])?;
+
+ // Invoke `gcd` export
+ let gcd = instance.exports()[gcd_index].func().expect("gcd");
+ let result = gcd.call(&[Val::from(6i32), Val::from(27i32)])?;
+
+ println!("{:?}", result);
+ Ok(())
+}
diff --git a/crates/api/examples/hello.rs b/crates/api/examples/hello.rs
new file mode 100644
index 0000000000..9a461569ba
--- /dev/null
+++ b/crates/api/examples/hello.rs
@@ -0,0 +1,50 @@
+//! Translation of hello example
+
+use anyhow::{ensure, Context as _, Result};
+use wasmtime::*;
+
+fn main() -> Result<()> {
+ // Configure the initial compilation environment, creating the global
+ // `Store` structure. Note that you can also tweak configuration settings
+ // with a `Config` and an `Engine` if desired.
+ println!("Initializing...");
+ let store = Store::default();
+
+ // Compile the wasm binary into an in-memory instance of a `Module`.
+ println!("Compiling module...");
+ let wat = r#"
+ (module
+ (func $hello (import "" "hello"))
+ (func (export "run") (call $hello))
+ )
+ "#;
+ let module = Module::new(&store, wat).context("> Error compiling module!")?;
+
+ // Here we handle the imports of the module, which in this case is our
+ // `HelloCallback` type and its associated implementation of `Callback.
+ println!("Creating callback...");
+ let hello_func = Func::wrap0(&store, || {
+ println!("Calling back...");
+ println!("> Hello World!");
+ });
+
+ // Once we've got that all set up we can then move to the instantiation
+ // phase, pairing together a compiled module as well as a set of imports.
+ // Note that this is where the wasm `start` function, if any, would run.
+ println!("Instantiating module...");
+ let imports = vec![hello_func.into()];
+ let instance = Instance::new(&module, &imports).context("> Error instantiating module!")?;
+
+ // Next we poke around a bit to extract the `run` function from the module.
+ println!("Extracting export...");
+ let exports = instance.exports();
+ ensure!(!exports.is_empty(), "> Error accessing exports!");
+ let run_func = exports[0].func().context("> Error accessing exports!")?;
+
+ // And last but not least we can call it!
+ println!("Calling export...");
+ run_func.call(&[])?;
+
+ println!("Done.");
+ Ok(())
+}
diff --git a/crates/api/examples/memory.rs b/crates/api/examples/memory.rs
new file mode 100644
index 0000000000..dd2908c005
--- /dev/null
+++ b/crates/api/examples/memory.rs
@@ -0,0 +1,160 @@
+//! Translation of the memory example
+
+use anyhow::{bail, ensure, Context as _, Error};
+use wasmtime::*;
+
+fn get_export_memory(exports: &[Extern], i: usize) -> Result {
+ if exports.len() <= i {
+ bail!("> Error accessing memory export {}!", i);
+ }
+ Ok(exports[i]
+ .memory()
+ .with_context(|| format!("> Error accessing memory export {}!", i))?
+ .clone())
+}
+
+fn get_export_func(exports: &[Extern], i: usize) -> Result {
+ if exports.len() <= i {
+ bail!("> Error accessing function export {}!", i);
+ }
+ Ok(exports[i]
+ .func()
+ .with_context(|| format!("> Error accessing function export {}!", i))?
+ .clone())
+}
+
+macro_rules! check {
+ ($actual:expr, $expected:expr) => {
+ if $actual != $expected {
+ bail!("> Error on result, expected {}, got {}", $expected, $actual);
+ }
+ };
+}
+
+macro_rules! check_ok {
+ ($func:expr, $($p:expr),*) => {
+ if let Err(_) = $func.call(&[$($p.into()),*]) {
+ bail!("> Error on result, expected return");
+ }
+ }
+}
+
+macro_rules! check_trap {
+ ($func:expr, $($p:expr),*) => {
+ if let Ok(_) = $func.call(&[$($p.into()),*]) {
+ bail!("> Error on result, expected trap");
+ }
+ }
+}
+
+macro_rules! call {
+ ($func:expr, $($p:expr),*) => {
+ match $func.call(&[$($p.into()),*]) {
+ Ok(result) => {
+ let result: i32 = result[0].unwrap_i32();
+ result
+ }
+ Err(_) => { bail!("> Error on result, expected return"); }
+ }
+ }
+}
+
+fn main() -> Result<(), Error> {
+ // Initialize.
+ println!("Initializing...");
+ let store = Store::default();
+
+ // Load binary.
+ println!("Loading binary...");
+ let wat = r#"
+ (module
+ (memory (export "memory") 2 3)
+
+ (func (export "size") (result i32) (memory.size))
+ (func (export "load") (param i32) (result i32)
+ (i32.load8_s (local.get 0))
+ )
+ (func (export "store") (param i32 i32)
+ (i32.store8 (local.get 0) (local.get 1))
+ )
+
+ (data (i32.const 0x1000) "\01\02\03\04")
+ )
+ "#;
+
+ // Compile.
+ println!("Compiling module...");
+ let module = Module::new(&store, &wat).context("> Error compiling module!")?;
+
+ // Instantiate.
+ println!("Instantiating module...");
+ let instance = Instance::new(&module, &[]).context("> Error instantiating module!")?;
+
+ // Extract export.
+ println!("Extracting export...");
+ let exports = instance.exports();
+ ensure!(!exports.is_empty(), "> Error accessing exports!");
+ let memory = get_export_memory(&exports, 0)?;
+ let size_func = get_export_func(&exports, 1)?;
+ let load_func = get_export_func(&exports, 2)?;
+ let store_func = get_export_func(&exports, 3)?;
+
+ // Check initial memory.
+ println!("Checking memory...");
+ check!(memory.size(), 2u32);
+ check!(memory.data_size(), 0x20000usize);
+ check!(unsafe { memory.data_unchecked_mut()[0] }, 0);
+ check!(unsafe { memory.data_unchecked_mut()[0x1000] }, 1);
+ check!(unsafe { memory.data_unchecked_mut()[0x1003] }, 4);
+
+ check!(call!(size_func,), 2);
+ check!(call!(load_func, 0), 0);
+ check!(call!(load_func, 0x1000), 1);
+ check!(call!(load_func, 0x1003), 4);
+ check!(call!(load_func, 0x1ffff), 0);
+ check_trap!(load_func, 0x20000);
+
+ // Mutate memory.
+ println!("Mutating memory...");
+ unsafe {
+ memory.data_unchecked_mut()[0x1003] = 5;
+ }
+
+ check_ok!(store_func, 0x1002, 6);
+ check_trap!(store_func, 0x20000, 0);
+
+ check!(unsafe { memory.data_unchecked()[0x1002] }, 6);
+ check!(unsafe { memory.data_unchecked()[0x1003] }, 5);
+ check!(call!(load_func, 0x1002), 6);
+ check!(call!(load_func, 0x1003), 5);
+
+ // Grow memory.
+ println!("Growing memory...");
+ memory.grow(1)?;
+ check!(memory.size(), 3u32);
+ check!(memory.data_size(), 0x30000usize);
+
+ check!(call!(load_func, 0x20000), 0);
+ check_ok!(store_func, 0x20000, 0);
+ check_trap!(load_func, 0x30000);
+ check_trap!(store_func, 0x30000, 0);
+
+ memory.grow(1).unwrap_err();
+ memory.grow(0).unwrap();
+
+ // Create stand-alone memory.
+ // TODO(wasm+): Once Wasm allows multiple memories, turn this into import.
+ println!("Creating stand-alone memory...");
+ let memorytype = MemoryType::new(Limits::new(5, Some(5)));
+ let memory2 = Memory::new(&store, memorytype);
+ check!(memory2.size(), 5u32);
+ memory2.grow(1).unwrap_err();
+ memory2.grow(0).unwrap();
+
+ // Shut down.
+ println!("Shutting down...");
+ drop(store);
+
+ println!("Done.");
+ Ok(())
+}
diff --git a/crates/api/examples/multi.rs b/crates/api/examples/multi.rs
new file mode 100644
index 0000000000..663281eb09
--- /dev/null
+++ b/crates/api/examples/multi.rs
@@ -0,0 +1,129 @@
+//! Translation of multi example
+
+use anyhow::{ensure, format_err, Context as _, Result};
+use std::rc::Rc;
+use wasmtime::*;
+
+struct Callback;
+
+impl Callable for Callback {
+ fn call(&self, args: &[Val], results: &mut [Val]) -> Result<(), Trap> {
+ println!("Calling back...");
+ println!("> {} {}", args[0].unwrap_i32(), args[1].unwrap_i64());
+
+ results[0] = Val::I64(args[1].unwrap_i64() + 1);
+ results[1] = Val::I32(args[0].unwrap_i32() + 1);
+ Ok(())
+ }
+}
+
+const WAT: &str = r#"
+(module
+ (func $f (import "" "f") (param i32 i64) (result i64 i32))
+
+ (func $g (export "g") (param i32 i64) (result i64 i32)
+ (call $f (local.get 0) (local.get 1))
+ )
+
+ (func $round_trip_many
+ (export "round_trip_many")
+ (param i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+ (result i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+ 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)
+)
+"#;
+
+fn main() -> Result<()> {
+ // Initialize.
+ println!("Initializing...");
+ let engine = Engine::new(Config::new().wasm_multi_value(true));
+ let store = Store::new(&engine);
+
+ // Compile.
+ println!("Compiling module...");
+ let module = Module::new(&store, WAT).context("Error compiling module!")?;
+
+ // Create external print functions.
+ println!("Creating callback...");
+ let callback_type = FuncType::new(
+ Box::new([ValType::I32, ValType::I64]),
+ Box::new([ValType::I64, ValType::I32]),
+ );
+ let callback_func = Func::new(&store, callback_type, Rc::new(Callback));
+
+ // Instantiate.
+ println!("Instantiating module...");
+ let imports = vec![callback_func.into()];
+ let instance =
+ Instance::new(&module, imports.as_slice()).context("Error instantiating module!")?;
+
+ // Extract exports.
+ println!("Extracting export...");
+ let exports = instance.exports();
+ ensure!(!exports.is_empty(), "Error accessing exports!");
+ let g = exports[0].func().context("> Error accessing export $g!")?;
+ let round_trip_many = exports[1]
+ .func()
+ .context("> Error accessing export $round_trip_many")?;
+
+ // Call `$g`.
+ println!("Calling export \"g\"...");
+ let args = vec![Val::I32(1), Val::I64(3)];
+ let results = g
+ .call(&args)
+ .map_err(|e| format_err!("> Error calling g! {:?}", e))?;
+
+ println!("Printing result...");
+ println!("> {} {}", results[0].unwrap_i64(), results[1].unwrap_i32());
+
+ debug_assert_eq!(results[0].unwrap_i64(), 4);
+ debug_assert_eq!(results[1].unwrap_i32(), 2);
+
+ // Call `$round_trip_many`.
+ println!("Calling export \"round_trip_many\"...");
+ let args = vec![
+ Val::I64(0),
+ Val::I64(1),
+ Val::I64(2),
+ Val::I64(3),
+ Val::I64(4),
+ Val::I64(5),
+ Val::I64(6),
+ Val::I64(7),
+ Val::I64(8),
+ Val::I64(9),
+ ];
+ let results = round_trip_many
+ .call(&args)
+ .map_err(|e| format_err!("> Error calling round_trip_many! {:?}", e))?;
+
+ println!("Printing result...");
+ print!(">");
+ for r in results.iter() {
+ print!(" {}", r.unwrap_i64());
+ }
+ println!();
+
+ debug_assert_eq!(results.len(), 10);
+ debug_assert!(args
+ .iter()
+ .zip(results.iter())
+ .all(|(a, r)| a.i64() == r.i64()));
+
+ // Shut down.
+ println!("Shutting down...");
+ drop(store);
+
+ // All done.
+ println!("Done.");
+ Ok(())
+}
diff --git a/crates/api/src/callable.rs b/crates/api/src/callable.rs
new file mode 100644
index 0000000000..c4983df8c8
--- /dev/null
+++ b/crates/api/src/callable.rs
@@ -0,0 +1,225 @@
+use crate::runtime::Store;
+use crate::trampoline::generate_func_export;
+use crate::trap::Trap;
+use crate::types::FuncType;
+use crate::values::Val;
+use std::ptr;
+use std::rc::Rc;
+use wasmtime_environ::ir;
+use wasmtime_runtime::{Export, InstanceHandle};
+
+/// A trait representing a function that can be imported and called from inside
+/// WebAssembly.
+/// # Example
+/// ```
+/// use wasmtime::Val;
+///
+/// struct TimesTwo;
+///
+/// impl wasmtime::Callable for TimesTwo {
+/// fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), wasmtime::Trap> {
+/// let mut value = params[0].unwrap_i32();
+/// value *= 2;
+/// results[0] = value.into();
+///
+/// Ok(())
+/// }
+/// }
+///
+/// # fn main () -> Result<(), Box> {
+/// // Simple module that imports our host function ("times_two") and re-exports
+/// // it as "run".
+/// let wat = r#"
+/// (module
+/// (func $times_two (import "" "times_two") (param i32) (result i32))
+/// (func
+/// (export "run")
+/// (param i32)
+/// (result i32)
+/// (local.get 0)
+/// (call $times_two))
+/// )
+/// "#;
+///
+/// // Initialise environment and our module.
+/// let store = wasmtime::Store::default();
+/// let module = wasmtime::Module::new(&store, wat)?;
+///
+/// // Define the type of the function we're going to call.
+/// let times_two_type = wasmtime::FuncType::new(
+/// // Parameters
+/// Box::new([wasmtime::ValType::I32]),
+/// // Results
+/// Box::new([wasmtime::ValType::I32])
+/// );
+///
+/// // Build a reference to the "times_two" function that can be used.
+/// let times_two_function =
+/// wasmtime::Func::new(&store, times_two_type, std::rc::Rc::new(TimesTwo));
+///
+/// // Create module instance that imports our function
+/// let instance = wasmtime::Instance::new(
+/// &module,
+/// &[times_two_function.into()]
+/// )?;
+///
+/// // Get "run" function from the exports.
+/// let run_function = instance.exports()[0].func().unwrap();
+///
+/// // Borrow and call "run". Returning any error message from Wasm as a string.
+/// let original = 5i32;
+/// let results = run_function
+/// .call(&[original.into()])
+/// .map_err(|trap| trap.to_string())?;
+///
+/// // Compare that the results returned matches what we expect.
+/// assert_eq!(original * 2, results[0].unwrap_i32());
+/// # Ok(())
+/// # }
+/// ```
+pub trait Callable {
+ /// What is called when the function is invoked in WebAssembly.
+ /// `params` is an immutable list of parameters provided to the function.
+ /// `results` is mutable list of results to be potentially set by your
+ /// function. Produces a `Trap` if the function encounters any errors.
+ fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap>;
+}
+
+pub(crate) trait WrappedCallable {
+ fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap>;
+ fn signature(&self) -> &ir::Signature {
+ match self.wasmtime_export() {
+ Export::Function { signature, .. } => signature,
+ _ => panic!("unexpected export type in Callable"),
+ }
+ }
+ fn wasmtime_handle(&self) -> &InstanceHandle;
+ fn wasmtime_export(&self) -> &Export;
+}
+
+pub(crate) struct WasmtimeFn {
+ store: Store,
+ instance: InstanceHandle,
+ export: Export,
+}
+
+impl WasmtimeFn {
+ pub fn new(store: &Store, instance: InstanceHandle, export: Export) -> WasmtimeFn {
+ WasmtimeFn {
+ store: store.clone(),
+ instance,
+ export,
+ }
+ }
+}
+
+impl WrappedCallable for WasmtimeFn {
+ fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap> {
+ use std::cmp::max;
+ use std::mem;
+
+ let (vmctx, body, signature) = match self.wasmtime_export() {
+ Export::Function {
+ vmctx,
+ address,
+ signature,
+ } => (*vmctx, *address, signature.clone()),
+ _ => panic!("unexpected export type in Callable"),
+ };
+ if signature.params.len() - 2 != params.len() {
+ return Err(Trap::new(format!(
+ "expected {} arguments, got {}",
+ signature.params.len() - 2,
+ params.len()
+ )));
+ }
+ if signature.returns.len() != results.len() {
+ return Err(Trap::new(format!(
+ "expected {} results, got {}",
+ signature.returns.len(),
+ results.len()
+ )));
+ }
+
+ let value_size = mem::size_of::();
+ let mut values_vec = vec![0; max(params.len(), results.len())];
+
+ // Store the argument values into `values_vec`.
+ let param_tys = signature.params.iter().skip(2);
+ for ((arg, slot), ty) in params.iter().zip(&mut values_vec).zip(param_tys) {
+ if arg.ty().get_wasmtime_type() != Some(ty.value_type) {
+ return Err(Trap::new("argument type mismatch"));
+ }
+ unsafe {
+ arg.write_value_to(slot);
+ }
+ }
+
+ // Get the trampoline to call for this function.
+ let exec_code_buf = self
+ .store
+ .compiler_mut()
+ .get_published_trampoline(&signature, value_size)
+ .map_err(|e| Trap::new(format!("trampoline error: {:?}", e)))?;
+
+ // Call the trampoline.
+ if let Err(error) = unsafe {
+ wasmtime_runtime::wasmtime_call_trampoline(
+ vmctx,
+ ptr::null_mut(),
+ exec_code_buf,
+ body,
+ values_vec.as_mut_ptr() as *mut u8,
+ )
+ } {
+ return Err(Trap::from_jit(error));
+ }
+
+ // Load the return values out of `values_vec`.
+ for (index, abi_param) in signature.returns.iter().enumerate() {
+ unsafe {
+ let ptr = values_vec.as_ptr().add(index);
+
+ results[index] = Val::read_value_from(ptr, abi_param.value_type);
+ }
+ }
+
+ Ok(())
+ }
+ fn wasmtime_handle(&self) -> &InstanceHandle {
+ &self.instance
+ }
+ fn wasmtime_export(&self) -> &Export {
+ &self.export
+ }
+}
+
+pub struct NativeCallable {
+ callable: Rc,
+ instance: InstanceHandle,
+ export: Export,
+}
+
+impl NativeCallable {
+ pub(crate) fn new(callable: Rc, ft: &FuncType, store: &Store) -> Self {
+ let (instance, export) =
+ generate_func_export(ft, &callable, store).expect("generated func");
+ NativeCallable {
+ callable,
+ instance,
+ export,
+ }
+ }
+}
+
+impl WrappedCallable for NativeCallable {
+ fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap> {
+ self.callable.call(params, results)
+ }
+ fn wasmtime_handle(&self) -> &InstanceHandle {
+ &self.instance
+ }
+ fn wasmtime_export(&self) -> &Export {
+ &self.export
+ }
+}
diff --git a/crates/api/src/externals.rs b/crates/api/src/externals.rs
new file mode 100644
index 0000000000..1735c10be6
--- /dev/null
+++ b/crates/api/src/externals.rs
@@ -0,0 +1,643 @@
+use crate::trampoline::{generate_global_export, generate_memory_export, generate_table_export};
+use crate::values::{from_checked_anyfunc, into_checked_anyfunc, Val};
+use crate::Mutability;
+use crate::{ExternType, GlobalType, MemoryType, TableType, ValType};
+use crate::{Func, Store};
+use anyhow::{anyhow, bail, Result};
+use std::slice;
+use wasmtime_environ::{ir, wasm};
+use wasmtime_runtime::{self as runtime, InstanceHandle};
+
+// Externals
+
+/// An external item to a WebAssembly module, or a list of what can possibly be
+/// exported from a wasm module.
+///
+/// This is both returned from [`Instance::exports`](crate::Instance::exports)
+/// as well as required by [`Instance::new`](crate::Instance::new). In other
+/// words, this is the type of extracted values from an instantiated module, and
+/// it's also used to provide imported values when instantiating a module.
+#[derive(Clone)]
+pub enum Extern {
+ /// A WebAssembly `func` which can be called.
+ Func(Func),
+ /// A WebAssembly `global` which acts like a `Cell` of sorts, supporting
+ /// `get` and `set` operations.
+ Global(Global),
+ /// A WebAssembly `table` which is an array of `Val` types.
+ Table(Table),
+ /// A WebAssembly linear memory.
+ Memory(Memory),
+}
+
+impl Extern {
+ /// Returns the underlying `Func`, if this external is a function.
+ ///
+ /// Returns `None` if this is not a function.
+ pub fn func(&self) -> Option<&Func> {
+ match self {
+ Extern::Func(func) => Some(func),
+ _ => None,
+ }
+ }
+
+ /// Returns the underlying `Global`, if this external is a global.
+ ///
+ /// Returns `None` if this is not a global.
+ pub fn global(&self) -> Option<&Global> {
+ match self {
+ Extern::Global(global) => Some(global),
+ _ => None,
+ }
+ }
+
+ /// Returns the underlying `Table`, if this external is a table.
+ ///
+ /// Returns `None` if this is not a table.
+ pub fn table(&self) -> Option<&Table> {
+ match self {
+ Extern::Table(table) => Some(table),
+ _ => None,
+ }
+ }
+
+ /// Returns the underlying `Memory`, if this external is a memory.
+ ///
+ /// Returns `None` if this is not a memory.
+ pub fn memory(&self) -> Option<&Memory> {
+ match self {
+ Extern::Memory(memory) => Some(memory),
+ _ => None,
+ }
+ }
+
+ /// Returns the type associated with this `Extern`.
+ pub fn ty(&self) -> ExternType {
+ match self {
+ Extern::Func(ft) => ExternType::Func(ft.ty().clone()),
+ Extern::Memory(ft) => ExternType::Memory(ft.ty().clone()),
+ Extern::Table(tt) => ExternType::Table(tt.ty().clone()),
+ Extern::Global(gt) => ExternType::Global(gt.ty().clone()),
+ }
+ }
+
+ pub(crate) fn get_wasmtime_export(&self) -> wasmtime_runtime::Export {
+ match self {
+ Extern::Func(f) => f.wasmtime_export().clone(),
+ Extern::Global(g) => g.wasmtime_export().clone(),
+ Extern::Memory(m) => m.wasmtime_export().clone(),
+ Extern::Table(t) => t.wasmtime_export().clone(),
+ }
+ }
+
+ pub(crate) fn from_wasmtime_export(
+ store: &Store,
+ instance_handle: InstanceHandle,
+ export: wasmtime_runtime::Export,
+ ) -> Extern {
+ match export {
+ wasmtime_runtime::Export::Function { .. } => {
+ Extern::Func(Func::from_wasmtime_function(export, store, instance_handle))
+ }
+ wasmtime_runtime::Export::Memory { .. } => {
+ Extern::Memory(Memory::from_wasmtime_memory(export, store, instance_handle))
+ }
+ wasmtime_runtime::Export::Global { .. } => {
+ Extern::Global(Global::from_wasmtime_global(export, store, instance_handle))
+ }
+ wasmtime_runtime::Export::Table { .. } => {
+ Extern::Table(Table::from_wasmtime_table(export, store, instance_handle))
+ }
+ }
+ }
+}
+
+impl From for Extern {
+ fn from(r: Func) -> Self {
+ Extern::Func(r)
+ }
+}
+
+impl From for Extern {
+ fn from(r: Global) -> Self {
+ Extern::Global(r)
+ }
+}
+
+impl From for Extern {
+ fn from(r: Memory) -> Self {
+ Extern::Memory(r)
+ }
+}
+
+impl From for Extern {
+ fn from(r: Table) -> Self {
+ Extern::Table(r)
+ }
+}
+
+/// 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.
+///
+/// If you're familiar with Rust already you can think of a `Global` as a sort
+/// of `Rc>`, more or less.
+///
+/// # `Global` and `Clone`
+///
+/// Globals are internally reference counted so you can `clone` a `Global`. The
+/// cloning process only performs a shallow clone, so two cloned `Global`
+/// instances are equivalent in their functionality.
+#[derive(Clone)]
+pub struct Global {
+ _store: Store,
+ ty: GlobalType,
+ wasmtime_export: wasmtime_runtime::Export,
+ wasmtime_handle: InstanceHandle,
+}
+
+impl Global {
+ /// Creates a new WebAssembly `global` value with the provide type `ty` and
+ /// initial value `val`.
+ ///
+ /// The `store` argument provided is used as a general global cache for
+ /// information, and otherwise the `ty` and `val` arguments are used to
+ /// initialize the global.
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if the `ty` provided does not match the type of the
+ /// value `val`.
+ pub fn new(store: &Store, ty: GlobalType, val: Val) -> Result {
+ if val.ty() != *ty.content() {
+ bail!("value provided does not match the type of this global");
+ }
+ let (wasmtime_handle, wasmtime_export) = generate_global_export(store, &ty, val)?;
+ Ok(Global {
+ _store: store.clone(),
+ ty,
+ wasmtime_export,
+ wasmtime_handle,
+ })
+ }
+
+ /// Returns the underlying type of this `global`.
+ pub fn ty(&self) -> &GlobalType {
+ &self.ty
+ }
+
+ fn wasmtime_global_definition(&self) -> *mut wasmtime_runtime::VMGlobalDefinition {
+ match self.wasmtime_export {
+ wasmtime_runtime::Export::Global { definition, .. } => definition,
+ _ => panic!("global definition not found"),
+ }
+ }
+
+ /// Returns the current [`Val`] of this global.
+ pub fn get(&self) -> Val {
+ let definition = unsafe { &mut *self.wasmtime_global_definition() };
+ unsafe {
+ match self.ty().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()),
+ _ => unimplemented!("Global::get for {:?}", self.ty().content()),
+ }
+ }
+ }
+
+ /// Attempts to set the current value of this global to [`Val`].
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if this global has a different type than `Val`, or if
+ /// it's not a mutable global.
+ pub fn set(&self, val: Val) -> Result<()> {
+ if self.ty().mutability() != Mutability::Var {
+ bail!("immutable global cannot be set");
+ }
+ if val.ty() != *self.ty().content() {
+ bail!(
+ "global of type {:?} cannot be set to {:?}",
+ self.ty().content(),
+ val.ty()
+ );
+ }
+ let definition = unsafe { &mut *self.wasmtime_global_definition() };
+ unsafe {
+ 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,
+ _ => unimplemented!("Global::set for {:?}", val.ty()),
+ }
+ }
+ Ok(())
+ }
+
+ pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export {
+ &self.wasmtime_export
+ }
+
+ pub(crate) fn from_wasmtime_global(
+ export: wasmtime_runtime::Export,
+ store: &Store,
+ wasmtime_handle: InstanceHandle,
+ ) -> Global {
+ let global = if let wasmtime_runtime::Export::Global { ref global, .. } = export {
+ global
+ } else {
+ panic!("wasmtime export is not global")
+ };
+ // The original export is coming from wasmtime_runtime itself we should
+ // support all the types coming out of it, so assert such here.
+ let ty = GlobalType::from_wasmtime_global(&global)
+ .expect("core wasm global type should be supported");
+ Global {
+ _store: store.clone(),
+ ty: ty,
+ wasmtime_export: export,
+ wasmtime_handle,
+ }
+ }
+}
+
+/// A WebAssembly `table`, or an array of values.
+///
+/// Like [`Memory`] a table is an indexed array of values, but unlike [`Memory`]
+/// it's an array of WebAssembly values rather than bytes. One of the most
+/// common usages of a table is a function table for wasm modules, where each
+/// element has the `Func` type.
+///
+/// Tables, like globals, are not threadsafe and can only be used on one thread.
+/// Tables can be grown in size and each element can be read/written.
+///
+/// # `Table` and `Clone`
+///
+/// Tables are internally reference counted so you can `clone` a `Table`. The
+/// cloning process only performs a shallow clone, so two cloned `Table`
+/// instances are equivalent in their functionality.
+#[derive(Clone)]
+pub struct Table {
+ store: Store,
+ ty: TableType,
+ wasmtime_handle: InstanceHandle,
+ wasmtime_export: wasmtime_runtime::Export,
+}
+
+fn set_table_item(
+ handle: &mut InstanceHandle,
+ table_index: wasm::DefinedTableIndex,
+ item_index: u32,
+ item: wasmtime_runtime::VMCallerCheckedAnyfunc,
+) -> Result<()> {
+ handle
+ .table_set(table_index, item_index, item)
+ .map_err(|()| anyhow!("table element index out of bounds"))
+}
+
+impl Table {
+ /// Creates a new `Table` with the given parameters.
+ ///
+ /// * `store` - a global cache to store information in
+ /// * `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.
+ pub fn new(store: &Store, ty: TableType, init: Val) -> Result {
+ let item = into_checked_anyfunc(init, store)?;
+ let (mut wasmtime_handle, wasmtime_export) = generate_table_export(store, &ty)?;
+
+ // Initialize entries with the init value.
+ match wasmtime_export {
+ wasmtime_runtime::Export::Table { definition, .. } => {
+ let index = wasmtime_handle.table_index(unsafe { &*definition });
+ let len = unsafe { (*definition).current_elements };
+ for i in 0..len {
+ set_table_item(&mut wasmtime_handle, index, i, item.clone())?;
+ }
+ }
+ _ => unreachable!("export should be a table"),
+ }
+
+ Ok(Table {
+ store: store.clone(),
+ ty,
+ wasmtime_handle,
+ wasmtime_export,
+ })
+ }
+
+ /// Returns the underlying type of this table, including its element type as
+ /// well as the maximum/minimum lower bounds.
+ pub fn ty(&self) -> &TableType {
+ &self.ty
+ }
+
+ fn wasmtime_table_index(&self) -> wasm::DefinedTableIndex {
+ match self.wasmtime_export {
+ wasmtime_runtime::Export::Table { definition, .. } => {
+ self.wasmtime_handle.table_index(unsafe { &*definition })
+ }
+ _ => panic!("global definition not found"),
+ }
+ }
+
+ /// Returns the table element value at `index`.
+ ///
+ /// Returns `None` if `index` is out of bounds.
+ pub fn get(&self, index: u32) -> Option {
+ let table_index = self.wasmtime_table_index();
+ let item = self.wasmtime_handle.table_get(table_index, index)?;
+ Some(from_checked_anyfunc(item, &self.store))
+ }
+
+ /// Writes the `val` provided into `index` within this table.
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if `index` is out of bounds or if `val` does not have
+ /// the right type to be stored in this table.
+ pub fn set(&self, index: u32, val: Val) -> Result<()> {
+ let table_index = self.wasmtime_table_index();
+ let mut wasmtime_handle = self.wasmtime_handle.clone();
+ let item = into_checked_anyfunc(val, &self.store)?;
+ set_table_item(&mut wasmtime_handle, table_index, index, item)
+ }
+
+ /// Returns the current size of this table.
+ pub fn size(&self) -> u32 {
+ match self.wasmtime_export {
+ wasmtime_runtime::Export::Table { definition, .. } => unsafe {
+ (*definition).current_elements
+ },
+ _ => panic!("global definition not found"),
+ }
+ }
+
+ /// Grows the size of this table by `delta` more elements, initialization
+ /// all new elements to `init`.
+ ///
+ /// # 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.
+ pub fn grow(&self, delta: u32, init: Val) -> Result {
+ let index = self.wasmtime_table_index();
+ let item = into_checked_anyfunc(init, &self.store)?;
+ if let Some(len) = self.wasmtime_handle.clone().table_grow(index, delta) {
+ let mut wasmtime_handle = self.wasmtime_handle.clone();
+ for i in 0..delta {
+ let i = len - (delta - i);
+ set_table_item(&mut wasmtime_handle, index, i, item.clone())?;
+ }
+ Ok(len)
+ } else {
+ bail!("failed to grow table by `{}`", delta)
+ }
+ }
+
+ /// 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 fn copy(
+ dst_table: &Table,
+ dst_index: u32,
+ src_table: &Table,
+ src_index: u32,
+ len: u32,
+ ) -> Result<()> {
+ // NB: We must use the `dst_table`'s `wasmtime_handle` for the
+ // `dst_table_index` and vice versa for `src_table` since each table can
+ // come from different modules.
+
+ let dst_table_index = dst_table.wasmtime_table_index();
+ let dst_table = dst_table.wasmtime_handle.get_defined_table(dst_table_index);
+
+ let src_table_index = src_table.wasmtime_table_index();
+ let src_table = src_table.wasmtime_handle.get_defined_table(src_table_index);
+
+ runtime::Table::copy(
+ dst_table,
+ src_table,
+ dst_index,
+ src_index,
+ len,
+ ir::SourceLoc::default(),
+ )?;
+ Ok(())
+ }
+
+ pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export {
+ &self.wasmtime_export
+ }
+
+ pub(crate) fn from_wasmtime_table(
+ export: wasmtime_runtime::Export,
+ store: &Store,
+ instance_handle: wasmtime_runtime::InstanceHandle,
+ ) -> Table {
+ let table = if let wasmtime_runtime::Export::Table { ref table, .. } = export {
+ table
+ } else {
+ panic!("wasmtime export is not table")
+ };
+ let ty = TableType::from_wasmtime_table(&table.table);
+ Table {
+ store: store.clone(),
+ ty: ty,
+ wasmtime_handle: instance_handle,
+ wasmtime_export: export,
+ }
+ }
+}
+
+/// 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, statics in C/C++/Rust, shadow
+/// stack memory, etc. Accessing wasm memory is generally quite fast!
+///
+/// # `Memory` and `Clone`
+///
+/// Memories are internally reference counted so you can `clone` a `Memory`. The
+/// cloning process only performs a shallow clone, so two cloned `Memory`
+/// instances are equivalent in their functionality.
+///
+/// # `Memory` and threads
+///
+/// It is intended that `Memory` is safe to share between threads. At this time
+/// this is not implemented in `wasmtime`, however. This is planned to be
+/// implemented though!
+#[derive(Clone)]
+pub struct Memory {
+ _store: Store,
+ ty: MemoryType,
+ wasmtime_handle: InstanceHandle,
+ wasmtime_export: wasmtime_runtime::Export,
+}
+
+impl Memory {
+ /// Creates a new WebAssembly memory given the configuration of `ty`.
+ ///
+ /// The `store` argument is a general location for cache information, and
+ /// otherwise the memory will immediately be allocated according to the
+ /// type's configuration. All WebAssembly memory is initialized to zero.
+ pub fn new(store: &Store, ty: MemoryType) -> Memory {
+ let (wasmtime_handle, wasmtime_export) =
+ generate_memory_export(store, &ty).expect("generated memory");
+ Memory {
+ _store: store.clone(),
+ ty,
+ wasmtime_handle,
+ wasmtime_export,
+ }
+ }
+
+ /// Returns the underlying type of this memory.
+ pub fn ty(&self) -> &MemoryType {
+ &self.ty
+ }
+
+ fn wasmtime_memory_definition(&self) -> *mut wasmtime_runtime::VMMemoryDefinition {
+ match self.wasmtime_export {
+ wasmtime_runtime::Export::Memory { definition, .. } => definition,
+ _ => panic!("memory definition not found"),
+ }
+ }
+
+ /// Returns this memory as a slice view that can be read natively in Rust.
+ ///
+ /// # Safety
+ ///
+ /// This is an unsafe operation because there is no guarantee that the
+ /// following operations do not happen concurrently while the slice is in
+ /// use:
+ ///
+ /// * Data could be modified by calling into a wasm module.
+ /// * Memory could be relocated through growth by calling into a wasm
+ /// module.
+ /// * When threads are supported, non-atomic reads will race with other
+ /// writes.
+ ///
+ /// Extreme care need be taken when the data of a `Memory` is read. The
+ /// above invariants all need to be upheld at a bare minimum, and in
+ /// general you'll need to ensure that while you're looking at slice you're
+ /// the only one who can possibly look at the slice and read/write it.
+ ///
+ /// Be sure to keep in mind that `Memory` is reference counted, meaning
+ /// that there may be other users of this `Memory` instance elsewhere in
+ /// your program. Additionally `Memory` can be shared and used in any number
+ /// of wasm instances, so calling any wasm code should be considered
+ /// dangerous while you're holding a slice of memory.
+ pub unsafe fn data_unchecked(&self) -> &[u8] {
+ self.data_unchecked_mut()
+ }
+
+ /// Returns this memory as a slice view that can be read and written
+ /// natively in Rust.
+ ///
+ /// # Safety
+ ///
+ /// All of the same safety caveats of [`Memory::data_unchecked`] apply
+ /// here, doubly so because this is returning a mutable slice! As a
+ /// double-extra reminder, remember that `Memory` is reference counted, so
+ /// you can very easily acquire two mutable slices by simply calling this
+ /// function twice. Extreme caution should be used when using this method,
+ /// and in general you probably want to result to unsafe accessors and the
+ /// `data` methods below.
+ pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+ let definition = &*self.wasmtime_memory_definition();
+ slice::from_raw_parts_mut(definition.base, definition.current_length)
+ }
+
+ /// Returns the base pointer, in the host's address space, that the memory
+ /// is located at.
+ ///
+ /// When reading and manipulating memory be sure to read up on the caveats
+ /// of [`Memory::data_unchecked`] to make sure that you can safely
+ /// read/write the memory.
+ pub fn data_ptr(&self) -> *mut u8 {
+ unsafe { (*self.wasmtime_memory_definition()).base }
+ }
+
+ /// Returns the byte length of this memory.
+ ///
+ /// The returned value will be a multiple of the wasm page size, 64k.
+ pub fn data_size(&self) -> usize {
+ unsafe { (*self.wasmtime_memory_definition()).current_length }
+ }
+
+ /// Returns the size, in pages, of this wasm memory.
+ pub fn size(&self) -> u32 {
+ (self.data_size() / wasmtime_environ::WASM_PAGE_SIZE as usize) as u32
+ }
+
+ /// 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 previous
+ /// 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.
+ pub fn grow(&self, delta: u32) -> Result {
+ match self.wasmtime_export {
+ wasmtime_runtime::Export::Memory { definition, .. } => {
+ let definition = unsafe { &(*definition) };
+ let index = self.wasmtime_handle.memory_index(definition);
+ self.wasmtime_handle
+ .clone()
+ .memory_grow(index, delta)
+ .ok_or_else(|| anyhow!("failed to grow memory"))
+ }
+ _ => panic!("memory definition not found"),
+ }
+ }
+
+ pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export {
+ &self.wasmtime_export
+ }
+
+ pub(crate) fn from_wasmtime_memory(
+ export: wasmtime_runtime::Export,
+ store: &Store,
+ instance_handle: wasmtime_runtime::InstanceHandle,
+ ) -> Memory {
+ let memory = if let wasmtime_runtime::Export::Memory { ref memory, .. } = export {
+ memory
+ } else {
+ panic!("wasmtime export is not memory")
+ };
+ let ty = MemoryType::from_wasmtime_memory(&memory.memory);
+ Memory {
+ _store: store.clone(),
+ ty: ty,
+ wasmtime_handle: instance_handle,
+ wasmtime_export: export,
+ }
+ }
+}
diff --git a/crates/api/src/frame_info.rs b/crates/api/src/frame_info.rs
new file mode 100644
index 0000000000..5e0ea13331
--- /dev/null
+++ b/crates/api/src/frame_info.rs
@@ -0,0 +1,183 @@
+use crate::module::Names;
+use std::collections::BTreeMap;
+use std::sync::{Arc, RwLock};
+use wasmtime_environ::entity::EntityRef;
+use wasmtime_environ::wasm::FuncIndex;
+use wasmtime_jit::CompiledModule;
+
+lazy_static::lazy_static! {
+ /// This is a global cache of backtrace frame information for all active
+ ///
+ /// This global cache is used during `Trap` creation to symbolicate frames.
+ /// This is populated on module compilation, and it is cleared out whenever
+ /// all references to a module are dropped.
+ pub static ref FRAME_INFO: GlobalFrameInfo = GlobalFrameInfo::default();
+}
+
+#[derive(Default)]
+pub struct GlobalFrameInfo {
+ /// An internal map that keeps track of backtrace frame information for
+ /// each module.
+ ///
+ /// This map is morally a map of ranges to a map of information for that
+ /// module. Each module is expected to reside in a disjoint section of
+ /// contiguous memory. No modules can overlap.
+ ///
+ /// The key of this map is the highest address in the module and the value
+ /// is the module's information, which also contains the start address.
+ ranges: RwLock>,
+}
+
+/// An RAII structure used to unregister a module's frame information when the
+/// module is destroyed.
+pub struct GlobalFrameInfoRegistration {
+ /// The key that will be removed from the global `ranges` map when this is
+ /// dropped.
+ key: usize,
+}
+
+struct ModuleFrameInfo {
+ start: usize,
+ functions: BTreeMap,
+ names: Arc,
+}
+
+impl GlobalFrameInfo {
+ /// Registers a new compiled module's frame information.
+ ///
+ /// This function will register the `names` information for all of the
+ /// compiled functions within `module`. If the `module` has no functions
+ /// then `None` will be returned. Otherwise the returned object, when
+ /// dropped, will be used to unregister all name information from this map.
+ pub fn register(
+ &self,
+ names: &Arc,
+ module: &CompiledModule,
+ ) -> Option {
+ let mut min = usize::max_value();
+ let mut max = 0;
+ let mut functions = BTreeMap::new();
+ for (i, allocated) in module.finished_functions() {
+ let (start, end) = unsafe {
+ let ptr = (**allocated).as_ptr();
+ let len = (**allocated).len();
+ (ptr as usize, ptr as usize + len)
+ };
+ if start < min {
+ min = start;
+ }
+ if end > max {
+ max = end;
+ }
+ let func_index = module.module().local.func_index(i);
+ assert!(functions.insert(end, (start, func_index)).is_none());
+ }
+ if functions.len() == 0 {
+ return None;
+ }
+
+ let mut ranges = self.ranges.write().unwrap();
+ // First up assert that our chunk of jit functions doesn't collide with
+ // any other known chunks of jit functions...
+ if let Some((_, prev)) = ranges.range(max..).next() {
+ assert!(prev.start > max);
+ }
+ if let Some((prev_end, _)) = ranges.range(..=min).next_back() {
+ assert!(*prev_end < min);
+ }
+
+ // ... then insert our range and assert nothing was there previously
+ let prev = ranges.insert(
+ max,
+ ModuleFrameInfo {
+ start: min,
+ functions,
+ names: names.clone(),
+ },
+ );
+ assert!(prev.is_none());
+ Some(GlobalFrameInfoRegistration { key: max })
+ }
+
+ /// Fetches information about a program counter in a backtrace.
+ ///
+ /// Returns an object if this `pc` is known to some previously registered
+ /// module, or returns `None` if no information can be found.
+ pub fn lookup(&self, pc: usize) -> Option {
+ let ranges = self.ranges.read().ok()?;
+ let (end, info) = ranges.range(pc..).next()?;
+ if pc < info.start || *end < pc {
+ return None;
+ }
+ let (end, (start, func_index)) = info.functions.range(pc..).next()?;
+ if pc < *start || *end < pc {
+ return None;
+ }
+ Some(FrameInfo {
+ module_name: info.names.module_name.clone(),
+ func_index: func_index.index() as u32,
+ func_name: info.names.module.func_names.get(func_index).cloned(),
+ })
+ }
+}
+
+impl Drop for GlobalFrameInfoRegistration {
+ fn drop(&mut self) {
+ if let Ok(mut map) = FRAME_INFO.ranges.write() {
+ map.remove(&self.key);
+ }
+ }
+}
+
+/// Description of a frame in a backtrace for a [`Trap`].
+///
+/// Whenever a WebAssembly trap occurs an instance of [`Trap`] is created. Each
+/// [`Trap`] has a backtrace of the WebAssembly frames that led to the trap, and
+/// each frame is described by this structure.
+#[derive(Debug)]
+pub struct FrameInfo {
+ module_name: Option,
+ func_index: u32,
+ func_name: Option,
+}
+
+impl FrameInfo {
+ /// Returns the WebAssembly function index for this frame.
+ ///
+ /// This function index is the index in the function index space of the
+ /// WebAssembly module that this frame comes from.
+ pub fn func_index(&self) -> u32 {
+ self.func_index
+ }
+
+ /// Returns the identifer of the module that this frame is for.
+ ///
+ /// Module identifiers are present in the `name` section of a WebAssembly
+ /// binary, but this may not return the exact item in the `name` section.
+ /// Module names can be overwritten at construction time or perhaps inferred
+ /// from file names. The primary purpose of this function is to assist in
+ /// debugging and therefore may be tweaked over time.
+ ///
+ /// This function returns `None` when no name can be found or inferred.
+ pub fn module_name(&self) -> Option<&str> {
+ self.module_name.as_deref()
+ }
+
+ /// Returns a descriptive name of the function for this frame, if one is
+ /// available.
+ ///
+ /// The name of this function may come from the `name` section of the
+ /// WebAssembly binary, or wasmtime may try to infer a better name for it if
+ /// not available, for example the name of the export if it's exported.
+ ///
+ /// This return value is primarily used for debugging and human-readable
+ /// purposes for things like traps. Note that the exact return value may be
+ /// tweaked over time here and isn't guaranteed to be something in
+ /// particular about a wasm module due to its primary purpose of assisting
+ /// in debugging.
+ ///
+ /// This function returns `None` when no name could be inferred.
+ pub fn func_name(&self) -> Option<&str> {
+ self.func_name.as_deref()
+ }
+}
diff --git a/crates/api/src/func.rs b/crates/api/src/func.rs
new file mode 100644
index 0000000000..de0255feff
--- /dev/null
+++ b/crates/api/src/func.rs
@@ -0,0 +1,621 @@
+use crate::callable::{NativeCallable, WasmtimeFn, WrappedCallable};
+use crate::{Callable, FuncType, Store, Trap, Val, ValType};
+use anyhow::{ensure, Context as _};
+use std::fmt;
+use std::mem;
+use std::panic::{self, AssertUnwindSafe};
+use std::ptr;
+use std::rc::Rc;
+use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};
+
+/// A WebAssembly function which can be called.
+///
+/// This type can represent a number of callable items, such as:
+///
+/// * An exported function from a WebAssembly module.
+/// * A user-defined function used to satisfy an import.
+///
+/// These types of callable items are all wrapped up in this `Func` and can be
+/// used to both instantiate an [`Instance`](crate::Instance) as well as be
+/// extracted from an [`Instance`](crate::Instance).
+///
+/// # `Func` and `Clone`
+///
+/// Functions are internally reference counted so you can `clone` a `Func`. The
+/// cloning process only performs a shallow clone, so two cloned `Func`
+/// instances are equivalent in their functionality.
+#[derive(Clone)]
+pub struct Func {
+ _store: Store,
+ callable: Rc,
+ ty: FuncType,
+}
+
+macro_rules! wrappers {
+ ($(
+ $(#[$doc:meta])*
+ ($name:ident $(,$args:ident)*)
+ )*) => ($(
+ $(#[$doc])*
+ pub fn $name(store: &Store, func: F) -> Func
+ where
+ F: Fn($($args),*) -> R + 'static,
+ $($args: WasmTy,)*
+ R: WasmRet,
+ {
+ #[allow(non_snake_case)]
+ unsafe extern "C" fn shim(
+ vmctx: *mut VMContext,
+ _caller_vmctx: *mut VMContext,
+ $($args: $args::Abi,)*
+ ) -> R::Abi
+ where
+ F: Fn($($args),*) -> R + 'static,
+ $($args: WasmTy,)*
+ R: WasmRet,
+ {
+ let ret = {
+ let instance = InstanceHandle::from_vmctx(vmctx);
+ let func = instance.host_state().downcast_ref::().expect("state");
+ panic::catch_unwind(AssertUnwindSafe(|| {
+ func($($args::from_abi(_caller_vmctx, $args)),*)
+ }))
+ };
+ match ret {
+ Ok(ret) => ret.into_abi(),
+ Err(panic) => wasmtime_runtime::resume_panic(panic),
+ }
+ }
+
+ let mut _args = Vec::new();
+ $($args::push(&mut _args);)*
+ let mut ret = Vec::new();
+ R::push(&mut ret);
+ let ty = FuncType::new(_args.into(), ret.into());
+ unsafe {
+ let (instance, export) = crate::trampoline::generate_raw_func_export(
+ &ty,
+ std::slice::from_raw_parts_mut(
+ shim:: as *mut _,
+ 0,
+ ),
+ store,
+ Box::new(func),
+ )
+ .expect("failed to generate export");
+ let callable = Rc::new(WasmtimeFn::new(store, instance, export));
+ Func::from_wrapped(store, ty, callable)
+ }
+ }
+ )*)
+}
+
+macro_rules! getters {
+ ($(
+ $(#[$doc:meta])*
+ ($name:ident $(,$args:ident)*)
+ )*) => ($(
+ $(#[$doc])*
+ #[allow(non_snake_case)]
+ pub fn $name<$($args,)* R>(&self)
+ -> anyhow::Result Result>
+ where
+ $($args: WasmTy,)*
+ R: WasmTy,
+ {
+ // Verify all the paramers match the expected parameters, and that
+ // there are no extra parameters...
+ let mut params = self.ty().params().iter().cloned();
+ let n = 0;
+ $(
+ let n = n + 1;
+ $args::matches(&mut params)
+ .with_context(|| format!("Type mismatch in argument {}", n))?;
+ )*
+ ensure!(params.next().is_none(), "Type mismatch: too many arguments (expected {})", n);
+
+ // ... then do the same for the results...
+ let mut results = self.ty().results().iter().cloned();
+ R::matches(&mut results)
+ .context("Type mismatch in return type")?;
+ ensure!(results.next().is_none(), "Type mismatch: too many return values (expected 1)");
+
+ // ... and then once we've passed the typechecks we can hand out our
+ // object since our `transmute` below should be safe!
+ let (address, vmctx) = match self.wasmtime_export() {
+ wasmtime_runtime::Export::Function { address, vmctx, signature: _} => {
+ (*address, *vmctx)
+ }
+ _ => panic!("expected function export"),
+ };
+ Ok(move |$($args: $args),*| -> Result {
+ unsafe {
+ let f = mem::transmute::<
+ *const VMFunctionBody,
+ unsafe extern "C" fn(
+ *mut VMContext,
+ *mut VMContext,
+ $($args::Abi,)*
+ ) -> R::Abi,
+ >(address);
+ let mut ret = None;
+ $(let $args = $args.into_abi();)*
+ wasmtime_runtime::catch_traps(vmctx, || {
+ ret = Some(f(vmctx, ptr::null_mut(), $($args,)*));
+ }).map_err(Trap::from_jit)?;
+ Ok(R::from_abi(vmctx, ret.unwrap()))
+ }
+ })
+ }
+ )*)
+}
+
+impl Func {
+ /// Creates a new `Func` with the given arguments, typically to create a
+ /// user-defined function to pass as an import to a module.
+ ///
+ /// * `store` - a cache of data where information is stored, typically
+ /// shared with a [`Module`](crate::Module).
+ ///
+ /// * `ty` - the signature of this function, used to indicate what the
+ /// inputs and outputs are, which must be WebAssembly types.
+ ///
+ /// * `callable` - a type implementing the [`Callable`] trait which
+ /// is the implementation of this `Func` value.
+ ///
+ /// Note that the implementation of `callable` must adhere to the `ty`
+ /// signature given, error or traps may occur if it does not respect the
+ /// `ty` signature.
+ pub fn new(store: &Store, ty: FuncType, callable: Rc) -> Self {
+ let callable = Rc::new(NativeCallable::new(callable, &ty, &store));
+ Func::from_wrapped(store, ty, callable)
+ }
+
+ wrappers! {
+ /// Creates a new `Func` from the given Rust closure, which takes 0
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap0)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 1
+ /// argument.
+ ///
+ /// 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` |
+ /// | `i64` | `i64` |
+ /// | `f32` | `f32` |
+ /// | `f64` | `f64` |
+ /// | (not supported) | `v128` |
+ /// | (not supported) | `anyref` |
+ ///
+ /// 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 |
+ /// | `Result` | `T` | function may trap |
+ ///
+ /// Note that when using this API (and the related `wrap*` family of
+ /// functions), 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.
+ (wrap1, A1)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 2
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap2, A1, A2)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 3
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap3, A1, A2, A3)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 4
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap4, A1, A2, A3, A4)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 5
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap5, A1, A2, A3, A4, A5)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 6
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap6, A1, A2, A3, A4, A5, A6)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 7
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap7, A1, A2, A3, A4, A5, A6, A7)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 8
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap8, A1, A2, A3, A4, A5, A6, A7, A8)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 9
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap9, A1, A2, A3, A4, A5, A6, A7, A8, A9)
+
+ /// Creates a new `Func` from the given Rust closure, which takes 10
+ /// arguments.
+ ///
+ /// For more information about this function, see [`Func::wrap1`].
+ (wrap10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)
+ }
+
+ fn from_wrapped(
+ store: &Store,
+ ty: FuncType,
+ callable: Rc,
+ ) -> Func {
+ Func {
+ _store: store.clone(),
+ callable,
+ ty,
+ }
+ }
+
+ /// Returns the underlying wasm type that this `Func` has.
+ pub fn ty(&self) -> &FuncType {
+ &self.ty
+ }
+
+ /// Returns the number of parameters that this function takes.
+ pub fn param_arity(&self) -> usize {
+ self.ty.params().len()
+ }
+
+ /// Returns the number of results this function produces.
+ pub fn result_arity(&self) -> usize {
+ self.ty.results().len()
+ }
+
+ /// Invokes this function with the `params` given, returning the results and
+ /// any trap, if one occurs.
+ ///
+ /// The `params` here must match the type signature of this `Func`, or a
+ /// trap will occur. If a trap occurs while executing this function, then a
+ /// trap will also be returned.
+ ///
+ /// This function should not panic unless the underlying function itself
+ /// initiates a panic.
+ pub fn call(&self, params: &[Val]) -> Result, Trap> {
+ let mut results = vec![Val::null(); self.result_arity()];
+ self.callable.call(params, &mut results)?;
+ Ok(results.into_boxed_slice())
+ }
+
+ pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export {
+ self.callable.wasmtime_export()
+ }
+
+ pub(crate) fn from_wasmtime_function(
+ export: wasmtime_runtime::Export,
+ store: &Store,
+ instance_handle: InstanceHandle,
+ ) -> Self {
+ // This is only called with `Export::Function`, and since it's coming
+ // from wasmtime_runtime itself we should support all the types coming
+ // out of it, so assert such here.
+ let ty = if let wasmtime_runtime::Export::Function { signature, .. } = &export {
+ FuncType::from_wasmtime_signature(signature.clone())
+ .expect("core wasm signature should be supported")
+ } else {
+ panic!("expected function export")
+ };
+ let callable = WasmtimeFn::new(store, instance_handle, export);
+ Func::from_wrapped(store, ty, Rc::new(callable))
+ }
+
+ getters! {
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get0)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// This function serves as an optimized version of the [`Func::call`]
+ /// method if the type signature of a function is statically known to
+ /// the program. This method is faster than `call` on a few metrics:
+ ///
+ /// * Runtime type-checking only happens once, when this method is
+ /// called.
+ /// * The result values, if any, aren't boxed into a vector.
+ /// * Arguments and return values don't go through boxing and unboxing.
+ /// * No trampolines are used to transfer control flow to/from JIT code,
+ /// instead this function jumps directly into JIT code.
+ ///
+ /// For more information about which Rust types match up to which wasm
+ /// types, see the documentation on [`Func::wrap1`].
+ ///
+ /// # Return
+ ///
+ /// This function will return `None` if the type signature asserted
+ /// statically does not match the runtime type signature. `Some`,
+ /// however, will be returned if the underlying function takes one
+ /// parameter of type `A` and returns the parameter `R`. Currently `R`
+ /// can either be `()` (no return values) or one wasm type. At this time
+ /// a multi-value return isn't supported.
+ ///
+ /// The returned closure will always return a `Result` and an
+ /// `Err` is returned if a trap happens while the wasm is executing.
+ (get1, A1)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get2, A1, A2)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get3, A1, A2, A3)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get4, A1, A2, A3, A4)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get5, A1, A2, A3, A4, A5)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get6, A1, A2, A3, A4, A5, A6)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get7, A1, A2, A3, A4, A5, A6, A7)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get8, A1, A2, A3, A4, A5, A6, A7, A8)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get9, A1, A2, A3, A4, A5, A6, A7, A8, A9)
+
+ /// Extracts a natively-callable object from this `Func`, if the
+ /// signature matches.
+ ///
+ /// See the [`Func::get1`] method for more documentation.
+ (get10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)
+ }
+}
+
+impl fmt::Debug for Func {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Func")
+ }
+}
+
+/// A trait implemented for types which can be arguments to closures passed to
+/// [`Func::wrap1`] 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::wrap1`]
+pub trait WasmTy {
+ #[doc(hidden)]
+ type Abi: Copy;
+ #[doc(hidden)]
+ fn push(dst: &mut Vec);
+ #[doc(hidden)]
+ fn matches(tys: impl Iterator- ) -> anyhow::Result<()>;
+ #[doc(hidden)]
+ fn from_abi(vmctx: *mut VMContext, abi: Self::Abi) -> Self;
+ #[doc(hidden)]
+ fn into_abi(self) -> Self::Abi;
+}
+
+impl WasmTy for () {
+ type Abi = ();
+ fn push(_dst: &mut Vec) {}
+ fn matches(_tys: impl Iterator
- ) -> anyhow::Result<()> {
+ Ok(())
+ }
+ #[inline]
+ fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self {
+ abi
+ }
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ self
+ }
+}
+
+impl WasmTy for i32 {
+ type Abi = Self;
+ fn push(dst: &mut Vec) {
+ dst.push(ValType::I32);
+ }
+ fn matches(mut tys: impl Iterator
- ) -> anyhow::Result<()> {
+ let next = tys.next();
+ ensure!(
+ next == Some(ValType::I32),
+ "Type mismatch, expected i32, got {:?}",
+ next
+ );
+ Ok(())
+ }
+ #[inline]
+ fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self {
+ abi
+ }
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ self
+ }
+}
+
+impl WasmTy for i64 {
+ type Abi = Self;
+ fn push(dst: &mut Vec) {
+ dst.push(ValType::I64);
+ }
+ fn matches(mut tys: impl Iterator
- ) -> anyhow::Result<()> {
+ let next = tys.next();
+ ensure!(
+ next == Some(ValType::I64),
+ "Type mismatch, expected i64, got {:?}",
+ next
+ );
+ Ok(())
+ }
+ #[inline]
+ fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self {
+ abi
+ }
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ self
+ }
+}
+
+impl WasmTy for f32 {
+ type Abi = Self;
+ fn push(dst: &mut Vec) {
+ dst.push(ValType::F32);
+ }
+ fn matches(mut tys: impl Iterator
- ) -> anyhow::Result<()> {
+ let next = tys.next();
+ ensure!(
+ next == Some(ValType::F32),
+ "Type mismatch, expected f32, got {:?}",
+ next
+ );
+ Ok(())
+ }
+ #[inline]
+ fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self {
+ abi
+ }
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ self
+ }
+}
+
+impl WasmTy for f64 {
+ type Abi = Self;
+ fn push(dst: &mut Vec) {
+ dst.push(ValType::F64);
+ }
+ fn matches(mut tys: impl Iterator
- ) -> anyhow::Result<()> {
+ let next = tys.next();
+ ensure!(
+ next == Some(ValType::F64),
+ "Type mismatch, expected f64, got {:?}",
+ next
+ );
+ Ok(())
+ }
+ #[inline]
+ fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self {
+ abi
+ }
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ self
+ }
+}
+
+/// A trait implemented for types which can be returned from closures passed to
+/// [`Func::wrap1`] 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::wrap1`]
+pub trait WasmRet {
+ #[doc(hidden)]
+ type Abi;
+ #[doc(hidden)]
+ fn push(dst: &mut Vec);
+ #[doc(hidden)]
+ fn matches(tys: impl Iterator
- ) -> anyhow::Result<()>;
+ #[doc(hidden)]
+ fn into_abi(self) -> Self::Abi;
+}
+
+impl WasmRet for T {
+ type Abi = T::Abi;
+ fn push(dst: &mut Vec) {
+ T::push(dst)
+ }
+
+ fn matches(tys: impl Iterator
- ) -> anyhow::Result<()> {
+ T::matches(tys)
+ }
+
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ T::into_abi(self)
+ }
+}
+
+impl WasmRet for Result {
+ type Abi = T::Abi;
+ fn push(dst: &mut Vec) {
+ T::push(dst)
+ }
+
+ fn matches(tys: impl Iterator
- ) -> anyhow::Result<()> {
+ T::matches(tys)
+ }
+
+ #[inline]
+ fn into_abi(self) -> Self::Abi {
+ match self {
+ Ok(val) => return val.into_abi(),
+ Err(trap) => handle_trap(trap),
+ }
+
+ fn handle_trap(trap: Trap) -> ! {
+ unsafe { wasmtime_runtime::raise_user_trap(Box::new(trap)) }
+ }
+ }
+}
diff --git a/crates/api/src/instance.rs b/crates/api/src/instance.rs
new file mode 100644
index 0000000000..7d0b26260a
--- /dev/null
+++ b/crates/api/src/instance.rs
@@ -0,0 +1,186 @@
+use crate::externals::Extern;
+use crate::module::Module;
+use crate::runtime::{Config, Store};
+use crate::trap::Trap;
+use anyhow::{Error, Result};
+use wasmtime_jit::{CompiledModule, Resolver};
+use wasmtime_runtime::{Export, InstanceHandle, InstantiationError};
+
+struct SimpleResolver<'a> {
+ imports: &'a [Extern],
+}
+
+impl Resolver for SimpleResolver<'_> {
+ fn resolve(&mut self, idx: u32, _name: &str, _field: &str) -> Option {
+ self.imports
+ .get(idx as usize)
+ .map(|i| i.get_wasmtime_export())
+ }
+}
+
+fn instantiate(
+ config: &Config,
+ compiled_module: &CompiledModule,
+ imports: &[Extern],
+) -> Result {
+ let mut resolver = SimpleResolver { imports };
+ unsafe {
+ let instance = compiled_module
+ .instantiate(
+ config.validating_config.operator_config.enable_bulk_memory,
+ &mut resolver,
+ )
+ .map_err(|e| -> Error {
+ match e {
+ InstantiationError::StartTrap(trap) | InstantiationError::Trap(trap) => {
+ Trap::from_jit(trap).into()
+ }
+ other => other.into(),
+ }
+ })?;
+ Ok(instance)
+ }
+}
+
+/// 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. This is where all the fun stuff happens!
+///
+/// An [`Instance`] is created from two inputs, a [`Module`] and a list of
+/// imports, provided as a list of [`Extern`] values. The [`Module`] is the wasm
+/// code that was compiled and we're instantiating, and the [`Extern`] imports
+/// are how we're satisfying the imports of the module provided. On successful
+/// instantiation an [`Instance`] will automatically invoke the wasm `start`
+/// function.
+///
+/// When interacting with any wasm code you'll want to make an [`Instance`] to
+/// call any code or execute anything!
+#[derive(Clone)]
+pub struct Instance {
+ pub(crate) instance_handle: InstanceHandle,
+ module: Module,
+ exports: Box<[Extern]>,
+}
+
+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 provided) and then the [`Instance`] will be
+ /// returned.
+ ///
+ /// ## Providing Imports
+ ///
+ /// The `imports` array here is a bit tricky. 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. It is the
+ /// intention that we'll soon provide a [higher level API][issue] which will
+ /// be much more ergonomic for instantiating modules. If you need the full
+ /// power of customization of imports, though, this is the method for you!
+ ///
+ /// ## 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::()`.
+ ///
+ /// [inst]: https://webassembly.github.io/spec/core/exec/modules.html#exec-instantiation
+ /// [issue]: https://github.com/bytecodealliance/wasmtime/issues/727
+ pub fn new(module: &Module, imports: &[Extern]) -> Result {
+ let store = module.store();
+ let config = store.engine().config();
+ let instance_handle = instantiate(config, module.compiled_module(), imports)?;
+
+ let exports = {
+ let mut exports = Vec::with_capacity(module.exports().len());
+ for export in module.exports() {
+ let name = export.name().to_string();
+ let export = instance_handle.lookup(&name).expect("export");
+ exports.push(Extern::from_wasmtime_export(
+ store,
+ instance_handle.clone(),
+ export,
+ ));
+ }
+ exports.into_boxed_slice()
+ };
+ module.register_frame_info();
+ Ok(Instance {
+ instance_handle,
+ module: module.clone(),
+ exports,
+ })
+ }
+
+ /// Returns the associated [`Store`] that this `Instance` is compiled into.
+ ///
+ /// This is the [`Store`] that generally serves as a sort of global cache
+ /// for various instance-related things.
+ pub fn store(&self) -> &Store {
+ self.module.store()
+ }
+
+ /// Returns the associated [`Module`] that this `Instance` instantiated.
+ ///
+ /// The corresponding [`Module`] here is a static version of this `Instance`
+ /// which can be used to learn information such as naming information about
+ /// various functions.
+ pub fn module(&self) -> &Module {
+ &self.module
+ }
+
+ /// Returns the list of exported items from this [`Instance`].
+ ///
+ /// Note that the exports here do not have names associated with them,
+ /// they're simply the values that are exported. To learn the value of each
+ /// export you'll need to consult [`Module::exports`]. The list returned
+ /// here maps 1:1 with the list that [`Module::exports`] returns, and
+ /// [`ExportType`] contains the name of each export.
+ pub fn exports(&self) -> &[Extern] {
+ &self.exports
+ }
+
+ /// 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`.
+ pub fn get_export(&self, name: &str) -> Option<&Extern> {
+ let (i, _) = self
+ .module
+ .exports()
+ .iter()
+ .enumerate()
+ .find(|(_, e)| e.name() == name)?;
+ Some(&self.exports()[i])
+ }
+
+ #[doc(hidden)]
+ pub fn handle(&self) -> &InstanceHandle {
+ &self.instance_handle
+ }
+}
diff --git a/crates/api/src/lib.rs b/crates/api/src/lib.rs
new file mode 100644
index 0000000000..4e5bce5b6c
--- /dev/null
+++ b/crates/api/src/lib.rs
@@ -0,0 +1,44 @@
+//! Wasmtime's embedding API
+//!
+//! This crate contains a high-level API used to interact with WebAssembly
+//! modules. The API here is intended to mirror the proposed [WebAssembly C
+//! API](https://github.com/WebAssembly/wasm-c-api), with small extensions here
+//! and there to implement Rust idioms. This crate also defines the actual C API
+//! itself for consumption from other languages.
+
+#![deny(missing_docs)]
+
+mod callable;
+mod externals;
+mod frame_info;
+mod func;
+mod instance;
+mod module;
+mod r#ref;
+mod runtime;
+mod trampoline;
+mod trap;
+mod types;
+mod values;
+
+pub use crate::callable::Callable;
+pub use crate::externals::*;
+pub use crate::frame_info::FrameInfo;
+pub use crate::func::{Func, WasmRet, WasmTy};
+pub use crate::instance::Instance;
+pub use crate::module::Module;
+pub use crate::r#ref::{AnyRef, HostInfo, HostRef};
+pub use crate::runtime::{Config, Engine, OptLevel, Store, Strategy};
+pub use crate::trap::Trap;
+pub use crate::types::*;
+pub use crate::values::*;
+
+cfg_if::cfg_if! {
+ if #[cfg(unix)] {
+ pub mod unix;
+ } else if #[cfg(windows)] {
+ pub mod windows;
+ } else {
+ // ... unknown os!
+ }
+}
diff --git a/crates/api/src/module.rs b/crates/api/src/module.rs
new file mode 100644
index 0000000000..dd463d2fc5
--- /dev/null
+++ b/crates/api/src/module.rs
@@ -0,0 +1,442 @@
+use crate::frame_info::{GlobalFrameInfoRegistration, FRAME_INFO};
+use crate::runtime::Store;
+use crate::types::{
+ ExportType, ExternType, FuncType, GlobalType, ImportType, Limits, MemoryType, Mutability,
+ TableType, ValType,
+};
+use anyhow::{bail, Error, Result};
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+use wasmparser::{
+ validate, CustomSectionKind, ExternalKind, ImportSectionEntryType, ModuleReader, Name,
+ SectionCode,
+};
+use wasmtime_jit::CompiledModule;
+
+fn into_memory_type(mt: wasmparser::MemoryType) -> Result {
+ if mt.shared {
+ bail!("shared memories are not supported yet");
+ }
+ Ok(MemoryType::new(Limits::new(
+ mt.limits.initial,
+ mt.limits.maximum,
+ )))
+}
+
+fn into_global_type(gt: wasmparser::GlobalType) -> GlobalType {
+ let mutability = if gt.mutable {
+ Mutability::Var
+ } else {
+ Mutability::Const
+ };
+ GlobalType::new(into_valtype(>.content_type), mutability)
+}
+
+// `into_valtype` is used for `map` which requires `&T`.
+#[allow(clippy::trivially_copy_pass_by_ref)]
+fn into_valtype(ty: &wasmparser::Type) -> ValType {
+ use wasmparser::Type::*;
+ match ty {
+ I32 => ValType::I32,
+ I64 => ValType::I64,
+ F32 => ValType::F32,
+ F64 => ValType::F64,
+ V128 => ValType::V128,
+ AnyFunc => ValType::FuncRef,
+ AnyRef => ValType::AnyRef,
+ _ => unimplemented!("types in into_valtype"),
+ }
+}
+
+fn into_func_type(mt: wasmparser::FuncType) -> FuncType {
+ assert_eq!(mt.form, wasmparser::Type::Func);
+ let params = mt.params.iter().map(into_valtype).collect::>();
+ let returns = mt.returns.iter().map(into_valtype).collect::>();
+ FuncType::new(params.into_boxed_slice(), returns.into_boxed_slice())
+}
+
+fn into_table_type(tt: wasmparser::TableType) -> TableType {
+ assert!(
+ tt.element_type == wasmparser::Type::AnyFunc || tt.element_type == wasmparser::Type::AnyRef
+ );
+ let ty = into_valtype(&tt.element_type);
+ let limits = Limits::new(tt.limits.initial, tt.limits.maximum);
+ TableType::new(ty, limits)
+}
+
+/// 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.
+///
+/// ## 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.
+#[derive(Clone)]
+pub struct Module {
+ inner: Arc,
+}
+
+struct ModuleInner {
+ store: Store,
+ imports: Box<[ImportType]>,
+ exports: Box<[ExportType]>,
+ compiled: CompiledModule,
+ frame_info_registration: Mutex>>,
+ names: Arc,
+}
+
+pub struct Names {
+ pub module: Arc,
+ pub module_name: Option,
+}
+
+impl Module {
+ /// Creates a new WebAssembly `Module` from the given in-memory `bytes`.
+ ///
+ /// The `bytes` provided must be in one of two formats:
+ ///
+ /// * It can be a [binary-encoded][binary] WebAssembly module. This
+ /// is always supported.
+ /// * It may also be 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 `store` and
+ /// cached in this type.
+ ///
+ /// The provided `store` is a global cache for compiled resources as well as
+ /// configuration for what wasm features are enabled. It's recommended to
+ /// share a `store` among modules if possible.
+ ///
+ /// # 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 `store`
+ /// * 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
+ pub fn new(store: &Store, bytes: impl AsRef<[u8]>) -> Result {
+ #[cfg(feature = "wat")]
+ let bytes = wat::parse_bytes(bytes.as_ref())?;
+ Module::from_binary(store, bytes.as_ref())
+ }
+
+ /// Creates a new WebAssembly `Module` from the given in-memory `binary`
+ /// data. The provided `name` will be used in traps/backtrace details.
+ ///
+ /// See [`Module::new`] for other details.
+ pub fn new_with_name(store: &Store, bytes: impl AsRef<[u8]>, name: &str) -> Result {
+ let mut module = Module::new(store, bytes.as_ref())?;
+ let inner = Arc::get_mut(&mut module.inner).unwrap();
+ Arc::get_mut(&mut inner.names).unwrap().module_name = Some(name.to_string());
+ Ok(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`]
+ pub fn from_file(store: &Store, file: impl AsRef) -> Result {
+ #[cfg(feature = "wat")]
+ let wasm = wat::parse_file(file)?;
+ #[cfg(not(feature = "wat"))]
+ let wasm = std::fs::read(file)?;
+ Module::new(store, &wasm)
+ }
+
+ /// 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.
+ pub fn from_binary(store: &Store, binary: &[u8]) -> Result {
+ Module::validate(store, binary)?;
+ // Note that the call to `from_binary_unchecked` here should be ok
+ // because we previously validated the binary, meaning we're guaranteed
+ // to pass a valid binary for `store`.
+ unsafe { Module::from_binary_unchecked(store, binary) }
+ }
+
+ /// Creates a new WebAssembly `Module` from the given in-memory `binary`
+ /// data, skipping validation and asserting that `binary` is a valid
+ /// WebAssembly module.
+ ///
+ /// This function is the same as [`Module::new`] except that it skips the
+ /// call to [`Module::validate`] and it does not support the text format of
+ /// WebAssembly. The WebAssembly binary is not validated for
+ /// correctness and it is simply assumed as valid.
+ ///
+ /// For more information about creation of a module and the `store` argument
+ /// see the documentation of [`Module::new`].
+ ///
+ /// # Unsafety
+ ///
+ /// This function is `unsafe` due to the unchecked assumption that the input
+ /// `binary` is valid. If the `binary` is not actually a valid wasm binary it
+ /// may cause invalid machine code to get generated, cause panics, etc.
+ ///
+ /// It is only safe to call this method if [`Module::validate`] succeeds on
+ /// the same arguments passed to this function.
+ ///
+ /// # Errors
+ ///
+ /// This function may fail for many of the same reasons as [`Module::new`].
+ /// While this assumes that the binary is valid it still needs to actually
+ /// be somewhat valid for decoding purposes, and the basics of decoding can
+ /// still fail.
+ pub unsafe fn from_binary_unchecked(store: &Store, binary: &[u8]) -> Result {
+ let mut ret = Module::compile(store, binary)?;
+ ret.read_imports_and_exports(binary)?;
+ Ok(ret)
+ }
+
+ /// Validates `binary` input data as a WebAssembly binary given the
+ /// configuration in `store`.
+ ///
+ /// 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 `store` 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`], but is a
+ /// requirement for [`Module::new_unchecked`] to be safe.
+ ///
+ /// # 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(store: &Store, binary: &[u8]) -> Result<()> {
+ let config = store.engine().config().validating_config.clone();
+ validate(binary, Some(config)).map_err(Error::new)
+ }
+
+ unsafe fn compile(store: &Store, binary: &[u8]) -> Result {
+ let compiled = CompiledModule::new(
+ &mut store.compiler_mut(),
+ binary,
+ store.engine().config().debug_info,
+ store.engine().config().profiler.as_ref(),
+ )?;
+
+ let names = Arc::new(Names {
+ module_name: None,
+ module: compiled.module().clone(),
+ });
+ Ok(Module {
+ inner: Arc::new(ModuleInner {
+ store: store.clone(),
+ imports: Box::new([]),
+ exports: Box::new([]),
+ names,
+ compiled,
+ frame_info_registration: Mutex::new(None),
+ }),
+ })
+ }
+
+ pub(crate) fn compiled_module(&self) -> &CompiledModule {
+ &self.inner.compiled
+ }
+
+ /// Returns identifier/name that this [`Module`] has. This name
+ /// is used in traps/backtrace details.
+ pub fn name(&self) -> Option<&str> {
+ self.inner.names.module_name.as_deref()
+ }
+
+ /// Returns the list of imports that this [`Module`] has and must be
+ /// satisfied.
+ pub fn imports(&self) -> &[ImportType] {
+ &self.inner.imports
+ }
+
+ /// Returns the list of exports that this [`Module`] has and will be
+ /// available after instantiation.
+ pub fn exports(&self) -> &[ExportType] {
+ &self.inner.exports
+ }
+
+ /// Returns the [`Store`] that this [`Module`] was compiled into.
+ pub fn store(&self) -> &Store {
+ &self.inner.store
+ }
+
+ fn read_imports_and_exports(&mut self, binary: &[u8]) -> Result<()> {
+ let inner = Arc::get_mut(&mut self.inner).unwrap();
+ let mut reader = ModuleReader::new(binary)?;
+ let mut imports = Vec::new();
+ let mut exports = Vec::new();
+ let mut memories = Vec::new();
+ let mut tables = Vec::new();
+ let mut func_sig = Vec::new();
+ let mut sigs = Vec::new();
+ let mut globals = Vec::new();
+ while !reader.eof() {
+ let section = reader.read()?;
+ match section.code {
+ SectionCode::Memory => {
+ let section = section.get_memory_section_reader()?;
+ memories.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ memories.push(into_memory_type(entry?)?);
+ }
+ }
+ SectionCode::Type => {
+ let section = section.get_type_section_reader()?;
+ sigs.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ sigs.push(into_func_type(entry?));
+ }
+ }
+ SectionCode::Function => {
+ let section = section.get_function_section_reader()?;
+ func_sig.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ func_sig.push(entry?);
+ }
+ }
+ SectionCode::Global => {
+ let section = section.get_global_section_reader()?;
+ globals.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ globals.push(into_global_type(entry?.ty));
+ }
+ }
+ SectionCode::Table => {
+ let section = section.get_table_section_reader()?;
+ tables.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ tables.push(into_table_type(entry?))
+ }
+ }
+ SectionCode::Import => {
+ let section = section.get_import_section_reader()?;
+ imports.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ let entry = entry?;
+ let r#type = match entry.ty {
+ ImportSectionEntryType::Function(index) => {
+ func_sig.push(index);
+ let sig = &sigs[index as usize];
+ ExternType::Func(sig.clone())
+ }
+ ImportSectionEntryType::Table(tt) => {
+ let table = into_table_type(tt);
+ tables.push(table.clone());
+ ExternType::Table(table)
+ }
+ ImportSectionEntryType::Memory(mt) => {
+ let memory = into_memory_type(mt)?;
+ memories.push(memory.clone());
+ ExternType::Memory(memory)
+ }
+ ImportSectionEntryType::Global(gt) => {
+ let global = into_global_type(gt);
+ globals.push(global.clone());
+ ExternType::Global(global)
+ }
+ };
+ imports.push(ImportType::new(entry.module, entry.field, r#type));
+ }
+ }
+ SectionCode::Export => {
+ let section = section.get_export_section_reader()?;
+ exports.reserve_exact(section.get_count() as usize);
+ for entry in section {
+ let entry = entry?;
+ let r#type = match entry.kind {
+ ExternalKind::Function => {
+ let sig_index = func_sig[entry.index as usize] as usize;
+ let sig = &sigs[sig_index];
+ ExternType::Func(sig.clone())
+ }
+ ExternalKind::Table => {
+ ExternType::Table(tables[entry.index as usize].clone())
+ }
+ ExternalKind::Memory => {
+ ExternType::Memory(memories[entry.index as usize].clone())
+ }
+ ExternalKind::Global => {
+ ExternType::Global(globals[entry.index as usize].clone())
+ }
+ };
+ exports.push(ExportType::new(entry.field, r#type));
+ }
+ }
+ SectionCode::Custom {
+ kind: CustomSectionKind::Name,
+ ..
+ } => {
+ // Read name section. Per spec, ignore invalid custom section.
+ if let Ok(mut reader) = section.get_name_section_reader() {
+ while let Ok(entry) = reader.read() {
+ if let Name::Module(name) = entry {
+ if let Ok(name) = name.get_name() {
+ Arc::get_mut(&mut inner.names).unwrap().module_name =
+ Some(name.to_string());
+ }
+ break;
+ }
+ }
+ }
+ }
+ _ => {
+ // skip other sections
+ }
+ }
+ }
+
+ inner.imports = imports.into();
+ inner.exports = exports.into();
+ Ok(())
+ }
+
+ /// Register this module's stack frame information into the global scope.
+ ///
+ /// This is required to ensure that any traps can be properly symbolicated.
+ pub(crate) fn register_frame_info(&self) {
+ let mut info = self.inner.frame_info_registration.lock().unwrap();
+ if info.is_some() {
+ return;
+ }
+ *info = Some(FRAME_INFO.register(&self.inner.names, &self.inner.compiled));
+ }
+}
diff --git a/crates/api/src/ref.rs b/crates/api/src/ref.rs
new file mode 100644
index 0000000000..f5dbd2ee42
--- /dev/null
+++ b/crates/api/src/ref.rs
@@ -0,0 +1,243 @@
+#![allow(missing_docs)]
+
+use std::any::Any;
+use std::cell::{self, RefCell};
+use std::fmt;
+use std::rc::{Rc, Weak};
+
+pub trait HostInfo {
+ fn finalize(&mut self) {}
+}
+
+trait InternalRefBase: Any {
+ fn as_any(&self) -> &dyn Any;
+ fn host_info(&self) -> Option>>;
+ fn set_host_info(&self, info: Option>);
+ fn ptr_eq(&self, other: &dyn InternalRefBase) -> bool;
+}
+
+#[derive(Clone)]
+pub struct InternalRef(Rc);
+
+impl InternalRef {
+ pub fn is_ref(&self) -> bool {
+ let r = self.0.as_any();
+ Any::is::>(r)
+ }
+ pub fn get_ref(&self) -> HostRef {
+ let r = self.0.as_any();
+ r.downcast_ref::>()
+ .expect("reference is not T type")
+ .clone()
+ }
+}
+
+struct AnyAndHostInfo {
+ any: Box,
+ host_info: Option>,
+}
+
+impl Drop for AnyAndHostInfo {
+ fn drop(&mut self) {
+ if let Some(info) = &mut self.host_info {
+ info.finalize();
+ }
+ }
+}
+
+#[derive(Clone)]
+pub struct OtherRef(Rc>);
+
+/// Represents an opaque reference to any data within WebAssembly.
+#[derive(Clone)]
+pub enum AnyRef {
+ /// A reference to no data.
+ Null,
+ /// A reference to data stored internally in `wasmtime`.
+ Ref(InternalRef),
+ /// A reference to data located outside of `wasmtime`.
+ Other(OtherRef),
+}
+
+impl AnyRef {
+ /// Creates a new instance of `AnyRef` from `Box`.
+ pub fn new(data: Box) -> Self {
+ let info = AnyAndHostInfo {
+ any: data,
+ host_info: None,
+ };
+ AnyRef::Other(OtherRef(Rc::new(RefCell::new(info))))
+ }
+
+ /// Creates a `Null` reference.
+ pub fn null() -> Self {
+ AnyRef::Null
+ }
+
+ /// Returns the data stored in the reference if available.
+ /// # Panics
+ /// Panics if the variant isn't `AnyRef::Other`.
+ pub fn data(&self) -> cell::Ref> {
+ match self {
+ AnyRef::Other(OtherRef(r)) => cell::Ref::map(r.borrow(), |r| &r.any),
+ _ => panic!("expected AnyRef::Other"),
+ }
+ }
+
+ /// Returns true if the two `AnyRef`'s point to the same value (not just
+ /// values that compare as equal).
+ pub fn ptr_eq(&self, other: &AnyRef) -> bool {
+ match (self, other) {
+ (AnyRef::Null, AnyRef::Null) => true,
+ (AnyRef::Ref(InternalRef(ref a)), AnyRef::Ref(InternalRef(ref b))) => {
+ a.ptr_eq(b.as_ref())
+ }
+ (AnyRef::Other(OtherRef(ref a)), AnyRef::Other(OtherRef(ref b))) => Rc::ptr_eq(a, b),
+ _ => false,
+ }
+ }
+
+ /// Returns a mutable reference to the host information if available.
+ /// # Panics
+ /// Panics if `AnyRef` is already borrowed or `AnyRef` is `Null`.
+ pub fn host_info(&self) -> Option>> {
+ match self {
+ AnyRef::Null => panic!("null"),
+ AnyRef::Ref(r) => r.0.host_info(),
+ AnyRef::Other(r) => {
+ let info = cell::RefMut::map(r.0.borrow_mut(), |b| &mut b.host_info);
+ if info.is_none() {
+ return None;
+ }
+ Some(cell::RefMut::map(info, |info| info.as_mut().unwrap()))
+ }
+ }
+ }
+
+ /// Sets the host information for an `AnyRef`.
+ /// # Panics
+ /// Panics if `AnyRef` is already borrowed or `AnyRef` is `Null`.
+ pub fn set_host_info(&self, info: Option>) {
+ match self {
+ AnyRef::Null => panic!("null"),
+ AnyRef::Ref(r) => r.0.set_host_info(info),
+ AnyRef::Other(r) => {
+ r.0.borrow_mut().host_info = info;
+ }
+ }
+ }
+}
+
+impl fmt::Debug for AnyRef {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ AnyRef::Null => write!(f, "null"),
+ AnyRef::Ref(_) => write!(f, "anyref"),
+ AnyRef::Other(_) => write!(f, "other ref"),
+ }
+ }
+}
+
+struct ContentBox {
+ content: T,
+ host_info: Option>,
+ anyref_data: Weak,
+}
+
+impl Drop for ContentBox {
+ fn drop(&mut self) {
+ if let Some(info) = &mut self.host_info {
+ info.finalize();
+ }
+ }
+}
+
+/// Represents a piece of data located in the host environment.
+pub struct HostRef(Rc>>);
+
+impl HostRef {
+ /// Creates a new `HostRef` from `T`.
+ pub fn new(item: T) -> HostRef {
+ let anyref_data: Weak> = Weak::new();
+ let content = ContentBox {
+ content: item,
+ host_info: None,
+ anyref_data,
+ };
+ HostRef(Rc::new(RefCell::new(content)))
+ }
+
+ /// Immutably borrows the wrapped data.
+ /// # Panics
+ /// Panics if the value is currently mutably borrowed.
+ pub fn borrow(&self) -> cell::Ref {
+ cell::Ref::map(self.0.borrow(), |b| &b.content)
+ }
+
+ /// Mutably borrows the wrapped data.
+ /// # Panics
+ /// Panics if the `HostRef` is already borrowed.
+ pub fn borrow_mut(&self) -> cell::RefMut {
+ cell::RefMut::map(self.0.borrow_mut(), |b| &mut b.content)
+ }
+
+ /// Returns true if the two `HostRef`'s point to the same value (not just
+ /// values that compare as equal).
+ pub fn ptr_eq(&self, other: &HostRef) -> bool {
+ Rc::ptr_eq(&self.0, &other.0)
+ }
+
+ /// Returns an opaque reference to the wrapped data in the form of
+ /// an `AnyRef`.
+ /// # Panics
+ /// Panics if `HostRef` is already mutably borrowed.
+ pub fn anyref(&self) -> AnyRef {
+ let r = self.0.borrow_mut().anyref_data.upgrade();
+ if let Some(r) = r {
+ return AnyRef::Ref(InternalRef(r));
+ }
+ let anyref_data: Rc = Rc::new(self.clone());
+ self.0.borrow_mut().anyref_data = Rc::downgrade(&anyref_data);
+ AnyRef::Ref(InternalRef(anyref_data))
+ }
+}
+
+impl InternalRefBase for HostRef {
+ fn ptr_eq(&self, other: &dyn InternalRefBase) -> bool {
+ if let Some(other) = other.as_any().downcast_ref() {
+ self.ptr_eq(other)
+ } else {
+ false
+ }
+ }
+
+ fn as_any(&self) -> &dyn Any {
+ self
+ }
+
+ fn host_info(&self) -> Option>> {
+ let info = cell::RefMut::map(self.0.borrow_mut(), |b| &mut b.host_info);
+ if info.is_none() {
+ return None;
+ }
+ Some(cell::RefMut::map(info, |info| info.as_mut().unwrap()))
+ }
+
+ fn set_host_info(&self, info: Option>) {
+ self.0.borrow_mut().host_info = info;
+ }
+}
+
+impl Clone for HostRef {
+ fn clone(&self) -> HostRef {
+ HostRef(self.0.clone())
+ }
+}
+
+impl fmt::Debug for HostRef {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Ref(")?;
+ self.0.borrow().content.fmt(f)?;
+ write!(f, ")")
+ }
+}
diff --git a/crates/api/src/runtime.rs b/crates/api/src/runtime.rs
new file mode 100644
index 0000000000..25aa3f6a58
--- /dev/null
+++ b/crates/api/src/runtime.rs
@@ -0,0 +1,577 @@
+use anyhow::Result;
+use std::cell::RefCell;
+use std::fmt;
+use std::path::Path;
+use std::rc::Rc;
+use std::sync::{Arc, Mutex};
+use wasmparser::{OperatorValidatorConfig, ValidatingParserConfig};
+use wasmtime_environ::settings::{self, Configurable};
+use wasmtime_environ::CacheConfig;
+use wasmtime_jit::{native, CompilationStrategy, Compiler};
+use wasmtime_profiling::{JitDumpAgent, ProfilingAgent, ProfilingStrategy};
+
+// Runtime Environment
+
+// Configuration
+
+/// Global configuration options used to create an [`Engine`] and customize its
+/// behavior.
+///
+/// This structure exposed a builder-like interface and is primarily consumed by
+/// [`Engine::new()`]
+#[derive(Clone)]
+pub struct Config {
+ pub(crate) flags: settings::Builder,
+ pub(crate) validating_config: ValidatingParserConfig,
+ pub(crate) debug_info: bool,
+ pub(crate) strategy: CompilationStrategy,
+ pub(crate) cache_config: CacheConfig,
+ pub(crate) profiler: Option>>>,
+}
+
+impl Config {
+ /// Creates a new configuration object with the default configuration
+ /// specified.
+ pub fn new() -> Config {
+ let mut flags = settings::builder();
+
+ // There are two possible traps for division, and this way
+ // we get the proper one if code traps.
+ flags
+ .enable("avoid_div_traps")
+ .expect("should be valid flag");
+
+ // Invert cranelift's default-on verification to instead default off.
+ flags
+ .set("enable_verifier", "false")
+ .expect("should be valid flag");
+
+ // Turn on cranelift speed optimizations by default
+ flags
+ .set("opt_level", "speed")
+ .expect("should be valid flag");
+
+ Config {
+ debug_info: false,
+ validating_config: ValidatingParserConfig {
+ operator_config: OperatorValidatorConfig {
+ enable_threads: false,
+ enable_reference_types: false,
+ enable_bulk_memory: false,
+ enable_simd: false,
+ enable_multi_value: false,
+ },
+ },
+ flags,
+ strategy: CompilationStrategy::Auto,
+ cache_config: CacheConfig::new_cache_disabled(),
+ profiler: None,
+ }
+ }
+
+ /// Configures whether DWARF debug information will be emitted during
+ /// compilation.
+ ///
+ /// By default this option is `false`.
+ pub fn debug_info(&mut self, enable: bool) -> &mut Self {
+ self.debug_info = enable;
+ self
+ }
+
+ /// Configures whether the WebAssembly threads proposal will be enabled for
+ /// compilation.
+ ///
+ /// 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.
+ ///
+ /// This feature gates items such as shared memories and atomic
+ /// instructions. Note that enabling the threads feature will
+ /// also enable the bulk memory feature.
+ ///
+ /// This is `false` by default.
+ ///
+ /// [threads]: https://github.com/webassembly/threads
+ pub fn wasm_threads(&mut self, enable: bool) -> &mut Self {
+ self.validating_config.operator_config.enable_threads = enable;
+ // The threads proposal depends on the bulk memory proposal
+ if enable {
+ self.wasm_bulk_memory(true);
+ }
+ self
+ }
+
+ /// Configures whether the WebAssembly reference types proposal will be
+ /// enabled for compilation.
+ ///
+ /// The [WebAssembly reference types proposal][proposal] 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.
+ ///
+ /// This feature gates items such as the `anyref` type and multiple tables
+ /// being in a module. Note that enabling the reference types feature will
+ /// also enable the bulk memory feature.
+ ///
+ /// This is `false` by default.
+ ///
+ /// [proposal]: https://github.com/webassembly/reference-types
+ pub fn wasm_reference_types(&mut self, enable: bool) -> &mut Self {
+ self.validating_config
+ .operator_config
+ .enable_reference_types = enable;
+ // The reference types proposal depends on the bulk memory proposal
+ if enable {
+ self.wasm_bulk_memory(true);
+ }
+ self
+ }
+
+ /// Configures whether the WebAssembly SIMD proposal will be
+ /// enabled for compilation.
+ ///
+ /// The [WebAssembly SIMD proposal][proposal] 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.
+ ///
+ /// This feature gates items such as the `v128` type and all of its
+ /// operators being in a module.
+ ///
+ /// This is `false` by default.
+ ///
+ /// [proposal]: https://github.com/webassembly/simd
+ pub fn wasm_simd(&mut self, enable: bool) -> &mut Self {
+ self.validating_config.operator_config.enable_simd = enable;
+ let val = if enable { "true" } else { "false" };
+ self.flags
+ .set("enable_simd", val)
+ .expect("should be valid flag");
+ self
+ }
+
+ /// Configures whether the WebAssembly bulk memory operations proposal will
+ /// be enabled for compilation.
+ ///
+ /// The [WebAssembly bulk memory operations proposal][proposal] 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.
+ ///
+ /// This feature gates items such as the `memory.copy` instruction, passive
+ /// data/table segments, etc, being in a module.
+ ///
+ /// This is `false` by default.
+ ///
+ /// [proposal]: https://github.com/webassembly/bulk-memory-operations
+ pub fn wasm_bulk_memory(&mut self, enable: bool) -> &mut Self {
+ self.validating_config.operator_config.enable_bulk_memory = enable;
+ self
+ }
+
+ /// Configures whether the WebAssembly multi-value proposal will
+ /// be enabled for compilation.
+ ///
+ /// The [WebAssembly multi-value proposal][proposal] 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.
+ ///
+ /// This feature gates functions and blocks returning multiple values in a
+ /// module, for example.
+ ///
+ /// This is `false` by default.
+ ///
+ /// [proposal]: https://github.com/webassembly/multi-value
+ pub fn wasm_multi_value(&mut self, enable: bool) -> &mut Self {
+ self.validating_config.operator_config.enable_multi_value = enable;
+ self
+ }
+
+ /// Configures which compilation strategy will be used for wasm modules.
+ ///
+ /// This method can be used to configure which compiler is used for wasm
+ /// modules, and for more documentation consult the [`Strategy`] enumeration
+ /// and its documentation.
+ ///
+ /// The default value for this is `Strategy::Auto`.
+ ///
+ /// # Errors
+ ///
+ /// Some compilation strategies require compile-time options of `wasmtime`
+ /// itself to be set, but if they're not set and the strategy is specified
+ /// here then an error will be returned.
+ pub fn strategy(&mut self, strategy: Strategy) -> Result<&mut Self> {
+ self.strategy = match strategy {
+ Strategy::Auto => CompilationStrategy::Auto,
+ Strategy::Cranelift => CompilationStrategy::Cranelift,
+ #[cfg(feature = "lightbeam")]
+ Strategy::Lightbeam => CompilationStrategy::Lightbeam,
+ #[cfg(not(feature = "lightbeam"))]
+ Strategy::Lightbeam => {
+ anyhow::bail!("lightbeam compilation strategy wasn't enabled at compile time");
+ }
+ };
+ Ok(self)
+ }
+
+ /// Creates a default profiler based on the profiling strategy choosen
+ ///
+ /// Profiler creation calls the type's default initializer where the purpose is
+ /// really just to put in place the type used for profiling.
+ pub fn profiler(&mut self, profile: ProfilingStrategy) -> Result<&mut Self> {
+ match profile {
+ ProfilingStrategy::JitDumpProfiler => {
+ self.profiler = { Some(Arc::new(Mutex::new(Box::new(JitDumpAgent::default())))) }
+ }
+ _ => self.profiler = { None },
+ };
+ Ok(self)
+ }
+
+ /// Configures whether the debug verifier of Cranelift is enabled or not.
+ ///
+ /// When Cranelift is used as a code generation backend this will configure
+ /// it to have the `enable_verifier` flag which will enable a number of debug
+ /// checks inside of Cranelift. This is largely only useful for the
+ /// developers of wasmtime itself.
+ ///
+ /// The default value for this is `false`
+ pub fn cranelift_debug_verifier(&mut self, enable: bool) -> &mut Self {
+ let val = if enable { "true" } else { "false" };
+ self.flags
+ .set("enable_verifier", val)
+ .expect("should be valid flag");
+ self
+ }
+
+ /// Configures the Cranelift code generator optimization level.
+ ///
+ /// When the Cranelift code generator is used you can configure the
+ /// optimization level used for generated code in a few various ways. For
+ /// more information see the documentation of [`OptLevel`].
+ ///
+ /// The default value for this is `OptLevel::None`.
+ pub fn cranelift_opt_level(&mut self, level: OptLevel) -> &mut Self {
+ let val = match level {
+ OptLevel::None => "none",
+ OptLevel::Speed => "speed",
+ OptLevel::SpeedAndSize => "speed_and_size",
+ };
+ self.flags
+ .set("opt_level", val)
+ .expect("should be valid flag");
+ self
+ }
+
+ /// Loads cache configuration specified at `path`.
+ ///
+ /// This method will read the file specified by `path` on the filesystem and
+ /// attempt to load cache configuration from it. This method can also fail
+ /// due to I/O errors, misconfiguration, syntax errors, etc. For expected
+ /// syntax in the configuration file see the [documentation online][docs].
+ ///
+ /// By default cache configuration is not enabled or loaded.
+ ///
+ /// # Errors
+ ///
+ /// This method can fail due to any error that happens when loading the file
+ /// pointed to by `path` and attempting to load the cache configuration.
+ ///
+ /// [docs]: https://bytecodealliance.github.io/wasmtime/cli-cache.html
+ pub fn cache_config_load(&mut self, path: impl AsRef) -> Result<&mut Self> {
+ self.cache_config = wasmtime_environ::CacheConfig::from_file(Some(path.as_ref()))?;
+ Ok(self)
+ }
+
+ /// Loads cache configuration from the system default path.
+ ///
+ /// This commit is the same as [`Config::cache_config_load`] except that it
+ /// does not take a path argument and instead loads the default
+ /// configuration present on the system. This is located, for example, on
+ /// Unix at `$HOME/.config/wasmtime/config.toml` and is typically created
+ /// with the `wasmtime config new` command.
+ ///
+ /// By default cache configuration is not enabled or loaded.
+ ///
+ /// # Errors
+ ///
+ /// This method can fail due to any error that happens when loading the
+ /// default system configuration. Note that it is not an error if the
+ /// default config file does not exist, in which case the default settings
+ /// for an enabled cache are applied.
+ ///
+ /// [docs]: https://bytecodealliance.github.io/wasmtime/cli-cache.html
+ pub fn cache_config_load_default(&mut self) -> Result<&mut Self> {
+ self.cache_config = wasmtime_environ::CacheConfig::from_file(None)?;
+ Ok(self)
+ }
+}
+
+impl Default for Config {
+ fn default() -> Config {
+ Config::new()
+ }
+}
+
+impl fmt::Debug for Config {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let features = &self.validating_config.operator_config;
+ f.debug_struct("Config")
+ .field("debug_info", &self.debug_info)
+ .field("strategy", &self.strategy)
+ .field("wasm_threads", &features.enable_threads)
+ .field("wasm_reference_types", &features.enable_reference_types)
+ .field("wasm_bulk_memory", &features.enable_bulk_memory)
+ .field("wasm_simd", &features.enable_simd)
+ .field("wasm_multi_value", &features.enable_multi_value)
+ .field(
+ "flags",
+ &settings::Flags::new(self.flags.clone()).to_string(),
+ )
+ .finish()
+ }
+}
+
+/// Possible Compilation strategies for a wasm module.
+///
+/// This is used as an argument to the [`Config::strategy`] method.
+#[non_exhaustive]
+#[derive(Clone, Debug)]
+pub enum Strategy {
+ /// An indicator that the compilation strategy should be automatically
+ /// selected.
+ ///
+ /// This is generally what you want for most projects and indicates that the
+ /// `wasmtime` crate itself should make the decision about what the best
+ /// code generator for a wasm module is.
+ ///
+ /// Currently this always defaults to Cranelift, but the default value will
+ /// change over time.
+ Auto,
+
+ /// Currently the default backend, Cranelift aims to be a reasonably fast
+ /// code generator which generates high quality machine code.
+ Cranelift,
+
+ /// A single-pass code generator that is faster than Cranelift but doesn't
+ /// produce as high-quality code.
+ ///
+ /// To successfully pass this argument to [`Config::strategy`] the
+ /// `lightbeam` feature of this crate must be enabled.
+ Lightbeam,
+}
+
+/// Possible optimization levels for the Cranelift codegen backend.
+#[non_exhaustive]
+#[derive(Clone, Debug)]
+pub enum OptLevel {
+ /// No optimizations performed, minimizes compilation time by disabling most
+ /// optimizations.
+ None,
+ /// Generates the fastest possible code, but may take longer.
+ Speed,
+ /// Similar to `speed`, but also performs transformations aimed at reducing
+ /// code size.
+ SpeedAndSize,
+}
+
+// Engine
+
+/// An `Engine` which is a global context for compilation and management of wasm
+/// modules.
+///
+/// An engine can be safely shared across threads and is a cheap cloneable
+/// handle to the actual engine. The engine itself will be deallocate once all
+/// references to it have gone away.
+///
+/// Engines store global configuration preferences such as compilation settings,
+/// enabled features, etc. You'll likely only need at most one of these for a
+/// program.
+///
+/// ## Engines and `Clone`
+///
+/// Using `clone` on an `Engine` is a cheap operation. It will not create an
+/// entirely new engine, but rather just a new reference to the existing engine.
+/// In other words it's a shallow copy, not a deep copy.
+///
+/// ## Engines and `Default`
+///
+/// You can create an engine with default configuration settings using
+/// `Engine::default()`. Be sure to consult the documentation of [`Config`] for
+/// default settings.
+#[derive(Default, Clone)]
+pub struct Engine {
+ config: Arc,
+}
+
+impl Engine {
+ /// Creates a new [`Engine`] with the specified compilation and
+ /// configuration settings.
+ pub fn new(config: &Config) -> Engine {
+ Engine {
+ config: Arc::new(config.clone()),
+ }
+ }
+
+ /// Returns the configuration settings that this engine is using.
+ pub fn config(&self) -> &Config {
+ &self.config
+ }
+}
+
+// Store
+
+/// A `Store` is a shared cache of information between WebAssembly modules.
+///
+/// Each `Module` is compiled into a `Store` and a `Store` is associated with an
+/// [`Engine`]. You'll use a `Store` to attach to a number of global items in
+/// the production of various items for wasm modules.
+///
+/// # Stores and `Clone`
+///
+/// Using `clone` on a `Store` is a cheap operation. It will not create an
+/// entirely new store, but rather just a new reference to the existing object.
+/// In other words it's a shallow copy, not a deep copy.
+///
+/// ## Stores and `Default`
+///
+/// You can create a store with default configuration settings using
+/// `Store::default()`. This will create a brand new [`Engine`] with default
+/// ocnfiguration (see [`Config`] for more information).
+#[derive(Clone)]
+pub struct Store {
+ // FIXME(#777) should be `Arc` and this type should be thread-safe
+ inner: Rc,
+}
+
+struct StoreInner {
+ engine: Engine,
+ compiler: RefCell,
+}
+
+impl Store {
+ /// Creates a new store to be associated with the given [`Engine`].
+ pub fn new(engine: &Engine) -> Store {
+ let isa = native::builder().finish(settings::Flags::new(engine.config.flags.clone()));
+ let compiler = Compiler::new(
+ isa,
+ engine.config.strategy,
+ engine.config.cache_config.clone(),
+ );
+ Store {
+ inner: Rc::new(StoreInner {
+ engine: engine.clone(),
+ compiler: RefCell::new(compiler),
+ }),
+ }
+ }
+
+ /// Returns the [`Engine`] that this store is associated with.
+ pub fn engine(&self) -> &Engine {
+ &self.inner.engine
+ }
+
+ pub(crate) fn compiler(&self) -> std::cell::Ref<'_, Compiler> {
+ self.inner.compiler.borrow()
+ }
+
+ pub(crate) fn compiler_mut(&self) -> std::cell::RefMut<'_, Compiler> {
+ self.inner.compiler.borrow_mut()
+ }
+
+ /// Returns whether the stores `a` and `b` refer to the same underlying
+ /// `Store`.
+ ///
+ /// Because the `Store` type is reference counted multiple clones may point
+ /// to the same underlying storage, and this method can be used to determine
+ /// whether two stores are indeed the same.
+ pub fn same(a: &Store, b: &Store) -> bool {
+ Rc::ptr_eq(&a.inner, &b.inner)
+ }
+}
+
+impl Default for Store {
+ fn default() -> Store {
+ Store::new(&Engine::default())
+ }
+}
+
+fn _assert_send_sync() {
+ fn _assert() {}
+ _assert::();
+ _assert::();
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::Module;
+ use tempfile::TempDir;
+
+ #[test]
+ 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 store = Store::new(&Engine::new(&cfg));
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 0);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 1);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+
+ let mut cfg = Config::new();
+ cfg.cranelift_opt_level(OptLevel::Speed)
+ .cache_config_load(&config_path)?;
+ let store = Store::new(&Engine::new(&cfg));
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 0);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 1);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+
+ let mut cfg = Config::new();
+ cfg.cranelift_opt_level(OptLevel::SpeedAndSize)
+ .cache_config_load(&config_path)?;
+ let store = Store::new(&Engine::new(&cfg));
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 0);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 1);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+
+ let mut cfg = Config::new();
+ cfg.debug_info(true).cache_config_load(&config_path)?;
+ let store = Store::new(&Engine::new(&cfg));
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 0);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+ Module::new(&store, "(module (func))")?;
+ assert_eq!(store.engine().config.cache_config.cache_hits(), 1);
+ assert_eq!(store.engine().config.cache_config.cache_misses(), 1);
+
+ Ok(())
+ }
+}
diff --git a/crates/api/src/trampoline/create_handle.rs b/crates/api/src/trampoline/create_handle.rs
new file mode 100644
index 0000000000..d3d295de9d
--- /dev/null
+++ b/crates/api/src/trampoline/create_handle.rs
@@ -0,0 +1,54 @@
+//! Support for a calling of an imported function.
+
+use crate::runtime::Store;
+use anyhow::Result;
+use std::any::Any;
+use std::collections::HashSet;
+use std::sync::Arc;
+use wasmtime_environ::entity::PrimaryMap;
+use wasmtime_environ::wasm::DefinedFuncIndex;
+use wasmtime_environ::Module;
+use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody};
+
+pub(crate) fn create_handle(
+ module: Module,
+ store: &Store,
+ finished_functions: PrimaryMap,
+ state: Box,
+) -> Result {
+ let imports = Imports::new(
+ HashSet::new(),
+ PrimaryMap::new(),
+ PrimaryMap::new(),
+ PrimaryMap::new(),
+ PrimaryMap::new(),
+ );
+ let data_initializers = Vec::new();
+
+ // Compute indices into the shared signature table.
+ let signatures = module
+ .local
+ .signatures
+ .values()
+ .map(|sig| store.compiler().signatures().register(sig))
+ .collect::>();
+
+ unsafe {
+ Ok(InstanceHandle::new(
+ Arc::new(module),
+ store.compiler().trap_registry().register_traps(Vec::new()),
+ finished_functions.into_boxed_slice(),
+ imports,
+ &data_initializers,
+ signatures.into_boxed_slice(),
+ None,
+ store
+ .engine()
+ .config()
+ .validating_config
+ .operator_config
+ .enable_bulk_memory,
+ state,
+ )?)
+ }
+}
diff --git a/crates/api/src/trampoline/func.rs b/crates/api/src/trampoline/func.rs
new file mode 100644
index 0000000000..83753be403
--- /dev/null
+++ b/crates/api/src/trampoline/func.rs
@@ -0,0 +1,326 @@
+//! Support for a calling of an imported function.
+
+use super::create_handle::create_handle;
+use crate::{Callable, FuncType, Store, Trap, Val};
+use anyhow::{bail, Result};
+use std::any::Any;
+use std::cmp;
+use std::panic::{self, AssertUnwindSafe};
+use std::rc::Rc;
+use wasmtime_environ::entity::{EntityRef, PrimaryMap};
+use wasmtime_environ::ir::types;
+use wasmtime_environ::isa::TargetIsa;
+use wasmtime_environ::wasm::{DefinedFuncIndex, FuncIndex};
+use wasmtime_environ::{
+ ir, settings, CompiledFunction, CompiledFunctionUnwindInfo, Export, Module,
+};
+use wasmtime_jit::trampoline::ir::{
+ ExternalName, Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind,
+};
+use wasmtime_jit::trampoline::{
+ binemit, pretty_error, Context, FunctionBuilder, FunctionBuilderContext,
+};
+use wasmtime_jit::{native, CodeMemory};
+use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};
+
+struct TrampolineState {
+ func: Rc,
+ #[allow(dead_code)]
+ code_memory: CodeMemory,
+}
+
+impl TrampolineState {
+ fn new(func: Rc, code_memory: CodeMemory) -> Self {
+ TrampolineState { func, code_memory }
+ }
+}
+
+unsafe extern "C" fn stub_fn(
+ vmctx: *mut VMContext,
+ _caller_vmctx: *mut VMContext,
+ call_id: u32,
+ values_vec: *mut i128,
+) {
+ // 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(|| call_stub(vmctx, call_id, 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` through to the
+ // call-site, which gets unwrapped in `Trap::from_jit` later on as we
+ // convert from the internal `Trap` type to our own `Trap` type in this
+ // crate.
+ Ok(Err(trap)) => wasmtime_runtime::raise_user_trap(Box::new(trap)),
+
+ // 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),
+ }
+
+ unsafe fn call_stub(
+ vmctx: *mut VMContext,
+ call_id: u32,
+ values_vec: *mut i128,
+ ) -> Result<(), Trap> {
+ let instance = InstanceHandle::from_vmctx(vmctx);
+
+ let (args, returns_len) = {
+ let module = instance.module_ref();
+ let signature =
+ &module.local.signatures[module.local.functions[FuncIndex::new(call_id as usize)]];
+
+ let mut args = Vec::new();
+ for i in 2..signature.params.len() {
+ args.push(Val::read_value_from(
+ values_vec.offset(i as isize - 2),
+ signature.params[i].value_type,
+ ))
+ }
+ (args, signature.returns.len())
+ };
+
+ let mut returns = vec![Val::null(); returns_len];
+ let state = &instance
+ .host_state()
+ .downcast_ref::()
+ .expect("state");
+ state.func.call(&args, &mut returns)?;
+
+ let module = instance.module_ref();
+ let signature =
+ &module.local.signatures[module.local.functions[FuncIndex::new(call_id as usize)]];
+ for (i, ret) in returns.iter_mut().enumerate() {
+ if ret.ty().get_wasmtime_type() != Some(signature.returns[i].value_type) {
+ return Err(Trap::new(
+ "`Callable` attempted to return an incompatible value",
+ ));
+ }
+ ret.write_value_to(values_vec.add(i));
+ }
+ Ok(())
+ }
+}
+
+/// Create a trampoline for invoking a Callable.
+fn make_trampoline(
+ isa: &dyn TargetIsa,
+ code_memory: &mut CodeMemory,
+ fn_builder_ctx: &mut FunctionBuilderContext,
+ call_id: u32,
+ signature: &ir::Signature,
+) -> *mut [VMFunctionBody] {
+ // Mostly reverse copy of the similar method from wasmtime's
+ // wasmtime-jit/src/compiler.rs.
+ let pointer_type = isa.pointer_type();
+ let mut stub_sig = ir::Signature::new(isa.frontend_config().default_call_conv);
+
+ // Add the caller/callee `vmctx` parameters.
+ stub_sig.params.push(ir::AbiParam::special(
+ pointer_type,
+ ir::ArgumentPurpose::VMContext,
+ ));
+
+ // Add the caller `vmctx` parameter.
+ stub_sig.params.push(ir::AbiParam::new(pointer_type));
+
+ // Add the `call_id` parameter.
+ stub_sig.params.push(ir::AbiParam::new(types::I32));
+
+ // Add the `values_vec` parameter.
+ stub_sig.params.push(ir::AbiParam::new(pointer_type));
+
+ // Compute the size of the values vector. The vmctx and caller vmctx are passed separately.
+ let value_size = 16;
+ let values_vec_len = ((value_size as usize)
+ * cmp::max(signature.params.len() - 2, signature.returns.len()))
+ as u32;
+
+ let mut context = Context::new();
+ context.func = Function::with_name_signature(ExternalName::user(0, 0), signature.clone());
+ context.func.collect_frame_layout_info();
+
+ let ss = context.func.create_stack_slot(StackSlotData::new(
+ StackSlotKind::ExplicitSlot,
+ values_vec_len,
+ ));
+
+ {
+ let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx);
+ let block0 = builder.create_block();
+
+ builder.append_block_params_for_function_params(block0);
+ builder.switch_to_block(block0);
+ builder.seal_block(block0);
+
+ let values_vec_ptr_val = builder.ins().stack_addr(pointer_type, ss, 0);
+ let mflags = MemFlags::trusted();
+ for i in 2..signature.params.len() {
+ if i == 0 {
+ continue;
+ }
+
+ let val = builder.func.dfg.block_params(block0)[i];
+ builder.ins().store(
+ mflags,
+ val,
+ values_vec_ptr_val,
+ ((i - 2) * value_size) as i32,
+ );
+ }
+
+ let block_params = builder.func.dfg.block_params(block0);
+ let vmctx_ptr_val = block_params[0];
+ let caller_vmctx_ptr_val = block_params[1];
+ let call_id_val = builder.ins().iconst(types::I32, call_id as i64);
+
+ let callee_args = vec![
+ vmctx_ptr_val,
+ caller_vmctx_ptr_val,
+ call_id_val,
+ values_vec_ptr_val,
+ ];
+
+ let new_sig = builder.import_signature(stub_sig);
+
+ let callee_value = builder
+ .ins()
+ .iconst(pointer_type, stub_fn as *const VMFunctionBody as i64);
+ builder
+ .ins()
+ .call_indirect(new_sig, callee_value, &callee_args);
+
+ let mflags = MemFlags::trusted();
+ let mut results = Vec::new();
+ for (i, r) in signature.returns.iter().enumerate() {
+ let load = builder.ins().load(
+ r.value_type,
+ mflags,
+ values_vec_ptr_val,
+ (i * value_size) as i32,
+ );
+ results.push(load);
+ }
+ builder.ins().return_(&results);
+ builder.finalize()
+ }
+
+ let mut code_buf: Vec = Vec::new();
+ let mut reloc_sink = binemit::TrampolineRelocSink {};
+ let mut trap_sink = binemit::NullTrapSink {};
+ let mut stackmap_sink = binemit::NullStackmapSink {};
+ context
+ .compile_and_emit(
+ isa,
+ &mut code_buf,
+ &mut reloc_sink,
+ &mut trap_sink,
+ &mut stackmap_sink,
+ )
+ .map_err(|error| pretty_error(&context.func, Some(isa), error))
+ .expect("compile_and_emit");
+
+ let unwind_info = CompiledFunctionUnwindInfo::new(isa, &context);
+
+ code_memory
+ .allocate_for_function(&CompiledFunction {
+ body: code_buf,
+ jt_offsets: context.func.jt_offsets,
+ unwind_info,
+ })
+ .expect("allocate_for_function")
+}
+
+pub fn create_handle_with_function(
+ ft: &FuncType,
+ func: &Rc,
+ store: &Store,
+) -> Result {
+ let isa = {
+ let isa_builder = native::builder();
+ let flag_builder = settings::builder();
+ isa_builder.finish(settings::Flags::new(flag_builder))
+ };
+
+ let pointer_type = isa.pointer_type();
+ let sig = match ft.get_wasmtime_signature(pointer_type) {
+ Some(sig) => sig.clone(),
+ None => bail!("not a supported core wasm signature {:?}", ft),
+ };
+
+ let mut fn_builder_ctx = FunctionBuilderContext::new();
+ let mut module = Module::new();
+ let mut finished_functions: PrimaryMap =
+ PrimaryMap::new();
+ let mut code_memory = CodeMemory::new();
+
+ let sig_id = module.local.signatures.push(sig.clone());
+ let func_id = module.local.functions.push(sig_id);
+ module
+ .exports
+ .insert("trampoline".to_string(), Export::Function(func_id));
+ let trampoline = make_trampoline(
+ isa.as_ref(),
+ &mut code_memory,
+ &mut fn_builder_ctx,
+ func_id.index() as u32,
+ &sig,
+ );
+ code_memory.publish();
+
+ finished_functions.push(trampoline);
+
+ let trampoline_state = TrampolineState::new(func.clone(), code_memory);
+
+ create_handle(
+ module,
+ store,
+ finished_functions,
+ Box::new(trampoline_state),
+ )
+}
+
+pub unsafe fn create_handle_with_raw_function(
+ ft: &FuncType,
+ func: *mut [VMFunctionBody],
+ store: &Store,
+ state: Box,
+) -> Result {
+ let isa = {
+ let isa_builder = native::builder();
+ let flag_builder = settings::builder();
+ isa_builder.finish(settings::Flags::new(flag_builder))
+ };
+
+ let pointer_type = isa.pointer_type();
+ let sig = match ft.get_wasmtime_signature(pointer_type) {
+ Some(sig) => sig.clone(),
+ None => bail!("not a supported core wasm signature {:?}", ft),
+ };
+
+ let mut module = Module::new();
+ let mut finished_functions = PrimaryMap::new();
+
+ let sig_id = module.local.signatures.push(sig.clone());
+ let func_id = module.local.functions.push(sig_id);
+ module
+ .exports
+ .insert("trampoline".to_string(), Export::Function(func_id));
+ finished_functions.push(func);
+
+ create_handle(module, store, finished_functions, state)
+}
diff --git a/crates/api/src/trampoline/global.rs b/crates/api/src/trampoline/global.rs
new file mode 100644
index 0000000000..ad87386a3e
--- /dev/null
+++ b/crates/api/src/trampoline/global.rs
@@ -0,0 +1,35 @@
+use super::create_handle::create_handle;
+use crate::Store;
+use crate::{GlobalType, Mutability, Val};
+use anyhow::{bail, Result};
+use wasmtime_environ::entity::PrimaryMap;
+use wasmtime_environ::{wasm, Module};
+use wasmtime_runtime::InstanceHandle;
+
+pub fn create_global(store: &Store, gt: &GlobalType, val: Val) -> Result {
+ let global = wasm::Global {
+ ty: match gt.content().get_wasmtime_type() {
+ Some(t) => t,
+ None => bail!("cannot support {:?} as a wasm global type", gt.content()),
+ },
+ mutability: match gt.mutability() {
+ Mutability::Const => false,
+ Mutability::Var => true,
+ },
+ initializer: match val {
+ Val::I32(i) => wasm::GlobalInit::I32Const(i),
+ Val::I64(i) => wasm::GlobalInit::I64Const(i),
+ Val::F32(f) => wasm::GlobalInit::F32Const(f),
+ Val::F64(f) => wasm::GlobalInit::F64Const(f),
+ _ => unimplemented!("create_global for {:?}", gt),
+ },
+ };
+ let mut module = Module::new();
+ let global_id = module.local.globals.push(global);
+ module.exports.insert(
+ "global".to_string(),
+ wasmtime_environ::Export::Global(global_id),
+ );
+ let handle = create_handle(module, store, PrimaryMap::new(), Box::new(()))?;
+ Ok(handle)
+}
diff --git a/crates/api/src/trampoline/memory.rs b/crates/api/src/trampoline/memory.rs
new file mode 100644
index 0000000000..5d87dc6dca
--- /dev/null
+++ b/crates/api/src/trampoline/memory.rs
@@ -0,0 +1,27 @@
+use super::create_handle::create_handle;
+use crate::MemoryType;
+use crate::Store;
+use anyhow::Result;
+use wasmtime_environ::entity::PrimaryMap;
+use wasmtime_environ::{wasm, Module};
+use wasmtime_runtime::InstanceHandle;
+
+pub fn create_handle_with_memory(store: &Store, memory: &MemoryType) -> Result {
+ let mut module = Module::new();
+
+ let memory = wasm::Memory {
+ minimum: memory.limits().min(),
+ maximum: memory.limits().max(),
+ shared: false, // TODO
+ };
+ let tunable = Default::default();
+
+ let memory_plan = wasmtime_environ::MemoryPlan::for_memory(memory, &tunable);
+ let memory_id = module.local.memory_plans.push(memory_plan);
+ module.exports.insert(
+ "memory".to_string(),
+ wasmtime_environ::Export::Memory(memory_id),
+ );
+
+ create_handle(module, store, PrimaryMap::new(), Box::new(()))
+}
diff --git a/crates/api/src/trampoline/mod.rs b/crates/api/src/trampoline/mod.rs
new file mode 100644
index 0000000000..287ae66b5e
--- /dev/null
+++ b/crates/api/src/trampoline/mod.rs
@@ -0,0 +1,69 @@
+//! Utility module to create trampolines in/out WebAssembly module.
+
+mod create_handle;
+mod func;
+mod global;
+mod memory;
+mod table;
+
+use self::func::create_handle_with_function;
+use self::global::create_global;
+use self::memory::create_handle_with_memory;
+use self::table::create_handle_with_table;
+use super::{Callable, FuncType, GlobalType, MemoryType, Store, TableType, Val};
+use anyhow::Result;
+use std::any::Any;
+use std::rc::Rc;
+use wasmtime_runtime::VMFunctionBody;
+
+pub fn generate_func_export(
+ ft: &FuncType,
+ func: &Rc,
+ store: &Store,
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
+ let instance = create_handle_with_function(ft, func, store)?;
+ let export = instance.lookup("trampoline").expect("trampoline export");
+ Ok((instance, export))
+}
+
+/// Note that this is `unsafe` since `func` must be a valid function pointer and
+/// have a signature which matches `ft`, otherwise the returned
+/// instance/export/etc may exhibit undefined behavior.
+pub unsafe fn generate_raw_func_export(
+ ft: &FuncType,
+ func: *mut [VMFunctionBody],
+ store: &Store,
+ state: Box,
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
+ let instance = func::create_handle_with_raw_function(ft, func, store, state)?;
+ let export = instance.lookup("trampoline").expect("trampoline export");
+ Ok((instance, export))
+}
+
+pub fn generate_global_export(
+ store: &Store,
+ gt: &GlobalType,
+ val: Val,
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
+ let instance = create_global(store, gt, val)?;
+ let export = instance.lookup("global").expect("global export");
+ Ok((instance, export))
+}
+
+pub fn generate_memory_export(
+ store: &Store,
+ m: &MemoryType,
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
+ let instance = create_handle_with_memory(store, m)?;
+ let export = instance.lookup("memory").expect("memory export");
+ Ok((instance, export))
+}
+
+pub fn generate_table_export(
+ store: &Store,
+ t: &TableType,
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
+ let instance = create_handle_with_table(store, t)?;
+ let export = instance.lookup("table").expect("table export");
+ Ok((instance, export))
+}
diff --git a/crates/api/src/trampoline/table.rs b/crates/api/src/trampoline/table.rs
new file mode 100644
index 0000000000..7f067b6393
--- /dev/null
+++ b/crates/api/src/trampoline/table.rs
@@ -0,0 +1,30 @@
+use super::create_handle::create_handle;
+use crate::Store;
+use crate::{TableType, ValType};
+use anyhow::{bail, Result};
+use wasmtime_environ::entity::PrimaryMap;
+use wasmtime_environ::{wasm, Module};
+use wasmtime_runtime::InstanceHandle;
+
+pub fn create_handle_with_table(store: &Store, table: &TableType) -> Result {
+ let mut module = Module::new();
+
+ let table = wasm::Table {
+ minimum: table.limits().min(),
+ maximum: table.limits().max(),
+ ty: match table.element() {
+ ValType::FuncRef => wasm::TableElementType::Func,
+ _ => bail!("cannot support {:?} as a table element", table.element()),
+ },
+ };
+ let tunable = Default::default();
+
+ let table_plan = wasmtime_environ::TablePlan::for_table(table, &tunable);
+ let table_id = module.local.table_plans.push(table_plan);
+ module.exports.insert(
+ "table".to_string(),
+ wasmtime_environ::Export::Table(table_id),
+ );
+
+ create_handle(module, store, PrimaryMap::new(), Box::new(()))
+}
diff --git a/crates/api/src/trap.rs b/crates/api/src/trap.rs
new file mode 100644
index 0000000000..8b5d6f7b98
--- /dev/null
+++ b/crates/api/src/trap.rs
@@ -0,0 +1,119 @@
+use crate::frame_info::FRAME_INFO;
+use crate::FrameInfo;
+use backtrace::Backtrace;
+use std::fmt;
+use std::sync::Arc;
+
+/// A struct representing an aborted instruction execution, with a message
+/// indicating the cause.
+#[derive(Clone)]
+pub struct Trap {
+ inner: Arc,
+}
+
+struct TrapInner {
+ message: String,
+ wasm_trace: Vec,
+ native_trace: Backtrace,
+}
+
+fn _assert_trap_is_sync_and_send(t: &Trap) -> (&dyn Sync, &dyn Send) {
+ (t, t)
+}
+
+impl Trap {
+ /// Creates a new `Trap` with `message`.
+ /// # Example
+ /// ```
+ /// let trap = wasmtime::Trap::new("unexpected error");
+ /// assert_eq!("unexpected error", trap.message());
+ /// ```
+ pub fn new>(message: I) -> Self {
+ Trap::new_with_trace(message.into(), Backtrace::new_unresolved())
+ }
+
+ pub(crate) fn from_jit(jit: wasmtime_runtime::Trap) -> Self {
+ match jit {
+ wasmtime_runtime::Trap::User(error) => {
+ // Since we're the only one using the wasmtime internals (in
+ // theory) we should only see user errors which were originally
+ // created from our own `Trap` type (see the trampoline module
+ // with functions).
+ //
+ // If this unwrap trips for someone we'll need to tweak the
+ // return type of this function to probably be `anyhow::Error`
+ // or something like that.
+ *error
+ .downcast()
+ .expect("only `Trap` user errors are supported")
+ }
+ wasmtime_runtime::Trap::Wasm { desc, backtrace } => {
+ Trap::new_with_trace(desc.to_string(), backtrace)
+ }
+ }
+ }
+
+ fn new_with_trace(message: String, native_trace: Backtrace) -> Self {
+ let mut wasm_trace = Vec::new();
+ for frame in native_trace.frames() {
+ let pc = frame.ip() as usize;
+ if let Some(info) = FRAME_INFO.lookup(pc) {
+ wasm_trace.push(info);
+ }
+ }
+ Trap {
+ inner: Arc::new(TrapInner {
+ message,
+ wasm_trace,
+ native_trace,
+ }),
+ }
+ }
+
+ /// Returns a reference the `message` stored in `Trap`.
+ pub fn message(&self) -> &str {
+ &self.inner.message
+ }
+
+ /// Returns a list of function frames in WebAssembly code that led to this
+ /// trap happening.
+ pub fn trace(&self) -> &[FrameInfo] {
+ &self.inner.wasm_trace
+ }
+}
+
+impl fmt::Debug for Trap {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Trap")
+ .field("message", &self.inner.message)
+ .field("wasm_trace", &self.inner.wasm_trace)
+ .field("native_trace", &self.inner.native_trace)
+ .finish()
+ }
+}
+
+impl fmt::Display for Trap {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", self.inner.message)?;
+ let trace = self.trace();
+ if trace.is_empty() {
+ return Ok(());
+ }
+ writeln!(f, "\nwasm backtrace:")?;
+ for (i, frame) in self.trace().iter().enumerate() {
+ let name = frame.module_name().unwrap_or("");
+ write!(f, " {}: {}!", i, name)?;
+ match frame.func_name() {
+ Some(name) => match rustc_demangle::try_demangle(name) {
+ Ok(name) => write!(f, "{}", name)?,
+ Err(_) => write!(f, "{}", name)?,
+ },
+ None => write!(f, "", frame.func_index())?,
+ }
+ writeln!(f, "")?;
+ }
+ Ok(())
+ }
+}
+
+impl std::error::Error for Trap {}
diff --git a/crates/api/src/types.rs b/crates/api/src/types.rs
new file mode 100644
index 0000000000..8e344d5d0a
--- /dev/null
+++ b/crates/api/src/types.rs
@@ -0,0 +1,437 @@
+use wasmtime_environ::{ir, wasm};
+
+// Type Representations
+
+// Type attributes
+
+/// Indicator of whether a global is mutable or not
+#[derive(Debug, Clone, Copy, 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,
+}
+
+/// Limits of tables/memories where the units of the limits are defined by the
+/// table/memory types.
+///
+/// A minimum is always available but the maximum may not be present.
+#[derive(Debug, Clone)]
+pub struct Limits {
+ min: u32,
+ max: Option,
+}
+
+impl Limits {
+ /// Creates a new set of limits with the minimum and maximum both specified.
+ pub fn new(min: u32, max: Option) -> Limits {
+ Limits { min, max }
+ }
+
+ /// Creates a new `Limits` with the `min` specified and no maximum specified.
+ pub fn at_least(min: u32) -> Limits {
+ Limits::new(min, None)
+ }
+
+ /// Returns the minimum amount for these limits.
+ pub fn min(&self) -> u32 {
+ self.min
+ }
+
+ /// Returns the maximum amount for these limits, if specified.
+ pub fn max(&self) -> Option {
+ self.max
+ }
+}
+
+// Value Types
+
+/// A list of all possible value types in WebAssembly.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum ValType {
+ /// 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 opaque data in the Wasm instance.
+ AnyRef, /* = 128 */
+ /// A reference to a Wasm function.
+ 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::AnyRef | ValType::FuncRef => true,
+ _ => false,
+ }
+ }
+
+ pub(crate) fn get_wasmtime_type(&self) -> Option {
+ match self {
+ ValType::I32 => Some(ir::types::I32),
+ ValType::I64 => Some(ir::types::I64),
+ ValType::F32 => Some(ir::types::F32),
+ ValType::F64 => Some(ir::types::F64),
+ ValType::V128 => Some(ir::types::I8X16),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn from_wasmtime_type(ty: ir::Type) -> Option {
+ match ty {
+ ir::types::I32 => Some(ValType::I32),
+ ir::types::I64 => Some(ValType::I64),
+ ir::types::F32 => Some(ValType::F32),
+ ir::types::F64 => Some(ValType::F64),
+ ir::types::I8X16 => Some(ValType::V128),
+ _ => 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! 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)
+ }
+}
+
+// Function Types
+fn from_wasmtime_abiparam(param: &ir::AbiParam) -> Option {
+ assert_eq!(param.purpose, ir::ArgumentPurpose::Normal);
+ ValType::from_wasmtime_type(param.value_type)
+}
+
+/// A descriptor for a function in a WebAssembly module.
+///
+/// WebAssembly functions can have 0 or more parameters and results.
+#[derive(Debug, Clone, PartialEq)]
+pub struct FuncType {
+ params: Box<[ValType]>,
+ results: Box<[ValType]>,
+}
+
+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: Box<[ValType]>, results: Box<[ValType]>) -> FuncType {
+ FuncType { params, results }
+ }
+
+ /// Returns the list of parameter types for this function.
+ pub fn params(&self) -> &[ValType] {
+ &self.params
+ }
+
+ /// Returns the list of result types for this function.
+ pub fn results(&self) -> &[ValType] {
+ &self.results
+ }
+
+ /// Returns `Some` if this function signature was compatible with cranelift,
+ /// or `None` if one of the types/results wasn't supported or compatible
+ /// with cranelift.
+ pub(crate) fn get_wasmtime_signature(&self, pointer_type: ir::Type) -> Option {
+ use wasmtime_environ::ir::{types, AbiParam, ArgumentPurpose, Signature};
+ use wasmtime_jit::native;
+ let call_conv = native::call_conv();
+ let mut params = self
+ .params
+ .iter()
+ .map(|p| p.get_wasmtime_type().map(AbiParam::new))
+ .collect::>>()?;
+ let returns = self
+ .results
+ .iter()
+ .map(|p| p.get_wasmtime_type().map(AbiParam::new))
+ .collect::>>()?;
+ params.insert(0, AbiParam::special(types::I64, ArgumentPurpose::VMContext));
+ params.insert(1, AbiParam::new(pointer_type));
+
+ Some(Signature {
+ params,
+ returns,
+ call_conv,
+ })
+ }
+
+ /// Returns `None` if any types in the signature can't be converted to the
+ /// types in this crate, but that should very rarely happen and largely only
+ /// indicate a bug in our cranelift integration.
+ pub(crate) fn from_wasmtime_signature(signature: ir::Signature) -> Option {
+ let params = signature
+ .params
+ .iter()
+ .skip(2) // skip the caller/callee vmctx
+ .map(|p| from_wasmtime_abiparam(p))
+ .collect::>>()?;
+ let results = signature
+ .returns
+ .iter()
+ .map(|p| from_wasmtime_abiparam(p))
+ .collect::>>()?;
+ Some(FuncType {
+ params: params.into_boxed_slice(),
+ results: results.into_boxed_slice(),
+ })
+ }
+}
+
+// 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)]
+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
+ }
+
+ /// 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: &wasm::Global) -> Option {
+ let ty = ValType::from_wasmtime_type(global.ty)?;
+ let mutability = if global.mutability {
+ Mutability::Var
+ } else {
+ Mutability::Const
+ };
+ Some(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 `anyref`. The most common use for tables is a function table through
+/// which `call_indirect` can invoke other functions.
+#[derive(Debug, Clone)]
+pub struct TableType {
+ element: ValType,
+ limits: Limits,
+}
+
+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: ValType, limits: Limits) -> TableType {
+ TableType { element, limits }
+ }
+
+ /// Returns the element value type of this table.
+ pub fn element(&self) -> &ValType {
+ &self.element
+ }
+
+ /// Returns the limits, in units of elements, of this table.
+ pub fn limits(&self) -> &Limits {
+ &self.limits
+ }
+
+ pub(crate) fn from_wasmtime_table(table: &wasm::Table) -> TableType {
+ assert!(if let wasm::TableElementType::Func = table.ty {
+ true
+ } else {
+ false
+ });
+ let ty = ValType::FuncRef;
+ let limits = Limits::new(table.minimum, table.maximum);
+ TableType::new(ty, limits)
+ }
+}
+
+// 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)]
+pub struct MemoryType {
+ limits: Limits,
+}
+
+impl MemoryType {
+ /// Creates a new descriptor for a WebAssembly memory given the specified
+ /// limits of the memory.
+ pub fn new(limits: Limits) -> MemoryType {
+ MemoryType { limits }
+ }
+
+ /// Returns the limits (in pages) that are configured for this memory.
+ pub fn limits(&self) -> &Limits {
+ &self.limits
+ }
+
+ pub(crate) fn from_wasmtime_memory(memory: &wasm::Memory) -> MemoryType {
+ MemoryType::new(Limits::new(memory.minimum, memory.maximum))
+ }
+}
+
+// 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(Debug, Clone)]
+pub struct ImportType {
+ module: String,
+ name: String,
+ ty: ExternType,
+}
+
+impl ImportType {
+ /// Creates a new import descriptor which comes from `module` and `name` and
+ /// is of type `ty`.
+ pub fn new(module: &str, name: &str, ty: ExternType) -> ImportType {
+ ImportType {
+ module: module.to_string(),
+ name: name.to_string(),
+ ty,
+ }
+ }
+
+ /// Returns the module name that this import is expected to come from.
+ pub fn module(&self) -> &str {
+ &self.module
+ }
+
+ /// Returns the field name of the module that this import is expected to
+ /// come from.
+ pub fn name(&self) -> &str {
+ &self.name
+ }
+
+ /// Returns the expected type of this import.
+ pub fn ty(&self) -> &ExternType {
+ &self.ty
+ }
+}
+
+// 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(Debug, Clone)]
+pub struct ExportType {
+ name: String,
+ ty: ExternType,
+}
+
+impl ExportType {
+ /// Creates a new export which is exported with the given `name` and has the
+ /// given `ty`.
+ pub fn new(name: &str, ty: ExternType) -> ExportType {
+ ExportType {
+ name: name.to_string(),
+ ty,
+ }
+ }
+
+ /// Returns the name by which this export is known by.
+ pub fn name(&self) -> &str {
+ &self.name
+ }
+
+ /// Returns the type of this export.
+ pub fn ty(&self) -> &ExternType {
+ &self.ty
+ }
+}
diff --git a/crates/api/src/unix.rs b/crates/api/src/unix.rs
new file mode 100644
index 0000000000..f17eecfe13
--- /dev/null
+++ b/crates/api/src/unix.rs
@@ -0,0 +1,31 @@
+//! Unix-specific extension for the `wasmtime` crate.
+//!
+//! This module is only available on Unix targets, for example Linux and macOS.
+//! It is not available on Windows, for example. 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::Instance;
+
+/// Extensions for the [`Instance`] type only available on Unix.
+pub trait InstanceExt {
+ // 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(&self, handler: H)
+ where
+ H: 'static + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool;
+}
+
+impl InstanceExt for Instance {
+ unsafe fn set_signal_handler(&self, handler: H)
+ where
+ H: 'static + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool,
+ {
+ self.instance_handle.clone().set_signal_handler(handler);
+ }
+}
diff --git a/crates/api/src/values.rs b/crates/api/src/values.rs
new file mode 100644
index 0000000000..de071d312b
--- /dev/null
+++ b/crates/api/src/values.rs
@@ -0,0 +1,224 @@
+use crate::r#ref::AnyRef;
+use crate::{Func, Store, ValType};
+use anyhow::{bail, Result};
+use std::ptr;
+use wasmtime_environ::ir;
+
+/// Possible runtime values that a WebAssembly module can either consume or
+/// produce.
+#[derive(Debug, Clone)]
+pub enum Val {
+ /// 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),
+
+ /// An `anyref` value which can hold opaque data to the wasm instance itself.
+ ///
+ /// Note that this is a nullable value as well.
+ AnyRef(AnyRef),
+
+ /// A first-class reference to a WebAssembly function.
+ FuncRef(Func),
+
+ /// A 128-bit number
+ V128(u128),
+}
+
+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.
+ 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.
+ pub fn $unwrap(&self) -> $ty {
+ self.$get().expect(concat!("expected ", stringify!($ty)))
+ }
+ )*)
+}
+
+impl Val {
+ /// Returns a null `anyref` value.
+ pub fn null() -> Val {
+ Val::AnyRef(AnyRef::null())
+ }
+
+ /// Returns the corresponding [`ValType`] for this `Val`.
+ pub fn ty(&self) -> ValType {
+ match self {
+ Val::I32(_) => ValType::I32,
+ Val::I64(_) => ValType::I64,
+ Val::F32(_) => ValType::F32,
+ Val::F64(_) => ValType::F64,
+ Val::AnyRef(_) => ValType::AnyRef,
+ Val::FuncRef(_) => ValType::FuncRef,
+ Val::V128(_) => ValType::V128,
+ }
+ }
+
+ pub(crate) unsafe fn write_value_to(&self, p: *mut i128) {
+ match self {
+ Val::I32(i) => ptr::write(p as *mut i32, *i),
+ Val::I64(i) => ptr::write(p as *mut i64, *i),
+ Val::F32(u) => ptr::write(p as *mut u32, *u),
+ Val::F64(u) => ptr::write(p as *mut u64, *u),
+ Val::V128(b) => ptr::write(p as *mut u128, *b),
+ _ => unimplemented!("Val::write_value_to"),
+ }
+ }
+
+ pub(crate) unsafe fn read_value_from(p: *const i128, ty: ir::Type) -> Val {
+ match ty {
+ ir::types::I32 => Val::I32(ptr::read(p as *const i32)),
+ ir::types::I64 => Val::I64(ptr::read(p as *const i64)),
+ ir::types::F32 => Val::F32(ptr::read(p as *const u32)),
+ ir::types::F64 => Val::F64(ptr::read(p as *const u64)),
+ ir::types::I8X16 => Val::V128(ptr::read(p as *const u128)),
+ _ => unimplemented!("Val::read_value_from"),
+ }
+ }
+
+ 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(&Func) funcref unwrap_funcref e)
+ (V128(u128) v128 unwrap_v128 *e)
+ }
+
+ /// Attempt to access the underlying value of this `Val`, returning
+ /// `None` if it is not the correct type.
+ ///
+ /// This will return `Some` for both the `AnyRef` and `FuncRef` types.
+ pub fn anyref(&self) -> Option {
+ match self {
+ Val::AnyRef(e) => Some(e.clone()),
+ _ => 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.
+ pub fn unwrap_anyref(&self) -> AnyRef {
+ self.anyref().expect("expected anyref")
+ }
+}
+
+impl From for Val {
+ fn from(val: i32) -> Val {
+ Val::I32(val)
+ }
+}
+
+impl From for Val {
+ fn from(val: i64) -> Val {
+ Val::I64(val)
+ }
+}
+
+impl From for Val {
+ fn from(val: f32) -> Val {
+ Val::F32(val.to_bits())
+ }
+}
+
+impl From for Val {
+ fn from(val: f64) -> Val {
+ Val::F64(val.to_bits())
+ }
+}
+
+impl From for Val {
+ fn from(val: AnyRef) -> Val {
+ Val::AnyRef(val)
+ }
+}
+
+impl From for Val {
+ fn from(val: Func) -> Val {
+ Val::FuncRef(val)
+ }
+}
+
+pub(crate) fn into_checked_anyfunc(
+ val: Val,
+ store: &Store,
+) -> Result {
+ Ok(match val {
+ Val::AnyRef(AnyRef::Null) => wasmtime_runtime::VMCallerCheckedAnyfunc {
+ func_ptr: ptr::null(),
+ type_index: wasmtime_runtime::VMSharedSignatureIndex::default(),
+ vmctx: ptr::null_mut(),
+ },
+ Val::FuncRef(f) => {
+ let (vmctx, func_ptr, signature) = match f.wasmtime_export() {
+ wasmtime_runtime::Export::Function {
+ vmctx,
+ address,
+ signature,
+ } => (*vmctx, *address, signature),
+ _ => panic!("expected function export"),
+ };
+ let type_index = store.compiler().signatures().register(signature);
+ wasmtime_runtime::VMCallerCheckedAnyfunc {
+ func_ptr,
+ type_index,
+ vmctx,
+ }
+ }
+ _ => bail!("val is not funcref"),
+ })
+}
+
+pub(crate) fn from_checked_anyfunc(
+ item: wasmtime_runtime::VMCallerCheckedAnyfunc,
+ store: &Store,
+) -> Val {
+ if item.type_index == wasmtime_runtime::VMSharedSignatureIndex::default() {
+ return Val::AnyRef(AnyRef::Null);
+ }
+ let signature = store
+ .compiler()
+ .signatures()
+ .lookup(item.type_index)
+ .expect("signature");
+ let instance_handle = unsafe { wasmtime_runtime::InstanceHandle::from_vmctx(item.vmctx) };
+ let export = wasmtime_runtime::Export::Function {
+ address: item.func_ptr,
+ signature,
+ vmctx: item.vmctx,
+ };
+ let f = Func::from_wasmtime_function(export, store, instance_handle);
+ Val::FuncRef(f)
+}
diff --git a/crates/api/src/windows.rs b/crates/api/src/windows.rs
new file mode 100644
index 0000000000..962cae7458
--- /dev/null
+++ b/crates/api/src/windows.rs
@@ -0,0 +1,31 @@
+//! 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::Instance;
+
+/// Extensions for the [`Instance`] type only available on Windows.
+pub trait InstanceExt {
+ /// Configures a custom signal handler to execute.
+ ///
+ /// TODO: needs more documentation.
+ unsafe fn set_signal_handler(&self, handler: H)
+ where
+ H: 'static + Fn(winapi::um::winnt::PEXCEPTION_POINTERS) -> bool;
+}
+
+impl InstanceExt for Instance {
+ unsafe fn set_signal_handler(&self, handler: H)
+ where
+ H: 'static + Fn(winapi::um::winnt::PEXCEPTION_POINTERS) -> bool,
+ {
+ self.instance_handle.clone().set_signal_handler(handler);
+ }
+}
diff --git a/crates/api/tests/examples.rs b/crates/api/tests/examples.rs
new file mode 100644
index 0000000000..24de77f3ed
--- /dev/null
+++ b/crates/api/tests/examples.rs
@@ -0,0 +1,38 @@
+use std::env;
+use std::process::{Command, Stdio};
+
+fn run_example(name: &'static str) {
+ let cargo = env::var("CARGO").unwrap_or("cargo".to_string());
+ let pkg_dir = env!("CARGO_MANIFEST_DIR");
+ assert!(
+ Command::new(cargo)
+ .current_dir(pkg_dir)
+ .stdout(Stdio::null())
+ .args(&["run", "-q", "--example", name])
+ .status()
+ .expect("success")
+ .success(),
+ "failed to execute the example '{}'",
+ name,
+ );
+}
+
+#[test]
+fn test_run_hello_example() {
+ run_example("hello");
+}
+
+#[test]
+fn test_run_gcd_example() {
+ run_example("gcd");
+}
+
+#[test]
+fn test_run_memory_example() {
+ run_example("memory");
+}
+
+#[test]
+fn test_run_multi_example() {
+ run_example("multi");
+}
diff --git a/crates/api/tests/externals.rs b/crates/api/tests/externals.rs
new file mode 100644
index 0000000000..749af41e2b
--- /dev/null
+++ b/crates/api/tests/externals.rs
@@ -0,0 +1,54 @@
+use wasmtime::*;
+
+#[test]
+fn bad_globals() {
+ let ty = GlobalType::new(ValType::I32, Mutability::Var);
+ assert!(Global::new(&Store::default(), ty.clone(), Val::I64(0)).is_err());
+ assert!(Global::new(&Store::default(), ty.clone(), Val::F32(0)).is_err());
+ assert!(Global::new(&Store::default(), ty.clone(), Val::F64(0)).is_err());
+
+ let ty = GlobalType::new(ValType::I32, Mutability::Const);
+ let g = Global::new(&Store::default(), ty.clone(), Val::I32(0)).unwrap();
+ assert!(g.set(Val::I32(1)).is_err());
+
+ let ty = GlobalType::new(ValType::I32, Mutability::Var);
+ let g = Global::new(&Store::default(), ty.clone(), Val::I32(0)).unwrap();
+ assert!(g.set(Val::I64(0)).is_err());
+}
+
+#[test]
+fn bad_tables() {
+ // i32 not supported yet
+ let ty = TableType::new(ValType::I32, Limits::new(0, Some(1)));
+ assert!(Table::new(&Store::default(), ty.clone(), Val::I32(0)).is_err());
+
+ // mismatched initializer
+ let ty = TableType::new(ValType::FuncRef, Limits::new(0, Some(1)));
+ assert!(Table::new(&Store::default(), ty.clone(), Val::I32(0)).is_err());
+
+ // get out of bounds
+ let ty = TableType::new(ValType::FuncRef, Limits::new(0, Some(1)));
+ let t = Table::new(&Store::default(), ty.clone(), Val::AnyRef(AnyRef::Null)).unwrap();
+ assert!(t.get(0).is_none());
+ assert!(t.get(u32::max_value()).is_none());
+
+ // set out of bounds or wrong type
+ let ty = TableType::new(ValType::FuncRef, Limits::new(1, Some(1)));
+ let t = Table::new(&Store::default(), ty.clone(), Val::AnyRef(AnyRef::Null)).unwrap();
+ assert!(t.set(0, Val::I32(0)).is_err());
+ assert!(t.set(0, Val::AnyRef(AnyRef::Null)).is_ok());
+ assert!(t.set(1, Val::AnyRef(AnyRef::Null)).is_err());
+
+ // grow beyond max
+ let ty = TableType::new(ValType::FuncRef, Limits::new(1, Some(1)));
+ let t = Table::new(&Store::default(), ty.clone(), Val::AnyRef(AnyRef::Null)).unwrap();
+ assert!(t.grow(0, Val::AnyRef(AnyRef::Null)).is_ok());
+ assert!(t.grow(1, Val::AnyRef(AnyRef::Null)).is_err());
+ assert_eq!(t.size(), 1);
+
+ // grow wrong type
+ let ty = TableType::new(ValType::FuncRef, Limits::new(1, Some(2)));
+ let t = Table::new(&Store::default(), ty.clone(), Val::AnyRef(AnyRef::Null)).unwrap();
+ assert!(t.grow(1, Val::I32(0)).is_err());
+ assert_eq!(t.size(), 1);
+}
diff --git a/crates/api/tests/func.rs b/crates/api/tests/func.rs
new file mode 100644
index 0000000000..dcb1a1d8c9
--- /dev/null
+++ b/crates/api/tests/func.rs
@@ -0,0 +1,291 @@
+use anyhow::Result;
+use std::rc::Rc;
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use wasmtime::{Callable, Func, FuncType, Instance, Module, Store, Trap, Val, ValType};
+
+#[test]
+fn func_constructors() {
+ let store = Store::default();
+ Func::wrap0(&store, || {});
+ Func::wrap1(&store, |_: i32| {});
+ Func::wrap2(&store, |_: i32, _: i64| {});
+ Func::wrap2(&store, |_: f32, _: f64| {});
+ Func::wrap0(&store, || -> i32 { 0 });
+ Func::wrap0(&store, || -> i64 { 0 });
+ Func::wrap0(&store, || -> f32 { 0.0 });
+ Func::wrap0(&store, || -> f64 { 0.0 });
+
+ Func::wrap0(&store, || -> Result<(), Trap> { loop {} });
+ Func::wrap0(&store, || -> Result { loop {} });
+ Func::wrap0(&store, || -> Result { loop {} });
+ Func::wrap0(&store, || -> Result { loop {} });
+ Func::wrap0(&store, || -> Result { loop {} });
+}
+
+#[test]
+fn dtor_runs() {
+ static HITS: AtomicUsize = AtomicUsize::new(0);
+
+ struct A;
+
+ impl Drop for A {
+ fn drop(&mut self) {
+ HITS.fetch_add(1, SeqCst);
+ }
+ }
+
+ let store = Store::default();
+ let a = A;
+ assert_eq!(HITS.load(SeqCst), 0);
+ Func::wrap0(&store, move || {
+ drop(&a);
+ });
+ assert_eq!(HITS.load(SeqCst), 1);
+}
+
+#[test]
+fn dtor_delayed() -> Result<()> {
+ static HITS: AtomicUsize = AtomicUsize::new(0);
+
+ struct A;
+
+ impl Drop for A {
+ fn drop(&mut self) {
+ HITS.fetch_add(1, SeqCst);
+ }
+ }
+
+ let store = Store::default();
+ let a = A;
+ let func = Func::wrap0(&store, move || drop(&a));
+
+ assert_eq!(HITS.load(SeqCst), 0);
+ let wasm = wat::parse_str(r#"(import "" "" (func))"#)?;
+ let module = Module::new(&store, &wasm)?;
+ let instance = Instance::new(&module, &[func.into()])?;
+ assert_eq!(HITS.load(SeqCst), 0);
+ drop(instance);
+ assert_eq!(HITS.load(SeqCst), 1);
+ Ok(())
+}
+
+#[test]
+fn signatures_match() {
+ let store = Store::default();
+
+ let f = Func::wrap0(&store, || {});
+ assert_eq!(f.ty().params(), &[]);
+ assert_eq!(f.ty().results(), &[]);
+
+ let f = Func::wrap0(&store, || -> i32 { loop {} });
+ assert_eq!(f.ty().params(), &[]);
+ assert_eq!(f.ty().results(), &[ValType::I32]);
+
+ let f = Func::wrap0(&store, || -> i64 { loop {} });
+ assert_eq!(f.ty().params(), &[]);
+ assert_eq!(f.ty().results(), &[ValType::I64]);
+
+ let f = Func::wrap0(&store, || -> f32 { loop {} });
+ assert_eq!(f.ty().params(), &[]);
+ assert_eq!(f.ty().results(), &[ValType::F32]);
+
+ let f = Func::wrap0(&store, || -> f64 { loop {} });
+ assert_eq!(f.ty().params(), &[]);
+ assert_eq!(f.ty().results(), &[ValType::F64]);
+
+ let f = Func::wrap5(&store, |_: f32, _: f64, _: i32, _: i64, _: i32| -> f64 {
+ loop {}
+ });
+ assert_eq!(
+ f.ty().params(),
+ &[
+ ValType::F32,
+ ValType::F64,
+ ValType::I32,
+ ValType::I64,
+ ValType::I32
+ ]
+ );
+ assert_eq!(f.ty().results(), &[ValType::F64]);
+}
+
+#[test]
+fn import_works() -> Result<()> {
+ static HITS: AtomicUsize = AtomicUsize::new(0);
+
+ let wasm = wat::parse_str(
+ r#"
+ (import "" "" (func))
+ (import "" "" (func (param i32) (result i32)))
+ (import "" "" (func (param i32) (param i64)))
+ (import "" "" (func (param i32 i64 i32 f32 f64)))
+
+ (func $foo
+ call 0
+ i32.const 0
+ call 1
+ i32.const 1
+ i32.add
+ i64.const 3
+ call 2
+
+ i32.const 100
+ i64.const 200
+ i32.const 300
+ f32.const 400
+ f64.const 500
+ call 3
+ )
+ (start $foo)
+ "#,
+ )?;
+ let store = Store::default();
+ let module = Module::new(&store, &wasm)?;
+ Instance::new(
+ &module,
+ &[
+ Func::wrap0(&store, || {
+ assert_eq!(HITS.fetch_add(1, SeqCst), 0);
+ })
+ .into(),
+ Func::wrap1(&store, |x: i32| -> i32 {
+ assert_eq!(x, 0);
+ assert_eq!(HITS.fetch_add(1, SeqCst), 1);
+ 1
+ })
+ .into(),
+ Func::wrap2(&store, |x: i32, y: i64| {
+ assert_eq!(x, 2);
+ assert_eq!(y, 3);
+ assert_eq!(HITS.fetch_add(1, SeqCst), 2);
+ })
+ .into(),
+ Func::wrap5(&store, |a: i32, b: i64, c: i32, d: f32, e: f64| {
+ assert_eq!(a, 100);
+ assert_eq!(b, 200);
+ assert_eq!(c, 300);
+ assert_eq!(d, 400.0);
+ assert_eq!(e, 500.0);
+ assert_eq!(HITS.fetch_add(1, SeqCst), 3);
+ })
+ .into(),
+ ],
+ )?;
+ Ok(())
+}
+
+#[test]
+fn trap_smoke() {
+ let store = Store::default();
+ let f = Func::wrap0(&store, || -> Result<(), Trap> { Err(Trap::new("test")) });
+ let err = f.call(&[]).unwrap_err();
+ assert_eq!(err.message(), "test");
+}
+
+#[test]
+fn trap_import() -> Result<()> {
+ let wasm = wat::parse_str(
+ r#"
+ (import "" "" (func))
+ (start 0)
+ "#,
+ )?;
+ let store = Store::default();
+ let module = Module::new(&store, &wasm)?;
+ let trap = Instance::new(
+ &module,
+ &[Func::wrap0(&store, || -> Result<(), Trap> { Err(Trap::new("foo")) }).into()],
+ )
+ .err()
+ .unwrap()
+ .downcast::()?;
+ assert_eq!(trap.message(), "foo");
+ Ok(())
+}
+
+#[test]
+fn get_from_wrapper() {
+ let store = Store::default();
+ let f = Func::wrap0(&store, || {});
+ assert!(f.get0::<()>().is_ok());
+ assert!(f.get0::().is_err());
+ assert!(f.get1::<(), ()>().is_ok());
+ assert!(f.get1::().is_err());
+ assert!(f.get1::().is_err());
+ assert!(f.get2::<(), (), ()>().is_ok());
+ assert!(f.get2::().is_err());
+ assert!(f.get2::().is_err());
+
+ let f = Func::wrap0(&store, || -> i32 { loop {} });
+ assert!(f.get0::().is_ok());
+ let f = Func::wrap0(&store, || -> f32 { loop {} });
+ assert!(f.get0::().is_ok());
+ let f = Func::wrap0(&store, || -> f64 { loop {} });
+ assert!(f.get0::().is_ok());
+
+ let f = Func::wrap1(&store, |_: i32| {});
+ assert!(f.get1::().is_ok());
+ assert!(f.get1::().is_err());
+ assert!(f.get1::().is_err());
+ assert!(f.get1::().is_err());
+ let f = Func::wrap1(&store, |_: i64| {});
+ assert!(f.get1::().is_ok());
+ let f = Func::wrap1(&store, |_: f32| {});
+ assert!(f.get1::().is_ok());
+ let f = Func::wrap1(&store, |_: f64| {});
+ assert!(f.get1::().is_ok());
+}
+
+#[test]
+fn get_from_signature() {
+ struct Foo;
+ impl Callable for Foo {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ panic!()
+ }
+ }
+ let store = Store::default();
+ let ty = FuncType::new(Box::new([]), Box::new([]));
+ let f = Func::new(&store, ty, Rc::new(Foo));
+ assert!(f.get0::<()>().is_ok());
+ assert!(f.get0::().is_err());
+ assert!(f.get1::().is_err());
+
+ let ty = FuncType::new(Box::new([ValType::I32]), Box::new([ValType::F64]));
+ let f = Func::new(&store, ty, Rc::new(Foo));
+ assert!(f.get0::<()>().is_err());
+ assert!(f.get0::().is_err());
+ assert!(f.get1::().is_err());
+ assert!(f.get1::().is_ok());
+}
+
+#[test]
+fn get_from_module() -> anyhow::Result<()> {
+ let store = Store::default();
+ let module = Module::new(
+ &store,
+ r#"
+ (module
+ (func (export "f0"))
+ (func (export "f1") (param i32))
+ (func (export "f2") (result i32)
+ i32.const 0)
+ )
+
+ "#,
+ )?;
+ let instance = Instance::new(&module, &[])?;
+ let f0 = instance.get_export("f0").unwrap().func().unwrap();
+ assert!(f0.get0::<()>().is_ok());
+ assert!(f0.get0::().is_err());
+ let f1 = instance.get_export("f1").unwrap().func().unwrap();
+ assert!(f1.get0::<()>().is_err());
+ assert!(f1.get1::().is_ok());
+ assert!(f1.get1::().is_err());
+ let f2 = instance.get_export("f2").unwrap().func().unwrap();
+ assert!(f2.get0::<()>().is_err());
+ assert!(f2.get0::().is_ok());
+ assert!(f2.get1::().is_err());
+ assert!(f2.get1::().is_err());
+ Ok(())
+}
diff --git a/crates/api/tests/globals.rs b/crates/api/tests/globals.rs
new file mode 100644
index 0000000000..8f5406d398
--- /dev/null
+++ b/crates/api/tests/globals.rs
@@ -0,0 +1,93 @@
+use wasmtime::*;
+
+#[test]
+fn smoke() -> anyhow::Result<()> {
+ let store = Store::default();
+ let g = Global::new(
+ &store,
+ GlobalType::new(ValType::I32, Mutability::Const),
+ 0.into(),
+ )?;
+ assert_eq!(g.get().i32(), Some(0));
+ assert!(g.set(0.into()).is_err());
+
+ let g = Global::new(
+ &store,
+ GlobalType::new(ValType::I32, Mutability::Const),
+ 1i32.into(),
+ )?;
+ assert_eq!(g.get().i32(), Some(1));
+
+ let g = Global::new(
+ &store,
+ GlobalType::new(ValType::I64, Mutability::Const),
+ 2i64.into(),
+ )?;
+ assert_eq!(g.get().i64(), Some(2));
+
+ let g = Global::new(
+ &store,
+ GlobalType::new(ValType::F32, Mutability::Const),
+ 3.0f32.into(),
+ )?;
+ assert_eq!(g.get().f32(), Some(3.0));
+
+ let g = Global::new(
+ &store,
+ GlobalType::new(ValType::F64, Mutability::Const),
+ 4.0f64.into(),
+ )?;
+ assert_eq!(g.get().f64(), Some(4.0));
+ Ok(())
+}
+
+#[test]
+fn mutability() -> anyhow::Result<()> {
+ let store = Store::default();
+ let g = Global::new(
+ &store,
+ GlobalType::new(ValType::I32, Mutability::Var),
+ 0.into(),
+ )?;
+ assert_eq!(g.get().i32(), Some(0));
+ g.set(1.into())?;
+ assert_eq!(g.get().i32(), Some(1));
+ Ok(())
+}
+
+// Make sure that a global is still usable after its original instance is
+// dropped. This is a bit of a weird test and really only fails depending on the
+// implementation, but for now should hopefully be resilient enough to catch at
+// least some cases of heap corruption.
+#[test]
+fn use_after_drop() -> anyhow::Result<()> {
+ let store = Store::default();
+ let module = Module::new(
+ &store,
+ r#"
+ (module
+ (global (export "foo") (mut i32) (i32.const 100)))
+ "#,
+ )?;
+ let instance = Instance::new(&module, &[])?;
+ let g = instance.exports()[0].global().unwrap().clone();
+ assert_eq!(g.get().i32(), Some(100));
+ g.set(101.into())?;
+ drop(instance);
+ assert_eq!(g.get().i32(), Some(101));
+ Instance::new(&module, &[])?;
+ assert_eq!(g.get().i32(), Some(101));
+ drop(module);
+ assert_eq!(g.get().i32(), Some(101));
+ drop(store);
+ assert_eq!(g.get().i32(), Some(101));
+
+ // spray some heap values
+ let mut x = Vec::new();
+ for _ in 0..100 {
+ x.push("xy".to_string());
+ }
+ drop(x);
+ assert_eq!(g.get().i32(), Some(101));
+ Ok(())
+}
diff --git a/crates/api/tests/host-segfault.rs b/crates/api/tests/host-segfault.rs
new file mode 100644
index 0000000000..127a6d7943
--- /dev/null
+++ b/crates/api/tests/host-segfault.rs
@@ -0,0 +1,100 @@
+// To handle out-of-bounds reads and writes we use segfaults right now. We only
+// want to catch a subset of segfaults, however, rather than all segfaults
+// happening everywhere. The purpose of this test is to ensure that we *don't*
+// catch segfaults if it happens in a random place in the code, but we instead
+// bail out of our segfault handler early.
+//
+// This is sort of hard to test for but the general idea here is that we confirm
+// that execution made it to our `segfault` function by printing something, and
+// then we also make sure that stderr is empty to confirm that no weird panics
+// happened or anything like that.
+
+use std::env;
+use std::process::{Command, ExitStatus};
+use wasmtime::*;
+
+const VAR_NAME: &str = "__TEST_TO_RUN";
+const CONFIRM: &str = "well at least we ran up to the segfault\n";
+
+fn segfault() -> ! {
+ unsafe {
+ print!("{}", CONFIRM);
+ *(0x4 as *mut i32) = 3;
+ unreachable!()
+ }
+}
+
+fn main() {
+ let tests: &[(&str, fn())] = &[
+ ("normal segfault", || segfault()),
+ ("make instance then segfault", || {
+ let store = Store::default();
+ let module = Module::new(&store, "(module)").unwrap();
+ let _instance = Instance::new(&module, &[]).unwrap();
+ segfault();
+ }),
+ ];
+ match env::var(VAR_NAME) {
+ Ok(s) => {
+ let test = tests
+ .iter()
+ .find(|p| p.0 == s)
+ .expect("failed to find test")
+ .1;
+ test();
+ }
+ Err(_) => {
+ for (name, _test) in tests {
+ runtest(name);
+ }
+ }
+ }
+}
+
+fn runtest(name: &str) {
+ let me = env::current_exe().unwrap();
+ let mut cmd = Command::new(me);
+ cmd.env(VAR_NAME, name);
+ let output = cmd.output().expect("failed to spawn subprocess");
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ let stderr = String::from_utf8_lossy(&output.stderr);
+ let mut desc = format!("got status: {}", output.status);
+ if !stdout.trim().is_empty() {
+ desc.push_str("\nstdout: ----\n");
+ desc.push_str(" ");
+ desc.push_str(&stdout.replace("\n", "\n "));
+ }
+ if !stderr.trim().is_empty() {
+ desc.push_str("\nstderr: ----\n");
+ desc.push_str(" ");
+ desc.push_str(&stderr.replace("\n", "\n "));
+ }
+ if is_segfault(&output.status) {
+ assert!(
+ stdout.ends_with(CONFIRM) && stderr.is_empty(),
+ "failed to find confirmation in test `{}`\n{}",
+ name,
+ desc
+ );
+ } else {
+ panic!("\n\nexpected a segfault on `{}`\n{}\n\n", name, desc);
+ }
+}
+
+#[cfg(unix)]
+fn is_segfault(status: &ExitStatus) -> bool {
+ use std::os::unix::prelude::*;
+
+ match status.signal() {
+ Some(libc::SIGSEGV) | Some(libc::SIGBUS) => true,
+ _ => false,
+ }
+}
+
+#[cfg(windows)]
+fn is_segfault(status: &ExitStatus) -> bool {
+ match status.code().map(|s| s as u32) {
+ Some(0xc0000005) => true,
+ _ => false,
+ }
+}
diff --git a/crates/api/tests/import-indexes.rs b/crates/api/tests/import-indexes.rs
new file mode 100644
index 0000000000..e1e0d41238
--- /dev/null
+++ b/crates/api/tests/import-indexes.rs
@@ -0,0 +1,67 @@
+use std::rc::Rc;
+use wasmtime::*;
+
+#[test]
+fn same_import_names_still_distinct() -> anyhow::Result<()> {
+ const WAT: &str = r#"
+(module
+ (import "" "" (func $a (result i32)))
+ (import "" "" (func $b (result f32)))
+ (func (export "foo") (result i32)
+ call $a
+ call $b
+ i32.trunc_f32_u
+ i32.add)
+)
+ "#;
+
+ struct Ret1;
+
+ impl Callable for Ret1 {
+ fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap> {
+ assert!(params.is_empty());
+ assert_eq!(results.len(), 1);
+ results[0] = 1i32.into();
+ Ok(())
+ }
+ }
+
+ struct Ret2;
+
+ impl Callable for Ret2 {
+ fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap> {
+ assert!(params.is_empty());
+ assert_eq!(results.len(), 1);
+ results[0] = 2.0f32.into();
+ Ok(())
+ }
+ }
+
+ let store = Store::default();
+ let module = Module::new(&store, WAT)?;
+
+ let imports = [
+ Func::new(
+ &store,
+ FuncType::new(Box::new([]), Box::new([ValType::I32])),
+ Rc::new(Ret1),
+ )
+ .into(),
+ Func::new(
+ &store,
+ FuncType::new(Box::new([]), Box::new([ValType::F32])),
+ Rc::new(Ret2),
+ )
+ .into(),
+ ];
+ let instance = Instance::new(&module, &imports)?;
+
+ let func = instance.get_export("foo").unwrap().func().unwrap();
+ let results = func.call(&[])?;
+ assert_eq!(results.len(), 1);
+ match results[0] {
+ Val::I32(n) => assert_eq!(n, 3),
+ _ => panic!("unexpected type of return"),
+ }
+ Ok(())
+}
diff --git a/crates/api/tests/import_calling_export.rs b/crates/api/tests/import_calling_export.rs
new file mode 100644
index 0000000000..c755e9bb58
--- /dev/null
+++ b/crates/api/tests/import_calling_export.rs
@@ -0,0 +1,116 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use wasmtime::*;
+
+#[test]
+fn test_import_calling_export() {
+ const WAT: &str = r#"
+ (module
+ (type $t0 (func))
+ (import "" "imp" (func $.imp (type $t0)))
+ (func $run call $.imp)
+ (func $other)
+ (export "run" (func $run))
+ (export "other" (func $other))
+ )
+ "#;
+
+ struct Callback {
+ pub other: RefCell>,
+ }
+
+ impl Callable for Callback {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ self.other
+ .borrow()
+ .as_ref()
+ .expect("expected a function ref")
+ .call(&[])
+ .expect("expected function not to trap");
+ Ok(())
+ }
+ }
+
+ let store = Store::default();
+ let module = Module::new(&store, WAT).expect("failed to create module");
+
+ let callback = Rc::new(Callback {
+ other: RefCell::new(None),
+ });
+
+ let callback_func = Func::new(
+ &store,
+ FuncType::new(Box::new([]), Box::new([])),
+ callback.clone(),
+ );
+
+ let imports = vec![callback_func.into()];
+ let instance =
+ Instance::new(&module, imports.as_slice()).expect("failed to instantiate module");
+
+ let exports = instance.exports();
+ assert!(!exports.is_empty());
+
+ let run_func = exports[0]
+ .func()
+ .expect("expected a run func in the module");
+
+ *callback.other.borrow_mut() = Some(
+ exports[1]
+ .func()
+ .expect("expected an other func in the module")
+ .clone(),
+ );
+
+ run_func.call(&[]).expect("expected function not to trap");
+}
+
+#[test]
+fn test_returns_incorrect_type() {
+ const WAT: &str = r#"
+ (module
+ (import "env" "evil" (func $evil (result i32)))
+ (func (export "run") (result i32)
+ (call $evil)
+ )
+ )
+ "#;
+
+ struct EvilCallback;
+
+ impl Callable for EvilCallback {
+ fn call(&self, _params: &[Val], results: &mut [Val]) -> Result<(), Trap> {
+ // Evil! Returns I64 here instead of promised in the signature I32.
+ results[0] = Val::I64(228);
+ Ok(())
+ }
+ }
+
+ let store = Store::default();
+ let module = Module::new(&store, WAT).expect("failed to create module");
+
+ let callback = Rc::new(EvilCallback);
+
+ let callback_func = Func::new(
+ &store,
+ FuncType::new(Box::new([]), Box::new([ValType::I32])),
+ callback.clone(),
+ );
+
+ let imports = vec![callback_func.into()];
+ let instance =
+ Instance::new(&module, imports.as_slice()).expect("failed to instantiate module");
+
+ let exports = instance.exports();
+ assert!(!exports.is_empty());
+
+ let run_func = exports[0]
+ .func()
+ .expect("expected a run func in the module");
+
+ let trap = run_func.call(&[]).expect_err("the execution should fail");
+ assert_eq!(
+ trap.message(),
+ "`Callable` attempted to return an incompatible value"
+ );
+}
diff --git a/crates/api/tests/invoke_func_via_table.rs b/crates/api/tests/invoke_func_via_table.rs
new file mode 100644
index 0000000000..28ba779ec9
--- /dev/null
+++ b/crates/api/tests/invoke_func_via_table.rs
@@ -0,0 +1,32 @@
+use anyhow::{Context as _, Result};
+use wasmtime::*;
+
+#[test]
+fn test_invoke_func_via_table() -> Result<()> {
+ let store = Store::default();
+
+ let wat = r#"
+ (module
+ (func $f (result i64) (i64.const 42))
+
+ (table (export "table") 1 1 anyfunc)
+ (elem (i32.const 0) $f)
+ )
+ "#;
+ let module = Module::new(&store, wat).context("> Error compiling module!")?;
+ let instance = Instance::new(&module, &[]).context("> Error instantiating module!")?;
+
+ let f = instance
+ .get_export("table")
+ .unwrap()
+ .table()
+ .unwrap()
+ .get(0)
+ .unwrap()
+ .funcref()
+ .unwrap()
+ .clone();
+ let result = f.call(&[]).unwrap();
+ assert_eq!(result[0].unwrap_i64(), 42);
+ Ok(())
+}
diff --git a/crates/api/tests/name.rs b/crates/api/tests/name.rs
new file mode 100644
index 0000000000..d6cea5a50c
--- /dev/null
+++ b/crates/api/tests/name.rs
@@ -0,0 +1,34 @@
+use wasmtime::*;
+
+#[test]
+fn test_module_no_name() -> anyhow::Result<()> {
+ let store = Store::default();
+ let wat = r#"
+ (module
+ (func (export "run") (nop))
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ assert_eq!(module.name(), None);
+
+ Ok(())
+}
+
+#[test]
+fn test_module_name() -> anyhow::Result<()> {
+ let store = Store::default();
+ let wat = r#"
+ (module $from_name_section
+ (func (export "run") (nop))
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ assert_eq!(module.name(), Some("from_name_section"));
+
+ let module = Module::new_with_name(&store, wat, "override")?;
+ assert_eq!(module.name(), Some("override"));
+
+ Ok(())
+}
diff --git a/crates/api/tests/traps.rs b/crates/api/tests/traps.rs
new file mode 100644
index 0000000000..5ef3bf2644
--- /dev/null
+++ b/crates/api/tests/traps.rs
@@ -0,0 +1,404 @@
+use anyhow::Result;
+use std::panic::{self, AssertUnwindSafe};
+use std::rc::Rc;
+use wasmtime::*;
+
+#[test]
+fn test_trap_return() -> Result<()> {
+ struct HelloCallback;
+
+ impl Callable for HelloCallback {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ Err(Trap::new("test 123"))
+ }
+ }
+
+ let store = Store::default();
+ let wat = r#"
+ (module
+ (func $hello (import "" "hello"))
+ (func (export "run") (call $hello))
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ let hello_type = FuncType::new(Box::new([]), Box::new([]));
+ let hello_func = Func::new(&store, hello_type, Rc::new(HelloCallback));
+
+ let instance = Instance::new(&module, &[hello_func.into()])?;
+ let run_func = instance.exports()[0]
+ .func()
+ .expect("expected function export");
+
+ let e = run_func.call(&[]).err().expect("error calling function");
+
+ assert_eq!(e.message(), "test 123");
+
+ Ok(())
+}
+
+#[test]
+fn test_trap_trace() -> Result<()> {
+ let store = Store::default();
+ let wat = r#"
+ (module $hello_mod
+ (func (export "run") (call $hello))
+ (func $hello (unreachable))
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ let instance = Instance::new(&module, &[])?;
+ let run_func = instance.exports()[0]
+ .func()
+ .expect("expected function export");
+
+ let e = run_func.call(&[]).err().expect("error calling function");
+
+ let trace = e.trace();
+ assert_eq!(trace.len(), 2);
+ assert_eq!(trace[0].module_name().unwrap(), "hello_mod");
+ assert_eq!(trace[0].func_index(), 1);
+ assert_eq!(trace[0].func_name(), Some("hello"));
+ assert_eq!(trace[1].module_name().unwrap(), "hello_mod");
+ assert_eq!(trace[1].func_index(), 0);
+ assert_eq!(trace[1].func_name(), None);
+ assert!(
+ e.message().contains("unreachable"),
+ "wrong message: {}",
+ e.message()
+ );
+
+ Ok(())
+}
+
+#[test]
+fn test_trap_trace_cb() -> Result<()> {
+ struct ThrowCallback;
+
+ impl Callable for ThrowCallback {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ Err(Trap::new("cb throw"))
+ }
+ }
+
+ let store = Store::default();
+ let wat = r#"
+ (module $hello_mod
+ (import "" "throw" (func $throw))
+ (func (export "run") (call $hello))
+ (func $hello (call $throw))
+ )
+ "#;
+
+ let fn_type = FuncType::new(Box::new([]), Box::new([]));
+ let fn_func = Func::new(&store, fn_type, Rc::new(ThrowCallback));
+
+ let module = Module::new(&store, wat)?;
+ let instance = Instance::new(&module, &[fn_func.into()])?;
+ let run_func = instance.exports()[0]
+ .func()
+ .expect("expected function export");
+
+ let e = run_func.call(&[]).err().expect("error calling function");
+
+ let trace = e.trace();
+ assert_eq!(trace.len(), 2);
+ assert_eq!(trace[0].module_name().unwrap(), "hello_mod");
+ assert_eq!(trace[0].func_index(), 2);
+ assert_eq!(trace[1].module_name().unwrap(), "hello_mod");
+ assert_eq!(trace[1].func_index(), 1);
+ assert_eq!(e.message(), "cb throw");
+
+ Ok(())
+}
+
+#[test]
+fn test_trap_stack_overflow() -> Result<()> {
+ let store = Store::default();
+ let wat = r#"
+ (module $rec_mod
+ (func $run (export "run") (call $run))
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ let instance = Instance::new(&module, &[])?;
+ let run_func = instance.exports()[0]
+ .func()
+ .expect("expected function export");
+
+ let e = run_func.call(&[]).err().expect("error calling function");
+
+ let trace = e.trace();
+ assert!(trace.len() >= 32);
+ for i in 0..trace.len() {
+ assert_eq!(trace[i].module_name().unwrap(), "rec_mod");
+ assert_eq!(trace[i].func_index(), 0);
+ assert_eq!(trace[i].func_name(), Some("run"));
+ }
+ assert!(e.message().contains("call stack exhausted"));
+
+ Ok(())
+}
+
+#[test]
+fn trap_display_pretty() -> Result<()> {
+ let store = Store::default();
+ let wat = r#"
+ (module $m
+ (func $die unreachable)
+ (func call $die)
+ (func $foo call 1)
+ (func (export "bar") call $foo)
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ let instance = Instance::new(&module, &[])?;
+ let run_func = instance.exports()[0]
+ .func()
+ .expect("expected function export");
+
+ let e = run_func.call(&[]).err().expect("error calling function");
+ assert_eq!(
+ e.to_string(),
+ "\
+wasm trap: unreachable, source location: @0023
+wasm backtrace:
+ 0: m!die
+ 1: m!
+ 2: m!foo
+ 3: m!
+"
+ );
+ Ok(())
+}
+
+#[test]
+fn trap_display_multi_module() -> Result<()> {
+ let store = Store::default();
+ let wat = r#"
+ (module $a
+ (func $die unreachable)
+ (func call $die)
+ (func $foo call 1)
+ (func (export "bar") call $foo)
+ )
+ "#;
+
+ let module = Module::new(&store, wat)?;
+ let instance = Instance::new(&module, &[])?;
+ let bar = instance.exports()[0].clone();
+
+ let wat = r#"
+ (module $b
+ (import "" "" (func $bar))
+ (func $middle call $bar)
+ (func (export "bar2") call $middle)
+ )
+ "#;
+ let module = Module::new(&store, wat)?;
+ let instance = Instance::new(&module, &[bar])?;
+ let bar2 = instance.exports()[0]
+ .func()
+ .expect("expected function export");
+
+ let e = bar2.call(&[]).err().expect("error calling function");
+ assert_eq!(
+ e.to_string(),
+ "\
+wasm trap: unreachable, source location: @0023
+wasm backtrace:
+ 0: a!die
+ 1: a!
+ 2: a!foo
+ 3: a!
+ 4: b!middle
+ 5: b!
+"
+ );
+ Ok(())
+}
+
+#[test]
+fn trap_start_function_import() -> Result<()> {
+ struct ReturnTrap;
+
+ impl Callable for ReturnTrap {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ Err(Trap::new("user trap"))
+ }
+ }
+
+ let store = Store::default();
+ let binary = wat::parse_str(
+ r#"
+ (module $a
+ (import "" "" (func $foo))
+ (start $foo)
+ )
+ "#,
+ )?;
+
+ let module = Module::new(&store, &binary)?;
+ let sig = FuncType::new(Box::new([]), Box::new([]));
+ let func = Func::new(&store, sig, Rc::new(ReturnTrap));
+ let err = Instance::new(&module, &[func.into()]).err().unwrap();
+ assert_eq!(err.downcast_ref::().unwrap().message(), "user trap");
+ Ok(())
+}
+
+#[test]
+fn rust_panic_import() -> Result<()> {
+ struct Panic;
+
+ impl Callable for Panic {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ panic!("this is a panic");
+ }
+ }
+
+ let store = Store::default();
+ let binary = wat::parse_str(
+ r#"
+ (module $a
+ (import "" "" (func $foo))
+ (import "" "" (func $bar))
+ (func (export "foo") call $foo)
+ (func (export "bar") call $bar)
+ )
+ "#,
+ )?;
+
+ let module = Module::new(&store, &binary)?;
+ let sig = FuncType::new(Box::new([]), Box::new([]));
+ let func = Func::new(&store, sig, Rc::new(Panic));
+ let instance = Instance::new(
+ &module,
+ &[
+ func.into(),
+ Func::wrap0(&store, || panic!("this is another panic")).into(),
+ ],
+ )?;
+ let func = instance.exports()[0].func().unwrap().clone();
+ let err = panic::catch_unwind(AssertUnwindSafe(|| {
+ drop(func.call(&[]));
+ }))
+ .unwrap_err();
+ assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
+
+ let func = instance.exports()[1].func().unwrap().clone();
+ let err = panic::catch_unwind(AssertUnwindSafe(|| {
+ drop(func.call(&[]));
+ }))
+ .unwrap_err();
+ assert_eq!(
+ err.downcast_ref::<&'static str>(),
+ Some(&"this is another panic")
+ );
+ Ok(())
+}
+
+#[test]
+fn rust_panic_start_function() -> Result<()> {
+ struct Panic;
+
+ impl Callable for Panic {
+ fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+ panic!("this is a panic");
+ }
+ }
+
+ let store = Store::default();
+ let binary = wat::parse_str(
+ r#"
+ (module $a
+ (import "" "" (func $foo))
+ (start $foo)
+ )
+ "#,
+ )?;
+
+ let module = Module::new(&store, &binary)?;
+ let sig = FuncType::new(Box::new([]), Box::new([]));
+ let func = Func::new(&store, sig, Rc::new(Panic));
+ let err = panic::catch_unwind(AssertUnwindSafe(|| {
+ drop(Instance::new(&module, &[func.into()]));
+ }))
+ .unwrap_err();
+ assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
+
+ let func = Func::wrap0(&store, || panic!("this is another panic"));
+ let err = panic::catch_unwind(AssertUnwindSafe(|| {
+ drop(Instance::new(&module, &[func.into()]));
+ }))
+ .unwrap_err();
+ assert_eq!(
+ err.downcast_ref::<&'static str>(),
+ Some(&"this is another panic")
+ );
+ Ok(())
+}
+
+#[test]
+fn mismatched_arguments() -> Result<()> {
+ let store = Store::default();
+ let binary = wat::parse_str(
+ r#"
+ (module $a
+ (func (export "foo") (param i32))
+ )
+ "#,
+ )?;
+
+ let module = Module::new(&store, &binary)?;
+ let instance = Instance::new(&module, &[])?;
+ let func = instance.exports()[0].func().unwrap().clone();
+ assert_eq!(
+ func.call(&[]).unwrap_err().message(),
+ "expected 1 arguments, got 0"
+ );
+ assert_eq!(
+ func.call(&[Val::F32(0)]).unwrap_err().message(),
+ "argument type mismatch",
+ );
+ assert_eq!(
+ func.call(&[Val::I32(0), Val::I32(1)])
+ .unwrap_err()
+ .message(),
+ "expected 1 arguments, got 2"
+ );
+ Ok(())
+}
+
+#[test]
+fn call_signature_mismatch() -> Result<()> {
+ let store = Store::default();
+ let binary = wat::parse_str(
+ r#"
+ (module $a
+ (func $foo
+ i32.const 0
+ call_indirect)
+ (func $bar (param i32))
+ (start $foo)
+
+ (table 1 anyfunc)
+ (elem (i32.const 0) 1)
+ )
+ "#,
+ )?;
+
+ let module = Module::new(&store, &binary)?;
+ let err = Instance::new(&module, &[])
+ .err()
+ .unwrap()
+ .downcast::()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "wasm trap: indirect call type mismatch, source location: @0030"
+ );
+ Ok(())
+}
diff --git a/crates/c-api/Cargo.toml b/crates/c-api/Cargo.toml
new file mode 100644
index 0000000000..3b17fcce03
--- /dev/null
+++ b/crates/c-api/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "wasmtime-c-api"
+version = "0.12.0"
+authors = ["The Wasmtime Project Developers"]
+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 = "2018"
+publish = false
+
+[lib]
+name = "wasmtime"
+crate-type = ["staticlib", "cdylib"]
+doc = false
+test = false
+doctest = false
+
+[dependencies]
+wasmtime = { path = "../api" }
+wasi-common = { path = "../wasi-common" }
+wasmtime-wasi = { path = "../wasi" }
diff --git a/crates/c-api/LICENSE b/crates/c-api/LICENSE
new file mode 100644
index 0000000000..f9d81955f4
--- /dev/null
+++ b/crates/c-api/LICENSE
@@ -0,0 +1,220 @@
+
+ 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/c-api/README.md b/crates/c-api/README.md
new file mode 100644
index 0000000000..b0edded9c2
--- /dev/null
+++ b/crates/c-api/README.md
@@ -0,0 +1,3 @@
+# Implementation of wasm-c-api in Rust
+
+https://github.com/WebAssembly/wasm-c-api
diff --git a/crates/c-api/examples/Makefile b/crates/c-api/examples/Makefile
new file mode 100644
index 0000000000..b309e80484
--- /dev/null
+++ b/crates/c-api/examples/Makefile
@@ -0,0 +1,171 @@
+###############################################################################
+# Configuration
+
+# Inherited from wasm-c-api/Makefile to just run C examples
+
+WASM_FLAGS = -DWASM_API_DEBUG # -DWASM_API_DEBUG_LOG
+C_FLAGS = ${WASM_FLAGS} -Wall -Werror -ggdb -O -fsanitize=address
+CC_FLAGS = -std=c++11 ${C_FLAGS}
+LD_FLAGS = -fsanitize-memory-track-origins -fsanitize-memory-use-after-dtor
+
+C_COMP = clang
+
+WASMTIME_API_MODE = debug
+
+
+# Base directories
+WASMTIME_API_DIR = ..
+WASM_DIR = wasm-c-api
+EXAMPLE_DIR = ${WASM_DIR}/example
+OUT_DIR = ${WASM_DIR}/out
+
+# Example config
+EXAMPLE_OUT = ${OUT_DIR}/example
+EXAMPLES = \
+ hello \
+ callback \
+ trap \
+ start \
+ reflect \
+ global \
+ table \
+ memory \
+ hostref \
+ finalize \
+ serialize \
+ threads \
+ # multi \
+
+# Wasm config
+WASM_INCLUDE = ${WASM_DIR}/include
+WASM_SRC = ${WASM_DIR}/src
+WASM_OUT = ${OUT_DIR}
+WASM_C_LIBS = wasm-bin wasm-rust-api
+WASM_CC_LIBS = $(error unsupported C++)
+
+
+# Compiler config
+ifeq (${WASMTIME_API_MODE},release)
+ CARGO_BUILD_FLAGS = --release
+else
+ CARGO_BUILD_FLAGS =
+endif
+
+ifeq (${C_COMP},clang)
+ CC_COMP = clang++
+ LD_GROUP_START =
+ LD_GROUP_END =
+else ifeq (${C_COMP},gcc)
+ CC_COMP = g++
+ LD_GROUP_START = -Wl,--start-group
+ LD_GROUP_END = -Wl,--end-group
+else
+ $(error C_COMP set to unknown compiler, must be clang or gcc)
+endif
+
+WASMTIME_BIN_DIR = ${WASMTIME_API_DIR}/../../target/${WASMTIME_API_MODE}
+WASMTIME_C_LIB_DIR = ${WASMTIME_BIN_DIR}
+WASMTIME_C_LIBS = wasmtime
+WASMTIME_CC_LIBS = $(error unsupported c++)
+
+WASMTIME_C_BINS = ${WASMTIME_C_LIBS:%=${WASMTIME_C_LIB_DIR}/lib%.a}
+
+###############################################################################
+# Examples
+#
+# To build Wasm APIs and run all examples:
+# make all
+#
+# To run only C examples:
+# make c
+#
+# To run only C++ examples:
+# make cc
+#
+# To run individual C example (e.g. hello):
+# make run-hello-c
+#
+# To run individual C++ example (e.g. hello):
+# make run-hello-cc
+#
+
+.PHONY: all cc c
+all: cc c
+cc: ${EXAMPLES:%=run-%-cc}
+c: ${EXAMPLES:%=run-%-c}
+
+# Running a C / C++ example
+run-%-c: ${EXAMPLE_OUT}/%-c ${EXAMPLE_OUT}/%.wasm
+ @echo ==== C ${@:run-%-c=%} ====; \
+ cd ${EXAMPLE_OUT}; ./${@:run-%=%}
+ @echo ==== Done ====
+
+run-%-cc: ${EXAMPLE_OUT}/%-cc ${EXAMPLE_OUT}/%.wasm
+ @echo ==== C++ ${@:run-%-cc=%} ====; \
+ cd ${EXAMPLE_OUT}; ./${@:run-%=%}
+ @echo ==== Done ====
+
+# Compiling C / C++ example
+${EXAMPLE_OUT}/%-c.o: ${EXAMPLE_DIR}/%.c ${WASM_INCLUDE}/wasm.h
+ mkdir -p ${EXAMPLE_OUT}
+ ${C_COMP} -c ${C_FLAGS} -I. -I${WASM_INCLUDE} $< -o $@
+
+${EXAMPLE_OUT}/%-cc.o: ${EXAMPLE_DIR}/%.cc ${WASM_INCLUDE}/wasm.hh
+ mkdir -p ${EXAMPLE_OUT}
+ ${CC_COMP} -c ${CC_FLAGS} -I. -I${WASM_INCLUDE} $< -o $@
+
+# Linking C / C++ example
+.PRECIOUS: ${EXAMPLES:%=${EXAMPLE_OUT}/%-c}
+${EXAMPLE_OUT}/%-c: ${EXAMPLE_OUT}/%-c.o ${WASMTIME_C_BINS}
+ ${CC_COMP} ${CC_FLAGS} ${LD_FLAGS} $< -o $@ \
+ ${LD_GROUP_START} \
+ ${WASMTIME_C_BINS} \
+ ${LD_GROUP_END} \
+ -ldl -pthread
+
+# Installing Wasm binaries
+.PRECIOUS: ${EXAMPLES:%=${EXAMPLE_OUT}/%.wasm}
+${EXAMPLE_OUT}/%.wasm: ${EXAMPLE_DIR}/%.wasm
+ cp $< $@
+
+###############################################################################
+# Wasm C / C++ API
+#
+# To build both C / C++ APIs:
+# make wasm
+
+.PHONY: wasm wasm-c wasm-cc
+wasm: wasm-c wasm-cc
+wasm-c: ${WASMTIME_C_BIN}
+wasm-cc: ${WASMTIME_CC_BIN}
+
+${WASMTIME_C_BINS}: CARGO_RUN
+ cd ${WASMTIME_API_DIR}; cargo build --lib ${CARGO_BUILD_FLAGS}
+
+.PHONY: CARGO_RUN
+CARGO_RUN:
+
+
+###############################################################################
+# Clean-up
+
+.PHONY: clean
+clean:
+ rm -rf ${OUT_DIR}
+
+###############################################################################
+# Other examples
+
+WASM_EXT_INCLUDE = ${WASMTIME_API_DIR}/include
+
+run-config-debug-c: ${EXAMPLE_OUT}/config-debug-c ${EXAMPLE_OUT}/fib-wasm.wasm
+ @echo ==== C config ====; \
+ cd ${EXAMPLE_OUT}; ./config-debug-c
+ @echo ==== Done ====
+
+${EXAMPLE_OUT}/fib-wasm.wasm: fib-wasm.wasm
+ cp $< $@
+
+${EXAMPLE_OUT}/config-debug-c.o: config-debug.c ${WASM_INCLUDE}/wasm.h ${WASM_EXT_INCLUDE}/wasmtime.h
+ mkdir -p ${EXAMPLE_OUT}
+ ${C_COMP} -c ${C_FLAGS} -I. -I${WASM_INCLUDE} -I${WASM_EXT_INCLUDE} $< -o $@
diff --git a/crates/c-api/examples/config-debug.c b/crates/c-api/examples/config-debug.c
new file mode 100644
index 0000000000..650d9645c9
--- /dev/null
+++ b/crates/c-api/examples/config-debug.c
@@ -0,0 +1,99 @@
+#include
+#include
+#include
+#include
+
+#include
+#include "wasmtime.h"
+
+#define own
+
+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();
+ wasmtime_config_debug_info_set(config, true);
+
+ // Initialize.
+ printf("Initializing...\n");
+ wasm_engine_t* engine = wasm_engine_new_with_config(config);
+ wasm_store_t* store = wasm_store_new(engine);
+
+ // Load binary.
+ printf("Loading binary...\n");
+ FILE* file = fopen("fib-wasm.wasm", "r");
+ if (!file) {
+ printf("> Error loading module!\n");
+ return 1;
+ }
+ fseek(file, 0L, SEEK_END);
+ size_t file_size = ftell(file);
+ fseek(file, 0L, SEEK_SET);
+ wasm_byte_vec_t binary;
+ wasm_byte_vec_new_uninitialized(&binary, file_size);
+ if (fread(binary.data, file_size, 1, file) != 1) {
+ printf("> Error loading module!\n");
+ return 1;
+ }
+ fclose(file);
+
+ // Compile.
+ printf("Compiling module...\n");
+ own wasm_module_t* module = wasm_module_new(store, &binary);
+ if (!module) {
+ printf("> Error compiling module!\n");
+ return 1;
+ }
+
+ wasm_byte_vec_delete(&binary);
+
+ // Instantiate.
+ printf("Instantiating module...\n");
+ own wasm_instance_t* instance =
+ wasm_instance_new(store, module, NULL, NULL);
+ if (!instance) {
+ printf("> Error instantiating module!\n");
+ return 1;
+ }
+
+ // Extract export.
+ printf("Extracting export...\n");
+ own wasm_extern_vec_t exports;
+ wasm_instance_exports(instance, &exports);
+ if (exports.size == 0) {
+ printf("> Error accessing exports!\n");
+ return 1;
+ }
+ // Getting second export (first is memory).
+ const wasm_func_t* run_func = wasm_extern_as_func(exports.data[1]);
+ if (run_func == NULL) {
+ printf("> Error accessing export!\n");
+ return 1;
+ }
+
+ wasm_module_delete(module);
+ wasm_instance_delete(instance);
+
+ // Call.
+ printf("Calling fib...\n");
+ wasm_val_t params[1] = { {.kind = WASM_I32, .of = {.i32 = 6}} };
+ wasm_val_t results[1];
+ if (wasm_func_call(run_func, params, results)) {
+ printf("> Error calling function!\n");
+ return 1;
+ }
+
+ wasm_extern_vec_delete(&exports);
+
+ printf("> fib(6) = %d\n", results[0].of.i32);
+
+ // Shut down.
+ printf("Shutting down...\n");
+ wasm_store_delete(store);
+ wasm_engine_delete(engine);
+
+ // All done.
+ printf("Done.\n");
+ return 0;
+}
diff --git a/crates/c-api/examples/fib-wasm.c b/crates/c-api/examples/fib-wasm.c
new file mode 100644
index 0000000000..20c06f5efa
--- /dev/null
+++ b/crates/c-api/examples/fib-wasm.c
@@ -0,0 +1,13 @@
+// Compile with:
+// clang --target=wasm32 fib-wasm.c -o fib-wasm.wasm -g \
+// -Wl,--no-entry,--export=fib -nostdlib -fdebug-prefix-map=$PWD=.
+
+int fib(int n) {
+ int i, t, a = 0, b = 1;
+ for (i = 0; i < n; i++) {
+ t = a;
+ a = b;
+ b += t;
+ }
+ return b;
+}
diff --git a/crates/c-api/examples/fib-wasm.wasm b/crates/c-api/examples/fib-wasm.wasm
new file mode 100755
index 0000000000..0a1ebac429
Binary files /dev/null and b/crates/c-api/examples/fib-wasm.wasm differ
diff --git a/crates/c-api/examples/wasm-c-api b/crates/c-api/examples/wasm-c-api
new file mode 160000
index 0000000000..d9a80099d4
--- /dev/null
+++ b/crates/c-api/examples/wasm-c-api
@@ -0,0 +1 @@
+Subproject commit d9a80099d496b5cdba6f3fe8fc77586e0e505ddc
diff --git a/crates/c-api/include/wasi.h b/crates/c-api/include/wasi.h
new file mode 100644
index 0000000000..e1a7ffc5dc
--- /dev/null
+++ b/crates/c-api/include/wasi.h
@@ -0,0 +1,70 @@
+// WASI C API
+
+#ifndef WASI_H
+#define WASI_H
+
+#include "wasm.h"
+
+#ifndef WASI_API_EXTERN
+#ifdef _WIN32
+#define WASI_API_EXTERN __declspec(dllimport)
+#else
+#define WASI_API_EXTERN
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#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*);
+
+// WASI config
+
+WASI_DECLARE_OWN(config)
+
+WASI_API_EXTERN own wasi_config_t* wasi_config_new();
+
+WASI_API_EXTERN void wasi_config_set_argv(wasi_config_t* config, int argc, const char* argv[]);
+WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t* config);
+
+WASI_API_EXTERN void wasi_config_set_env(wasi_config_t* config, int envc, const char* names[], const char* values[]);
+WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t* config);
+
+WASI_API_EXTERN bool wasi_config_set_stdin_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t* config);
+
+WASI_API_EXTERN bool wasi_config_set_stdout_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t* config);
+
+WASI_API_EXTERN bool wasi_config_set_stderr_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN void wasi_config_inherit_stderr(wasi_config_t* config);
+
+WASI_API_EXTERN bool wasi_config_preopen_dir(wasi_config_t* config, const char* path, const char* guest_path);
+
+// WASI instance
+
+WASI_DECLARE_OWN(instance)
+
+WASI_API_EXTERN own wasi_instance_t* wasi_instance_new(
+ wasm_store_t* store,
+ own wasi_config_t* config,
+ own wasm_trap_t** trap
+);
+
+WASI_API_EXTERN const wasm_extern_t* wasi_instance_bind_import(
+ const wasi_instance_t* instance,
+ const wasm_importtype_t* import
+);
+
+#undef own
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #ifdef WASI_H
\ No newline at end of file
diff --git a/crates/c-api/include/wasmtime.h b/crates/c-api/include/wasmtime.h
new file mode 100644
index 0000000000..16b463bb5a
--- /dev/null
+++ b/crates/c-api/include/wasmtime.h
@@ -0,0 +1,45 @@
+// WebAssembly C API extension for Wasmtime
+
+#ifndef WASMTIME_API_H
+#define WASMTIME_API_H
+
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uint8_t wasmtime_strategy_t;
+enum wasmtime_strategy_enum { // Strategy
+ WASMTIME_STRATEGY_AUTO,
+ WASMTIME_STRATEGY_CRANELIFT,
+ WASMTIME_STRATEGY_LIGHTBEAM,
+};
+
+typedef uint8_t wasmtime_opt_level_t;
+enum wasmtime_opt_level_enum { // OptLevel
+ WASMTIME_OPT_LEVEL_NONE,
+ WASMTIME_OPT_LEVEL_SPEED,
+ WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
+};
+
+#define WASMTIME_CONFIG_PROP(name, ty) \
+ WASM_API_EXTERN void wasmtime_config_##name##_set(wasm_config_t*, ty);
+
+WASMTIME_CONFIG_PROP(debug_info, bool)
+WASMTIME_CONFIG_PROP(wasm_threads, bool)
+WASMTIME_CONFIG_PROP(wasm_reference_types, bool)
+WASMTIME_CONFIG_PROP(wasm_simd, bool)
+WASMTIME_CONFIG_PROP(wasm_bulk_memory, bool)
+WASMTIME_CONFIG_PROP(wasm_multi_value, bool)
+WASMTIME_CONFIG_PROP(strategy, wasmtime_strategy_t)
+WASMTIME_CONFIG_PROP(cranelift_debug_verifier, bool)
+WASMTIME_CONFIG_PROP(cranelift_opt_level, wasmtime_opt_level_t)
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // WASMTIME_API_H
diff --git a/crates/c-api/src/ext.rs b/crates/c-api/src/ext.rs
new file mode 100644
index 0000000000..549bb1e604
--- /dev/null
+++ b/crates/c-api/src/ext.rs
@@ -0,0 +1,88 @@
+//! This file defines the extern "C" API extension, which are specific
+//! to the wasmtime implementation.
+
+use crate::wasm_config_t;
+use wasmtime::{OptLevel, Strategy};
+
+#[repr(u8)]
+#[derive(Clone)]
+pub enum wasmtime_strategy_t {
+ WASMTIME_STRATEGY_AUTO,
+ WASMTIME_STRATEGY_CRANELIFT,
+ WASMTIME_STRATEGY_LIGHTBEAM,
+}
+
+#[repr(u8)]
+#[derive(Clone)]
+pub enum wasmtime_opt_level_t {
+ WASMTIME_OPT_LEVEL_NONE,
+ WASMTIME_OPT_LEVEL_SPEED,
+ WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_debug_info_set(c: *mut wasm_config_t, enable: bool) {
+ (*c).config.debug_info(enable);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_wasm_threads_set(c: *mut wasm_config_t, enable: bool) {
+ (*c).config.wasm_threads(enable);
+}
+
+#[no_mangle]
+pub unsafe 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 unsafe extern "C" fn wasmtime_config_wasm_simd_set(c: *mut wasm_config_t, enable: bool) {
+ (*c).config.wasm_simd(enable);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_wasm_bulk_memory_set(c: *mut wasm_config_t, enable: bool) {
+ (*c).config.wasm_bulk_memory(enable);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_wasm_multi_value_set(c: *mut wasm_config_t, enable: bool) {
+ (*c).config.wasm_multi_value(enable);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_strategy_set(
+ c: *mut wasm_config_t,
+ strategy: wasmtime_strategy_t,
+) {
+ use wasmtime_strategy_t::*;
+ drop((*c).config.strategy(match strategy {
+ WASMTIME_STRATEGY_AUTO => Strategy::Auto,
+ WASMTIME_STRATEGY_CRANELIFT => Strategy::Cranelift,
+ WASMTIME_STRATEGY_LIGHTBEAM => Strategy::Lightbeam,
+ }));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_cranelift_debug_verifier_set(
+ c: *mut wasm_config_t,
+ enable: bool,
+) {
+ (*c).config.cranelift_debug_verifier(enable);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_cranelift_opt_level_set(
+ c: *mut wasm_config_t,
+ opt_level: wasmtime_opt_level_t,
+) {
+ use wasmtime_opt_level_t::*;
+ (*c).config.cranelift_opt_level(match opt_level {
+ WASMTIME_OPT_LEVEL_NONE => OptLevel::None,
+ WASMTIME_OPT_LEVEL_SPEED => OptLevel::Speed,
+ WASMTIME_OPT_LEVEL_SPEED_AND_SIZE => OptLevel::SpeedAndSize,
+ });
+}
diff --git a/crates/c-api/src/lib.rs b/crates/c-api/src/lib.rs
new file mode 100644
index 0000000000..52ec33af4e
--- /dev/null
+++ b/crates/c-api/src/lib.rs
@@ -0,0 +1,1785 @@
+//! This file defines the extern "C" API, which is compatible with the
+//! [Wasm C API](https://github.com/WebAssembly/wasm-c-api).
+
+#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+// TODO complete the C API
+
+use std::cell::RefCell;
+use std::panic::{self, AssertUnwindSafe};
+use std::rc::Rc;
+use std::{mem, ptr, slice};
+use wasmtime::{
+ AnyRef, Callable, Config, Engine, ExportType, Extern, ExternType, Func, FuncType, Global,
+ GlobalType, HostInfo, HostRef, ImportType, Instance, Limits, Memory, MemoryType, Module, Store,
+ Table, TableType, Trap, Val, ValType,
+};
+
+mod ext;
+mod wasi;
+
+pub use crate::ext::*;
+pub use crate::wasi::*;
+
+macro_rules! declare_vec {
+ ($name:ident, $elem_ty:path) => {
+ #[repr(C)]
+ #[derive(Clone)]
+ pub struct $name {
+ pub size: usize,
+ pub data: *mut $elem_ty,
+ }
+
+ impl $name {
+ #[allow(dead_code)]
+ fn set_from_slice(&mut self, source: &[$elem_ty]) {
+ let mut buffer = Vec::with_capacity(source.len());
+ buffer.extend_from_slice(source);
+ assert_eq!(buffer.len(), buffer.capacity());
+ self.size = buffer.len();
+ self.data = buffer.as_mut_ptr();
+ mem::forget(buffer);
+ }
+
+ #[allow(dead_code)]
+ fn set_buffer(&mut self, mut buffer: Vec<$elem_ty>) {
+ assert_eq!(buffer.len(), buffer.capacity());
+ self.size = buffer.len();
+ self.data = buffer.as_mut_ptr();
+ mem::forget(buffer);
+ }
+
+ #[allow(dead_code)]
+ fn set_uninitialized(&mut self, size: usize) {
+ let mut buffer = vec![Default::default(); size];
+ self.size = size;
+ self.data = buffer.as_mut_ptr();
+ mem::forget(buffer);
+ }
+
+ #[allow(dead_code)]
+ fn uninitialize(&mut self) {
+ let _ = unsafe { Vec::from_raw_parts(self.data, self.size, self.size) };
+ }
+
+ #[allow(dead_code)]
+ fn as_slice(&self) -> &[$elem_ty] {
+ unsafe { slice::from_raw_parts(self.data, self.size) }
+ }
+ }
+
+ impl From> for $name {
+ fn from(mut vec: Vec<$elem_ty>) -> Self {
+ assert_eq!(vec.len(), vec.capacity());
+ let result = $name {
+ size: vec.len(),
+ data: vec.as_mut_ptr(),
+ };
+ mem::forget(vec);
+ result
+ }
+ }
+
+ impl Drop for $name {
+ fn drop(&mut self) {
+ self.uninitialize();
+ }
+ }
+ };
+
+ ($name:ident, *mut $elem_ty:path) => {
+ #[repr(C)]
+ #[derive(Clone)]
+ pub struct $name {
+ pub size: usize,
+ pub data: *mut *mut $elem_ty,
+ }
+
+ impl $name {
+ #[allow(dead_code)]
+ fn set_from_slice(&mut self, source: &[*mut $elem_ty]) {
+ let mut buffer = Vec::with_capacity(source.len());
+ buffer.extend_from_slice(source);
+ assert_eq!(buffer.len(), buffer.capacity());
+ self.size = buffer.len();
+ self.data = buffer.as_mut_ptr();
+ mem::forget(buffer);
+ }
+
+ #[allow(dead_code)]
+ fn set_buffer(&mut self, mut buffer: Vec<*mut $elem_ty>) {
+ assert_eq!(buffer.len(), buffer.capacity());
+ self.size = buffer.len();
+ self.data = buffer.as_mut_ptr();
+ mem::forget(buffer);
+ }
+
+ #[allow(dead_code)]
+ fn set_uninitialized(&mut self, size: usize) {
+ let mut buffer = vec![ptr::null_mut(); size];
+ self.size = size;
+ self.data = buffer.as_mut_ptr();
+ mem::forget(buffer);
+ }
+
+ #[allow(dead_code)]
+ fn uninitialize(&mut self) {
+ for element in unsafe { Vec::from_raw_parts(self.data, self.size, self.size) } {
+ let _ = unsafe { Box::from_raw(element) };
+ }
+ }
+
+ #[allow(dead_code)]
+ fn as_slice(&self) -> &[*mut $elem_ty] {
+ unsafe { slice::from_raw_parts(self.data, self.size) }
+ }
+ }
+
+ impl From> for $name {
+ fn from(mut vec: Vec<*mut $elem_ty>) -> Self {
+ assert_eq!(vec.len(), vec.capacity());
+ let result = $name {
+ size: vec.len(),
+ data: vec.as_mut_ptr(),
+ };
+ mem::forget(vec);
+ result
+ }
+ }
+
+ impl Drop for $name {
+ fn drop(&mut self) {
+ self.uninitialize();
+ }
+ }
+ };
+}
+
+pub type float32_t = f32;
+pub type float64_t = f64;
+pub type wasm_byte_t = u8;
+
+declare_vec!(wasm_byte_vec_t, wasm_byte_t);
+
+pub type wasm_name_t = wasm_byte_vec_t;
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_config_t {
+ pub(crate) config: Config,
+}
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_engine_t {
+ engine: HostRef,
+}
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_store_t {
+ store: HostRef,
+}
+#[doc = ""]
+pub type wasm_mutability_t = u8;
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_limits_t {
+ pub min: u32,
+ pub max: u32,
+}
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_valtype_t {
+ ty: ValType,
+}
+
+declare_vec!(wasm_valtype_vec_t, *mut wasm_valtype_t);
+
+pub type wasm_valkind_t = u8;
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_functype_t {
+ functype: FuncType,
+ params_cache: Option,
+ returns_cache: Option,
+}
+
+declare_vec!(wasm_functype_vec_t, *mut wasm_functype_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_globaltype_t {
+ globaltype: GlobalType,
+ content_cache: Option,
+}
+
+declare_vec!(wasm_globaltype_vec_t, *mut wasm_globaltype_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_tabletype_t {
+ tabletype: TableType,
+ element_cache: Option,
+ limits_cache: Option,
+}
+
+declare_vec!(wasm_tabletype_vec_t, *mut wasm_tabletype_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_memorytype_t {
+ memorytype: MemoryType,
+ limits_cache: Option,
+}
+
+declare_vec!(wasm_memorytype_vec_t, *mut wasm_memorytype_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_externtype_t {
+ ty: ExternType,
+ cache: wasm_externtype_t_type_cache,
+}
+
+#[derive(Clone)]
+enum wasm_externtype_t_type_cache {
+ Empty,
+ Func(wasm_functype_t),
+ Global(wasm_globaltype_t),
+ Memory(wasm_memorytype_t),
+ Table(wasm_tabletype_t),
+}
+
+declare_vec!(wasm_externtype_vec_t, *mut wasm_externtype_t);
+
+pub type wasm_externkind_t = u8;
+
+const WASM_EXTERN_FUNC: wasm_externkind_t = 0;
+const WASM_EXTERN_GLOBAL: wasm_externkind_t = 1;
+const WASM_EXTERN_TABLE: wasm_externkind_t = 2;
+const WASM_EXTERN_MEMORY: wasm_externkind_t = 3;
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_importtype_t {
+ ty: ImportType,
+ module_cache: Option,
+ name_cache: Option,
+ type_cache: Option,
+}
+
+declare_vec!(wasm_importtype_vec_t, *mut wasm_importtype_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_exporttype_t {
+ ty: ExportType,
+ name_cache: Option,
+ type_cache: Option,
+}
+
+declare_vec!(wasm_exporttype_vec_t, *mut wasm_exporttype_t);
+
+#[doc = ""]
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_ref_t {
+ r: AnyRef,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct wasm_val_t {
+ pub kind: wasm_valkind_t,
+ pub of: wasm_val_t__bindgen_ty_1,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union wasm_val_t__bindgen_ty_1 {
+ pub i32: i32,
+ pub i64: i64,
+ pub u32: u32,
+ pub u64: u64,
+ pub f32: float32_t,
+ pub f64: float64_t,
+ pub ref_: *mut wasm_ref_t,
+ _bindgen_union_align: u64,
+}
+
+impl Default for wasm_val_t {
+ fn default() -> Self {
+ wasm_val_t {
+ kind: 0,
+ of: wasm_val_t__bindgen_ty_1 { i32: 0 },
+ }
+ }
+}
+
+declare_vec!(wasm_val_vec_t, wasm_val_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_frame_t {
+ _unused: [u8; 0],
+}
+
+declare_vec!(wasm_frame_vec_t, *mut wasm_frame_t);
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_instance_t {
+ instance: HostRef,
+ exports_cache: RefCell>>,
+}
+pub type wasm_message_t = wasm_name_t;
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_trap_t {
+ trap: HostRef,
+}
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_foreign_t {
+ _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_module_t {
+ module: HostRef
+ 
+ 
+