Merge pull request #1439 from Hywan/feat-interface-types-new-repo-rm

feat(interface-types) Move to its own repository

.appveyor.yml

@@ -1,90 +0,0 @@
-version: "{build} ~ {branch}"
-
-os: Visual Studio 2017
-
-branches:
-  only:
-    - staging
-    - trying
-    - master
-
-environment:
-  matrix:
-    - CHANNEL: stable
-      ARCH: x86_64
-      ABI: msvc
-      TARGET: x86_64-pc-windows-msvc
-
-cache:
-  - 'C:\Users\appveyor\.cargo'
-  - target
-  - wapm-cli-target
-
-install:
-  # # Install LLVM
-  # - mkdir C:\projects\deps
-  # - cd C:\projects\deps
-  # - appveyor DownloadFile http://prereleases.llvm.org/win-snapshots/LLVM-7.0.0-r336178-win64.exe -FileName llvm.exe
-  # - 7z x llvm.exe -oC:\projects\deps\llvm
-  # # - set "PATH=%PATH%;C:\projects\deps\llvm\bin"
-  # - set "LLD_LINK=C:\projects\deps\llvm\bin\lld-link.exe"
-  # - set "LLVM_SYS_70_PREFIX=C:\projects\deps\llvm"
-  # - cd "%APPVEYOR_BUILD_FOLDER%"
-
-  # Install Rust
-  # uncomment these lines if the cache is cleared, or if we must re-install rust for some reason
-  # - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  # - rustup-init.exe -yv --default-host %target%
-  - set PATH=%PATH%;C:\\Libraries\\llvm-5.0.0\\bin;%USERPROFILE%\.cargo\bin
-  - rustup default stable-%target%
-  - rustup update
-  - rustc -vV
-  - cargo -vV
-
-  # Install InnoSetup
-  - appveyor-retry appveyor DownloadFile https://s3-us-west-1.amazonaws.com/rust-lang-ci2/rust-ci-mirror/2017-08-22-is.exe
-  - 2017-08-22-is.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /SP-
-  - set PATH="C:\Program Files (x86)\Inno Setup 5";%PATH%
-# uncomment to RDP to appveyor
-#  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
-
-build_script:
-  - cargo build --release --verbose
-  # Now we build wapm
-  - git submodule init
-  - git submodule update
-  # Cache wapm cli target in dir above to prevent breaking git submodule on windows
-  - if not exist wapm-cli-target mkdir wapm-cli-target
-  - move wapm-cli-target wapm-cli
-  - cd wapm-cli
-  - rename wapm-cli-target target
-  - cd ..
-  - cargo build --release --manifest-path wapm-cli/Cargo.toml --features telemetry
-  - cd wapm-cli
-  - rename target wapm-cli-target
-  - cd ..
-  - move wapm-cli\wapm-cli-target wapm-cli-target
-  - cargo build --release --manifest-path lib/runtime-c-api/Cargo.toml
-
-test_script:
-  - cargo test --manifest-path lib/spectests/Cargo.toml --features clif
-
-before_deploy:
-  - cd ./src/installer
-  - iscc wasmer.iss
-  - copy /y .\WasmerInstaller.exe ..\..\WasmerInstaller-%APPVEYOR_REPO_TAG_NAME%.exe
-  - appveyor PushArtifact ..\..\WasmerInstaller-%APPVEYOR_REPO_TAG_NAME%.exe
-  - cd ..\..\
-
-matrix:
-  fast_finish: true
-
-deploy:
-  description: 'WasmerInstaller'
-  artifact: /.*\.exe/
-  auth_token:
-    secure: BbreGNDJy20922za7OhJG5TERzfX+dJSBQwttNTJkLvszbqMov6hhAtRb3P45hpf
-  provider: GitHub
-  on:
-    branch: master
-    appveyor_repo_tag: true

.azure/install-cmake.yml

@@ -0,0 +1,43 @@
+# This template installs CMake (if doesn't exist in the systems)
+
+steps:
+  - bash: |
+      set -ex
+      if [ -x "`command -v cmake`" ]; then
+        echo `command -v cmake` `cmake --version` installed
+      else
+        curl -O https://cmake.org/files/v3.4/cmake-3.4.1-Darwin-x86_64.tar.gz
+        tar xf cmake-3.4.1-Darwin-x86_64.tar.gz
+        export CMAKE_BIN_PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin"
+        echo "##vso[task.prependpath]$CMAKE_BIN_PATH"
+      fi
+    displayName: "Install CMake (macOS)"
+    condition: eq(variables['Agent.OS'], 'Darwin')
+
+  - bash: |
+      set -ex
+      if [ -x "`command -v cmake`" ]; then
+        echo `command -v cmake` `cmake --version` installed
+      else
+        curl -O https://cmake.org/files/v3.4/cmake-3.4.1-Linux-x86_64.tar.gz
+        tar xf cmake-3.4.1-Linux-x86_64.tar.gz
+        export CMAKE_BIN_PATH="`pwd`/cmake-3.4.1-Linux-x86_64/CMake.app/Contents/bin"
+        echo "##vso[task.prependpath]$CMAKE_BIN_PATH"
+      fi
+    displayName: "Install CMake (Linux)"
+    condition: eq(variables['Agent.OS'], 'Linux')
+
+  - bash: |
+      set -ex
+      if [ -x "`command -v cmake`" ]; then
+        echo `command -v cmake` `cmake --version` installed
+      else
+        chocolatey install cmake --installargs 'ADD_CMAKE_TO_PATH=System'
+      fi
+    displayName: "Install CMake (Windows)"
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  - bash: |
+      set -ex
+      cmake --version
+    displayName: CMake version

.azure/install-innosetup.yml

@@ -0,0 +1,18 @@
+# This template installs InnoSetup
+
+steps:
+  - bash: |
+      set -ex
+      if [ -x "`command -v iscc`" ]; then
+        echo `command -v iscc` `iscc -?` installed
+      else
+        choco install innosetup -y
+      fi
+    displayName: Install InnoSetup - Windows
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  # - bash: |
+  #     set -ex
+  #     iscc
+  #   displayName: InnoSetup
+  #   condition: eq(variables['Agent.OS'], 'Windows_NT')

.azure/install-llvm.yml

@@ -0,0 +1,70 @@
+# This template installs LLVM (if doesn't exist in the systems)
+
+steps:
+  - bash: |
+      set -ex
+      if [ -x "`command -v llvm-config`" ]; then
+        echo `command -v llvm-config` `llvm-config --version` installed
+      else
+        curl -O https://releases.llvm.org/8.0.0/clang+llvm-8.0.0-x86_64-apple-darwin.tar.xz
+        tar xf clang+llvm-8.0.0-x86_64-apple-darwin.tar.xz
+        export LLVM_PATH="`pwd`/clang+llvm-8.0.0-x86_64-apple-darwin/"
+        echo "##vso[task.prependpath]$LLVM_PATH/bin"
+        echo "##vso[task.setvariable variable=LLVM_SYS_80_PREFIX]$LLVM_PATH"
+      fi
+    displayName: "Install LLVM (macOS)"
+    condition: eq(variables['Agent.OS'], 'Darwin')
+
+  - bash: |
+      set -ex
+      if [ -x "`command -v llvm-config`" ]; then
+        echo `command -v llvm-config` `llvm-config --version` installed
+      else
+        curl -O https://releases.llvm.org/8.0.0/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+        tar xf clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+        export LLVM_PATH="`pwd`/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/"
+        echo "##vso[task.prependpath]$LLVM_PATH/bin"
+        echo "##vso[task.setvariable variable=LLVM_SYS_80_PREFIX]$LLVM_PATH"
+      fi
+    displayName: "Install LLVM (Linux X64)"
+    condition: and(eq(variables['Agent.OS'], 'Linux'), eq(variables['Agent.OSArchitecture'], 'X64'))
+
+  - bash: |
+      set -ex
+      if [ -x "`command -v llvm-config`" ]; then
+        echo `command -v llvm-config` `llvm-config --version` installed
+      else
+        curl -O https://releases.llvm.org/8.0.0/clang+llvm-8.0.0-aarch64-linux-gnu.tar.xz
+        tar xf clang+llvm-8.0.0-aarch64-linux-gnu.tar.xz
+        export LLVM_PATH="`pwd`/clang+llvm-8.0.0-aarch64-linux-gnu/"
+        echo "##vso[task.prependpath]$LLVM_PATH/bin"
+        echo "##vso[task.setvariable variable=LLVM_SYS_80_PREFIX]$LLVM_PATH"
+      fi
+    displayName: "Install LLVM (Linux ARM)"
+    condition: and(eq(variables['Agent.OS'], 'Linux'), eq(variables['Agent.OSArchitecture'], 'ARM64'))
+
+  - bash: |
+      set -ex
+      mkdir Win64_Release
+      cd Win64_Release
+      curl -OL https://github.com/wasmerio/llvm-build/releases/download/8.x/Win64_Release.zip
+      7z x Win64_Release.zip
+      llvm=`pwd`
+      echo "##vso[task.prependpath]$llvm/bin"
+      echo "##vso[task.setvariable variable=LLVM_SYS_80_PREFIX;]$llvm"
+      cd ..
+    displayName: "Install LLVM (Windows)"
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  # Just to make sure the paths and vars are set properly
+  - powershell: |
+      Write-Host "##vso[task.prependpath]$pwd/Win64_Release/bin"
+      Write-Host "##vso[task.setvariable variable=LLVM_SYS_80_PREFIX;]$pwd/Win64_Release/"
+    displayName: Install LLVM (Windows)
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  - bash: |
+      set -ex
+      env
+      llvm-config --version
+    displayName: LLVM version

.azure/install-rust.yml

@@ -0,0 +1,58 @@
+# This template installs Rust (if doesn't exist in the systems)
+# Also installs the desired Rust toolchain
+
+# Template inspired by Tokio and wasm-bindgen templates
+# Tokio template: https://github.com/tokio-rs/tokio/blob/master/ci/azure-install-rust.yml
+# Wasm-bindgen template: https://github.com/rustwasm/wasm-bindgen/blob/master/ci/azure-install-rust.yml
+
+steps:
+  # - bash: |
+  #     set -ex
+  #     brew install openssl@1.1 curl
+  #     brew link openssl@1.1 --force
+  #     echo "##vso[task.prependpath]/usr/local/opt/openssl/bin"
+  #     echo "##vso[task.setvariable variable=LDFLAGS;]-L/usr/local/opt/openssl/lib"
+  #     echo "##vso[task.setvariable variable=CPPFLAGS;]-I/usr/local/opt/openssl/include"
+  #   displayName: "Fix Cargo SSL (macOS)"
+  #   condition: eq(variables['Agent.OS'], 'Darwin')
+  - bash: |
+      set -ex
+      if [ -x "`command -v rustup`" ]; then
+        echo `command -v rustup` `rustup -V` installed
+      else
+        curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $RUST_TOOLCHAIN
+        echo "##vso[task.prependpath]$HOME/.cargo/bin"
+      fi
+    displayName: "Install Rust (Linux, macOS)"
+    condition: ne(variables['Agent.OS'], 'Windows_NT')
+
+  # - bash: |
+  #     set -ex
+  #     if [ -x "`command -v rustup`" ]; then
+  #       echo `command -v rustup` `rustup -V` installed
+  #     else
+  #       choco install rust -y
+  #       # curl -sSf -o rustup-init.exe https://win.rustup.rs
+  #       # ./rustup-init.exe -y --default-toolchain $RUST_TOOLCHAIN
+  #       # echo "##vso[task.prependpath]$USERPROFILE/.cargo/bin"
+  #     fi
+  #   displayName: "Install Rust (Windows)"
+  #   condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  - bash: |
+      set -ex
+      rustup update --no-self-update $RUST_TOOLCHAIN
+      rustup default $RUST_TOOLCHAIN
+      rustup target add x86_64-unknown-linux-musl
+      rustup target add wasm32-wasi
+
+      if [ -n "$ANDROID" ]; then
+        rustup target add x86_64-linux-android --toolchain $RUST_TOOLCHAIN
+      fi
+
+      rustc -Vv
+      cargo -V
+    displayName: Install Rust
+
+  - bash: echo "##vso[task.setvariable variable=RUSTC_VERSION;]`rustc --version`"
+    displayName: Set rustc version in env var

.azure/install-sccache.yml

@@ -0,0 +1,62 @@
+# This template installs sccache (Shared Compilation Cache)
+# More info: https://github.com/mozilla/sccache
+
+# Template originally from wasm-bindgen
+# https://github.com/rustwasm/wasm-bindgen/blob/master/ci/azure-install-sccache.yml
+steps:
+  - bash: |
+      set -ex
+      curl -L https://github.com/mozilla/sccache/releases/download/0.2.10/sccache-0.2.10-x86_64-unknown-linux-musl.tar.gz | tar xzf -
+      sccache=`pwd`/sccache-0.2.10-x86_64-unknown-linux-musl/sccache
+      echo "##vso[task.setvariable variable=RUSTC_WRAPPER;]$sccache"
+    displayName: Install sccache - Linux X64
+    condition: and(eq(variables['Agent.OS'], 'Linux'), eq(variables['Agent.OSArchitecture'], 'X64'))
+  - bash: |
+      command -v sccache > /dev/null || cargo install sccache
+      echo "##vso[task.setvariable variable=RUSTC_WRAPPER;]sccache"
+    displayName: Install sccache - Linux ARM
+    condition: and(eq(variables['Agent.OS'], 'Linux'), eq(variables['Agent.OSArchitecture'], 'ARM64'))
+  - bash: |
+      set -ex
+      brew install openssl@1.1
+      curl -L https://github.com/mozilla/sccache/releases/download/0.2.10/sccache-0.2.10-x86_64-apple-darwin.tar.gz | tar xzf -
+      sccache=`pwd`/sccache-0.2.10-x86_64-apple-darwin/sccache
+      echo "##vso[task.setvariable variable=RUSTC_WRAPPER;]$sccache"
+    displayName: Install sccache - Darwin
+    condition: eq( variables['Agent.OS'], 'Darwin' )
+  - powershell: |
+      Invoke-WebRequest https://github.com/mozilla/sccache/releases/download/0.2.10/sccache-0.2.10-x86_64-pc-windows-msvc.tar.gz -OutFile sccache.tar.gz
+      tar xzf sccache.tar.gz
+      Write-Host "##vso[task.setvariable variable=RUSTC_WRAPPER;]$pwd/sccache-0.2.10-x86_64-pc-windows-msvc/sccache.exe"
+    displayName: Install sccache - Windows
+    condition: eq( variables['Agent.OS'], 'Windows_NT' )
+  - bash: |
+      set -ex
+      env
+      SCCACHE_ERROR_LOG=`pwd`/sccache.log RUST_LOG=debug $RUSTC_WRAPPER --start-server
+      $RUSTC_WRAPPER -s
+      cat sccache.log
+    displayName: "start sccache"
+    condition: not(eq( variables['Agent.OS'], 'Windows_NT' ))
+    env:
+      SCCACHE_AZURE_CONNECTION_STRING: $(SCCACHE_AZURE_CONNECTION_STRING)
+      SCCACHE_AZURE_BLOB_CONTAINER: $(SCCACHE_AZURE_BLOB_CONTAINER)
+
+  # Only use Azure pipelines cache in Windows
+  - bash: |
+      set -ex
+      env
+      mkdir -p $SCCACHE_DIR
+      SCCACHE_ERROR_LOG=`pwd`/sccache.log RUST_LOG=debug $RUSTC_WRAPPER --start-server
+      $RUSTC_WRAPPER -s
+      cat sccache.log
+    displayName: "start sccache"
+    condition: eq( variables['Agent.OS'], 'Windows_NT' )
+    env:
+      SCCACHE_DIR: $(Pipeline.Workspace)/.sccache
+  - task: CacheBeta@0
+    inputs:
+      key: sccache | $(Agent.OS) | Cargo.lock
+      path: $(Pipeline.Workspace)/.sccache
+    displayName: Cache Cargo Target
+    condition: eq( variables['Agent.OS'], 'Windows_NT' )

.circleci/config.yml

@@ -1,435 +0,0 @@
-run_with_build_env_vars: &run_with_build_env_vars
-  environment:
-    LLVM_SYS_70_PREFIX: /home/circleci/project/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04/
-
-run_install_dependencies: &run_install_dependencies
-  run:
-    name: install dependencies
-    command: |
-      sudo apt-get install -y cmake
-      curl -O https://releases.llvm.org/7.0.0/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
-      tar xf clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
-
-version: 2
-jobs:
-  changelog:
-    docker:
-      - image: docker:stable-git
-    steps:
-      - checkout
-      - run:
-          command: ! git diff --exit-code CHANGELOG.md
-
-  # Job used for testing
-  lint:
-    docker:
-      - image: circleci/rust:latest
-    <<: *run_with_build_env_vars
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v8-lint-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - <<: *run_install_dependencies
-      - run:
-          name: Install lint deps
-          command: |
-            git config --global --unset url."ssh://git@github.com".insteadOf || true
-            rustup toolchain install nightly-2019-05-20
-            rustup component add rustfmt
-            rustup component add clippy --toolchain=nightly-2019-05-20 || cargo +nightly-2019-05-20 install --git https://github.com/rust-lang/rust-clippy/ --force clippy
-      - run:
-          name: Execute lints
-          command: |
-            make lint
-      - save_cache:
-          paths:
-            - /usr/local/cargo/registry
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-          key: v8-lint-{{ arch }}-{{ checksum "Cargo.lock" }}
-
-  test:
-    docker:
-      - image: circleci/rust:latest
-    <<: *run_with_build_env_vars
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v8-test-cargo-cache-linux-stable-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - <<: *run_install_dependencies
-      - run:
-          name: Tests
-          command: make test
-      - run:
-          name: Emscripten Tests
-          command: |
-            make test-emscripten-clif
-            make test-emscripten-llvm
-      - run:
-          name: Integration Tests
-          command: make integration-tests
-      - save_cache:
-          paths:
-            - /usr/local/cargo/registry
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-          key: v8-test-cargo-cache-linux-stable-{{ arch }}-{{ checksum "Cargo.lock" }}
-
-  test-macos:
-    macos:
-      xcode: "9.0"
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v8-cargo-cache-darwin-stable-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - run:
-          name: Install crate dependencies
-          command: |
-            # Installing cmake outside of brew to improve speed
-            curl -O https://cmake.org/files/v3.4/cmake-3.4.1-Darwin-x86_64.tar.gz
-            tar xf cmake-3.4.1-Darwin-x86_64.tar.gz
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            # Installing LLVM outside of brew
-            curl -O https://releases.llvm.org/7.0.0/clang+llvm-7.0.0-x86_64-apple-darwin.tar.xz
-            tar xf clang+llvm-7.0.0-x86_64-apple-darwin.tar.xz
-      - run:
-          name: Install Rust
-          command: |
-            curl -sSf https://sh.rustup.rs | sh -s -- -y
-            export PATH="$HOME/.cargo/bin:$PATH"
-            cargo --version
-      - run:
-          name: Tests
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-apple-darwin/"
-            # We increase the ulimit for fixing cargo unclosed files in mac
-            ulimit -n 8000
-            sudo sysctl -w kern.maxfiles=655360 kern.maxfilesperproc=327680
-            make test
-      - run:
-          name: Emscripten Tests
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-apple-darwin/"
-            # We increase the ulimit for fixing cargo unclosed files in mac
-            ulimit -n 8000
-            sudo sysctl -w kern.maxfiles=655360 kern.maxfilesperproc=327680
-            make test-emscripten-clif
-            make test-emscripten-llvm
-      - run:
-          name: Integration Tests
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-apple-darwin/"
-            make integration-tests
-      - save_cache:
-          paths:
-            - ~/.cargo/registry/
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-            - target/release/.fingerprint
-            - target/release/build
-            - target/release/deps
-          key: v8-cargo-cache-darwin-stable-{{ arch }}-{{ checksum "Cargo.lock" }}
-
-  test-and-build:
-    docker:
-      - image: circleci/rust:latest
-    steps:
-      - checkout
-      - run:
-          name: "Pull dependencies"
-          command: |
-            git submodule init
-            git submodule update
-      - restore_cache:
-          keys:
-            - v8-cargo-cache-linux-nightly-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - run:
-          name: Install dependencies
-          command: |
-            sudo apt-get install -y cmake
-            curl -O https://releases.llvm.org/7.0.0/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
-            tar xf clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
-      # Use rust nightly (for singlepass, for now)
-      - run: rustup default nightly-2019-04-11
-      - run:
-          name: Tests
-          command: |
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04/"
-            make test
-      - run:
-          name: Emscripten Tests
-          command: |
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04/"
-            make test-emscripten-clif
-            make test-emscripten-llvm
-      - run:
-          name: Debug flag checked
-          command: |
-            cargo check --features "debug"
-      - run:
-          name: Release Build
-          command: |
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04/"
-            make production-release
-            cargo build --release --manifest-path wapm-cli/Cargo.toml --features telemetry
-            mkdir -p artifacts
-            VERSION=$(cargo pkgid | cut -d# -f2 | cut -d: -f2)
-            # GIT_VERSION=$(git describe --exact-match --tags)
-            echo "${VERSION}" >> artifacts/version
-            echo "${CIRCLE_TAG}" >> artifacts/git_version
-            make build-install
-            cp ./wasmer.tar.gz ./artifacts/$(./binary-name.sh)
-      - run:
-          name: Dynamic library
-          command: |
-            cargo build --release --manifest-path lib/runtime-c-api/Cargo.toml
-            cp target/release/libwasmer_runtime_c_api.so ./artifacts
-      - persist_to_workspace:
-          root: .
-          paths:
-            - artifacts
-      - save_cache:
-          paths:
-            - /usr/local/cargo/registry
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-            - target/release/.fingerprint
-            - target/release/build
-            - target/release/deps
-            - wapm-cli/target/release/.fingerprint
-            - wapm-cli/target/release/build
-            - wapm-cli/target/release/deps
-          key: v8-cargo-cache-linux-nightly-{{ arch }}-{{ checksum "Cargo.lock" }}
-
-  test-and-build-macos:
-    macos:
-      xcode: "9.0"
-    steps:
-      - checkout
-      - run:
-          name: "Pull dependencies"
-          command: |
-            git submodule init
-            git submodule update
-      - restore_cache:
-          keys:
-            - v8-cargo-cache-darwin-nightly-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - run:
-          name: Install crate dependencies
-          command: |
-            # Installing cmake outside of brew to improve speed
-            curl -O https://cmake.org/files/v3.4/cmake-3.4.1-Darwin-x86_64.tar.gz
-            tar xf cmake-3.4.1-Darwin-x86_64.tar.gz
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            # Installing LLVM outside of brew
-            curl -O https://releases.llvm.org/7.0.0/clang+llvm-7.0.0-x86_64-apple-darwin.tar.xz
-            tar xf clang+llvm-7.0.0-x86_64-apple-darwin.tar.xz
-      - run:
-          name: Install Rust
-          command: |
-            curl -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain nightly
-            export PATH="$HOME/.cargo/bin:$PATH"
-            cargo --version
-      # Use rust nightly (for singlepass, for now)
-      # - run:
-      #     name: Install Rust nightly
-      #     command: |
-      #       export PATH="$HOME/.rustup/bin:$PATH"
-      #       rustup default nightly-2019-04-11
-      - run:
-          name: Tests
-          command: |
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            export PATH="$HOME/.cargo/bin:$PATH"
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-apple-darwin/"
-            # We increase the ulimit for fixing cargo unclosed files in mac
-            ulimit -n 8000
-            sudo sysctl -w kern.maxfiles=655360 kern.maxfilesperproc=327680
-            make test
-      - run:
-          name: Emscripten Tests
-          command: |
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            export PATH="$HOME/.cargo/bin:$PATH"
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-apple-darwin/"
-            # We increase the ulimit for fixing cargo unclosed files in mac
-            ulimit -n 8000
-            sudo sysctl -w kern.maxfiles=655360 kern.maxfilesperproc=327680
-            make test-emscripten-clif
-            make test-emscripten-singlepass
-      - run:
-          name: Release Build
-          command: |
-            export PATH="`pwd`/cmake-3.4.1-Darwin-x86_64/CMake.app/Contents/bin:$PATH"
-            export PATH="$HOME/.cargo/bin:$PATH"
-            export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-apple-darwin/"
-            make production-release
-            cargo build --release --manifest-path wapm-cli/Cargo.toml --features telemetry
-            mkdir -p artifacts
-            make build-install
-            cp ./wasmer.tar.gz ./artifacts/$(./binary-name.sh)
-            # VERSION=$(cargo pkgid | cut -d# -f2 | cut -d: -f2)
-            # echo "${VERSION}" >> artifacts/version
-      - run:
-          name: Generate dynamic library for the runtime C API
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            cargo build --release --manifest-path lib/runtime-c-api/Cargo.toml
-            install_name_tool -id "@rpath/libwasmer_runtime_c_api.dylib" target/release/libwasmer_runtime_c_api.dylib
-            cp target/release/libwasmer_runtime_c_api.dylib ./artifacts
-      - persist_to_workspace:
-          root: .
-          paths:
-            - artifacts
-      - save_cache:
-          paths:
-            - ~/.cargo/registry/
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-            - target/release/.fingerprint
-            - target/release/build
-            - target/release/deps
-            - wapm-cli/target/release/.fingerprint
-            - wapm-cli/target/release/build
-            - wapm-cli/target/release/deps
-          key: v8-cargo-cache-darwin-nightly-{ arch }}-{{ checksum "Cargo.lock" }}
-
-  test-rust-nightly:
-    docker:
-      - image: circleci/rust:latest
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v8-cargo-cache-linux-nightly-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - run:
-          name: Install dependencies
-          command: |
-            sudo apt-get install -y cmake
-            curl -O https://releases.llvm.org/7.0.0/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
-            tar xf clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz
-            rustup toolchain install nightly
-            rustup target add wasm32-wasi --toolchain nightly
-      - run: |
-          rustup default nightly
-          make test-wasi-singlepass
-          make test-wasi-clif
-      - run: rustup default nightly-2019-04-11
-      - run: |
-          export LLVM_SYS_70_PREFIX="`pwd`/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04/"
-          make test
-          make test-singlepass
-          make test-emscripten-clif
-          make test-emscripten-singlepass
-      - save_cache:
-          paths:
-            - /usr/local/cargo/registry
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-          key: v8-cargo-cache-linux-nightly-{{ arch }}-{{ checksum "Cargo.lock" }}-nightly
-
-  publish-github-release:
-    docker:
-      - image: cibuilds/github
-    steps:
-      - attach_workspace:
-          at: .
-      - run:
-          name: "Publish Release on GitHub"
-          command: |
-            # go get github.com/tcnksm/ghr
-            # VERSION=$(git log -1 --pretty=%B)
-            # VERSION=$(./artifacts/ --version)
-            VERSION=$(cat ./artifacts/version)
-            # VERSION_TAG=${CIRCLE_TAG}
-            VERSION_TAG=$(cat ./artifacts/git_version)
-            rm ./artifacts/version
-            rm ./artifacts/git_version
-            # VERSION_TAG=$(git describe --exact-match --tags)
-            #if [ "$VERSION" == "$VERSION_TAG" ]; then
-            # echo "Versions match, publishing to Github"
-            ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} ${VERSION} ./artifacts/  || true
-            #else
-            #    echo "Versions don't match. Wasmer output version (wasmer --version) is ${VERSION} while Git tag is ${VERSION_TAG}"
-            #    exit 1
-            #fi
-  trigger-benchmark-build:
-    docker:
-      - image: circleci/rust:latest
-    steps:
-      - run:
-          name: "Trigger Benchmark Build"
-          command: |
-            if [[ -z "${CIRCLE_API_USER_TOKEN}" ]]; then
-               echo "CIRCLE_API_USER_TOKEN environment variable not set"
-               exit 1
-            else
-               echo "Triggering benchmark build"
-               curl -u ${CIRCLE_API_USER_TOKEN} \
-                    -d build_parameters[CIRCLE_JOB]=bench \
-                    https://circleci.com/api/v1.1/project/github/wasmerio/wasmer-bench/tree/master
-            fi
-workflows:
-  version: 2
-  main:
-    jobs:
-      - changelog
-      - lint
-      - test:
-          filters:
-            branches:
-              only:
-                - trying
-                - staging
-      - test-macos:
-          filters:
-            branches:
-              only:
-                - trying
-                - staging
-      - test-and-build:
-          filters:
-            branches:
-              only:
-                - master
-      - test-and-build-macos:
-          filters:
-            branches:
-              only:
-                - master
-      - test-rust-nightly:
-          filters:
-            branches:
-              only:
-                - trying
-                - staging
-      - publish-github-release:
-          requires:
-            - lint
-            - test-and-build
-            - test-and-build-macos
-          filters:
-            branches:
-              only: master
-      - trigger-benchmark-build:
-          requires:
-            - test-and-build
-            - lint
-          filters:
-            branches:
-              only: master

.dockerignore

@@ -1,6 +0,0 @@
-# Ignore everything
-**
-!lib/**
-!src/**
-!Cargo.toml
-!Cargo.lock

.gitattributes

@@ -1,2 +1,3 @@
 lib/emscripten/emtests/* linguist-vendored
 lib/spectests/spectests/* linguist-vendored
+CHANGELOG.md merge=union

.github/CODEOWNERS

@@ -0,0 +1,38 @@
+# 
+src/                        @syrusakbary @MarkMcCaskey
+
+# Backends
+lib/singlepass-backend   	@losfair @nlewycky
+lib/clif-backend   	        @nlewycky
+lib/llvm-backend            @nlewycky @losfair
+
+# Runtime
+lib/runtime-core   	        @Hywan
+lib/runtime        	        @MarkMcCaskey @Hywan
+lib/runtime-c-api 	        @Hywan
+lib/win-exception-handler   @losfair
+lib/middleware-common       @losfair
+
+# Frontend integrations
+
+## Emscripten
+lib/emscripten        	    @MarkMcCaskey @syrusakbary
+lib/emscripten-tests  	    @MarkMcCaskey @syrusakbary
+
+## WASI
+lib/wasi            	    @MarkMcCaskey
+lib/wasi-tests      	    @MarkMcCaskey
+
+## Spectests
+lib/spectests               @syrusakbary @MarkMcCaskey @nlewycky
+
+# Kernel
+lib/kernel-loader           @losfair
+lib/kernel-net              @losfair
+
+# Examples
+examples                    @syrusakbary
+
+# Documentation
+docs                        @syrusakbary
+

.github/ISSUE_TEMPLATE/---bug-report.md

@@ -7,37 +7,44 @@ assignees: ''
 
 ---
 
-Thanks for the bug report!
+<!-- Thanks for the bug report! -->
 
 ### Describe the bug
 
+<!--
 A clear and concise description of what the bug is.
 
 Copy and paste the result of executing the following in your shell, so we can know the version of wasmer, Rust (if available) and architecture of your environment.
+-->
 
-```bash
+```sh
 echo "`wasmer -V` | `rustc -V` | `uname -m`"
 ```
 
-### Steps to reproduce
 
+### Steps to reproduce
+<!--
+Include steps that will help us recreate the issue.
+
+For example,
 1. Go to '…'
 2. Compile with '…'
 3. Run '…'
 4. See error
 
 If applicable, add a link to a test case (as a zip file or link to a repository we can clone).
+-->
 
 ### Expected behavior
-
-A clear and concise description of what you expected to happen.
+<!-- A clear and concise description of what you expected to happen. -->
 
 ### Actual behavior
 
+<!--
 A clear and concise description of what actually happened.
 
 If applicable, add screenshots to help explain your problem.
+-->
 
 ### Additional context
-
-Add any other context about the problem here.
+<!-- Add any other context about the problem here. -->

.github/pull_request_template.md

@@ -0,0 +1,15 @@
+<!-- 
+Prior to submitting a PR, review the CONTRIBUTING.md document for recommendations on how to test:
+https://github.com/wasmerio/wasmer/blob/master/CONTRIBUTING.md#pull-requests
+
+-->
+
+# Description
+<!-- 
+Provide details regarding the change including motivation,
+links to related issues, and the context of the PR.
+-->
+
+# Review
+
+- [ ] Add a short description of the the change to the CHANGELOG.md file

.gitignore

@@ -5,3 +5,10 @@
 .idea
 **/.vscode
 install/
+capi/
+api-docs/
+api-docs-repo/
+
+# Generated by tests on Android
+/avd
+/core

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "wapm-cli"]
-	path = wapm-cli
-	url = https://github.com/wasmerio/wapm-cli.git

ARCHITECTURE.md

@@ -1,74 +0,0 @@
-# Wasmer Architecture
-
-Wasmer uses the following components:
-
-- Compiler backends: for compiling Wasm binaries to machine code ([more info here](https://github.com/wasmerio/wasmer/tree/master/lib#backends))
-- [wabt](https://github.com/pepyakin/wabt-rs): for transforming `.wast` files to `.wasm` and running WebAssembly spec tests
-- [wasmparser](https://github.com/yurydelendik/wasmparser.rs): for parsing the `.wasm` files and translating them into WebAssembly modules
-
-## How Wasmer works
-
-The first time you run `wasmer run myfile.wasm`, Wasmer will:
-
-- Check if is a `.wast` file, and if so, transform it to `.wasm`
-- Check that the provided binary is a valid WebAssembly one, i.e. its binary format starts with `\0asm`.
-- Parse it with `wasmparser` and generate a `Module` from it
-- Generate an `Instance` with the proper `import_object` (that means, if is detected to be an Emscripten file, it will add the Emscripten expected imports)
-- Try to call the WebAssembly `start` function, or if it does not exist, try to search for the function that is exported as `main`
-
-Find a more detailed explanation of the process below:
-
-### Phase 1: Generating the Module / IR
-
-As the WebAssembly file is being parsed, it will read the sections in the WebAssembly file (memory, table, function, global and element definitions) using the `Module` (or `ModuleEnvironment`) as the structure to hold this information.
-
-However, the real IR initialization happens while a function body is being parsed/created, i.e. when the parser reads the section `(func ...)`.
-While the function body is being parsed the corresponding `FuncEnvironment` methods will be called.
-
-So for example, if the function is using a table, the `make_table` method within that `FuncEnvironment` will be called.
-Each of this methods will return the corresponding IR representation.
-
-The `Module` creation will be finished once the parsing is done, and will hold all the function IR as well as the imports/exports.
-
-### Phase 2: Compiling the Functions
-
-Now that we have a `Module` (and all its definitions living in `ModuleInfo`) we should be ready to compile its functions.
-
-Right now, the `Instance` is the one in charge of compiling this functions into machine code.
-
-When creating the `Instance`, each of the function bodies (IR) will be compiled into machine code that our architecture can understand.
-Once we have the compiled values, we will push them to memory and mark them as executable, so we can call them from anywhere in our code.
-
-#### Relocations
-
-Sometimes the functions that we generate will need to call other functions, but the generated code has no idea how to link these functions together.
-
-For example, if a function `A` is calling function `B` (that means is having a `(call b)` on its body) while compiling `A` we will have no idea where the function `B` lives on memory (as `B` is not yet compiled nor pushed into memory).
-
-For that reason, we will start collecting all the calls that function `A` will need to do under the hood, and save it's offsets.
-We do that, so we can patch the function calls after compilation, to point to the correct memory address.
-
-Note: sometimes this functions rather than living in the same WebAssembly module, they will be provided as import values.
-
-#### Traps
-
-There will be other times where the function created will cause a trap (for example, if executing `0 / 0`).
-When this happens, we will save the offset of the trap (while the function is being compiled).
-
-Thanks to that when we execute a function, if it traps (that means a sigaction is called), we would be able to backtrack from a memory address to a specific trap case.
-
-### Phase 3: Finalizing
-
-Once all the functions are compiled and patched with the proper relocations addresses, we will initialize the corresponding tables (where we save the pointers to all the exported functions), memories and globals that the instance need.
-
-Once that's finished, we will have a `Instance` function that will be ready to execute any function we need.
-
-## Emscripten
-
-Wasmer's Emscripten integration tries to wrap (and emulate) all the different syscalls that Emscripten needs.
-We provide this integration by filling the `import_object` with the Emscripten functions, while instantiating the WebAssembly Instance.
-
-## WASI
-
-Wasmer's WASI integration implements all the different syscalls that WASI needs.
-We provide this integration by filling the `import_object` with the WASI functions, while instantiating the WebAssembly Instance.

ATTRIBUTIONS.md

@@ -1,21 +1,29 @@
 # Wasmer Attributions
 
-Wasmer is a community effort.
-In order to build the best WebAssembly runtime it's our duty to see how other runtimes are approaching the same space
-and get inspired from them on the things that they got right, so Wasmer and its community can benefit from a solid
-foundation.
+Wasmer is a community effort and makes use of code from various other
+projects. Listed below are notable sections of code that are licensed
+from other projects and the relevant license of those projects.
 
-These are the different project that we used as inspiration:
+These are the projects that were used as inspiration and/or that we are using code from:
 
 - [Nebulet](https://github.com/nebulet/nebulet): as the base for creating a great Rust WebAssembly runtime
 - [WAVM](https://github.com/wavm/wavm): for their great integration and testing framework
 - [greenwasm](https://github.com/Kimundi/greenwasm): for their [spectests framework](https://github.com/Kimundi/greenwasm/tree/master/greenwasm-spectest)
-- [wasmtime](https://github.com/CraneStation/wasmtime): for their [mmap implementation](https://github.com/CraneStation/wasmtime/blob/3f24098edc81cd9bf0f877fb7fba018cad0f039e/lib/runtime/src/mmap.rs)
+- [wasmtime](https://github.com/CraneStation/wasmtime):
+  For their [mmap implementation](https://github.com/CraneStation/wasmtime/blob/3f24098edc81cd9bf0f877fb7fba018cad0f039e/lib/runtime/src/mmap.rs), the wast test implementation and the implementation of the `__jit_debug_register_code` function
+  in Rust, the structure of using Cranelift with the GDB JIT
+  interface including implementation details regarding the structure
+  of generating debug information for each function with Cranelift
+  (for example, the sorting of the extended basic blocks before
+  processing the instructions), and the API for transforming DWARF
+  see [wasm-debug's attribution file](https://github.com/wasmerio/wasm-debug/blob/master/ATTRIBUTIONS.md)
+  for more information
 - [stackoverflow](https://stackoverflow.com/a/45795699/1072990): to create an efficient HashMap with pair keys
 - [Emscripten](https://github.com/kripken/emscripten): for emtests test sources to ensure compatibility
+- [The WebAssembly spec](https://github.com/WebAssembly/spec/tree/master/test): for implementation details of WebAssembly and spectests
 
-We would love to hear from you if you think we can take inspiration from other projects that we haven't covered here.
-😊
+Please let us know if you believe there is an error or omission in
+this list and we will do our best to correct it.
 
 ## Licenses
 

CHANGELOG.md

@@ -1,14 +1,281 @@
 # Changelog
 
-All PRs to the Wasmer repository must add to this file.
-
-Blocks of changes will separated by version increments.
-
 ## **[Unreleased]**
-## 0.5.3
+
+- [#1439](https://github.com/wasmerio/wasmer/pull/1439) Move `wasmer-interface-types` into its own repository
+
+## 0.17.0 - 2020-05-11
+
+- [#1401](https://github.com/wasmerio/wasmer/pull/1401) Make breaking change to `RuntimeError`: `RuntimeError` is now more explicit about its possible error values allowing for better insight into why a call into Wasm failed.
+- [#1382](https://github.com/wasmerio/wasmer/pull/1382) Refactored test infranstructure (part 2)
+- [#1380](https://github.com/wasmerio/wasmer/pull/1380) Refactored test infranstructure (part 1)
+- [#1357](https://github.com/wasmerio/wasmer/pull/1357) Refactored bin commands into separate files
+- [#1331](https://github.com/wasmerio/wasmer/pull/1331) Implement the `record` type and instrutions for WIT
+- [#1345](https://github.com/wasmerio/wasmer/pull/1345) Adding ARM testing in Azure Pipelines
+- [#1335](https://github.com/wasmerio/wasmer/pull/1335) Change mutability of `memory` to `const` in `wasmer_memory_data_length` in the C API
+- [#1329](https://github.com/wasmerio/wasmer/pull/1329) New numbers and strings instructions for WIT
+- [#1332](https://github.com/wasmerio/wasmer/pull/1332) Add option to `CompilerConfig` to force compiler IR verification off even when `debug_assertions` are enabled. This can be used to make debug builds faster, which may be important if you're creating a library that wraps Wasmer and depend on the speed of debug builds.
+- [#1320](https://github.com/wasmerio/wasmer/pull/1320) Change `custom_sections` field in `ModuleInfo` to be more standards compliant by allowing multiple custom sections with the same name. To get the old behavior with the new API, you can add `.last().unwrap()` to accesses. For example, `module_info.custom_sections["custom_section_name"].last().unwrap()`.
+- [#1313](https://github.com/wasmerio/wasmer/pull/1313) Add new high-level public API through `wasmer` crate. Includes many updates including:
+  - Minor improvement: `imports!` macro now handles no trailing comma as well as a trailing comma in namespaces and between namespaces.
+  - New methods on `Module`: `exports`, `imports`, and `custom_sections`.
+  - New way to get exports from an instance with `let func_name: Func<i32, i64> = instance.exports.get("func_name");`.
+  - Improved `Table` APIs including `set` which now allows setting functions directly.  TODO: update this more if `Table::get` gets made public in this PR
+  - TODO: finish the list of changes here
+- [#1303](https://github.com/wasmerio/wasmer/pull/1303) NaN canonicalization for singlepass backend.
+- [#1292](https://github.com/wasmerio/wasmer/pull/1292) Experimental Support for Android (x86_64 and AArch64)
+- [#1305](https://github.com/wasmerio/wasmer/pull/1305) Handle panics from DynamicFunc.
+- [#1301](https://github.com/wasmerio/wasmer/pull/1301) Update supported stable Rust version to 1.41.1.
+- [#1300](https://github.com/wasmerio/wasmer/pull/1300) Add support for multiple versions of WASI tests: wasitests now test all versions of WASI.
+- [#1285](https://github.com/wasmerio/wasmer/pull/1285) Greatly improve errors in `wasmer-interface-types`
+- [#1283](https://github.com/wasmerio/wasmer/pull/1283) Workaround for floating point arguments and return values in `DynamicFunc`s.
+
+## 0.16.2 - 2020-03-11
+
+- [#1294](https://github.com/wasmerio/wasmer/pull/1294) Fix bug related to system calls in WASI that rely on reading from WasmPtrs as arrays of length 0. `WasmPtr` will now succeed on length 0 arrays again.
+
+## 0.16.1 - 2020-03-11
+
+- [#1291](https://github.com/wasmerio/wasmer/pull/1291) Fix installation packaging script to package the `wax` command.
+
+## 0.16.0 - 2020-03-11
+
+- [#1286](https://github.com/wasmerio/wasmer/pull/1286) Updated Windows Wasmer icons. Add wax
+- [#1284](https://github.com/wasmerio/wasmer/pull/1284) Implement string and memory instructions in `wasmer-interface-types`
+- [#1272](https://github.com/wasmerio/wasmer/pull/1272) Fix off-by-one error bug when accessing memory with a `WasmPtr` that contains the last valid byte of memory. Also changes the behavior of `WasmPtr<T, Array>` with a length of 0 and `WasmPtr<T>` where `std::mem::size_of::<T>()` is 0 to always return `None`
+
+## 0.15.0 - 2020-03-04
+
+- [#1263](https://github.com/wasmerio/wasmer/pull/1263) Changed the behavior of some WASI syscalls to now handle preopened directories more properly. Changed default `--debug` logging to only show Wasmer-related messages.
+- [#1217](https://github.com/wasmerio/wasmer/pull/1217) Polymorphic host functions based on dynamic trampoline generation.
+- [#1252](https://github.com/wasmerio/wasmer/pull/1252) Allow `/` in wasi `--mapdir` wasm path.
+- [#1212](https://github.com/wasmerio/wasmer/pull/1212) Add support for GDB JIT debugging:
+  - Add `--generate-debug-info` and `-g` flags to `wasmer run` to generate debug information during compilation. The debug info is passed via the GDB JIT interface to a debugger to allow source-level debugging of Wasm files. Currently only available on clif-backend.
+  - Break public middleware APIs: there is now a `source_loc` parameter that should be passed through if applicable.
+  - Break compiler trait methods such as `feed_local`, `feed_event` as well as `ModuleCodeGenerator::finalize`.
+
+## 0.14.1 - 2020-02-24
+
+- [#1245](https://github.com/wasmerio/wasmer/pull/1245) Use Ubuntu 16.04 in CI so that we use an earlier version of GLIBC.
+- [#1234](https://github.com/wasmerio/wasmer/pull/1234) Check for unused excluded spectest failures.
+- [#1232](https://github.com/wasmerio/wasmer/pull/1232) `wasmer-interface-types` has a WAT decoder.
+
+## 0.14.0 - 2020-02-20
+
+- [#1233](https://github.com/wasmerio/wasmer/pull/1233) Improved Wasmer C API release artifacts.
+- [#1216](https://github.com/wasmerio/wasmer/pull/1216) `wasmer-interface-types` receives a binary encoder.
+- [#1228](https://github.com/wasmerio/wasmer/pull/1228) Singlepass cleanup: Resolve several FIXMEs and remove protect_unix.
+- [#1218](https://github.com/wasmerio/wasmer/pull/1218) Enable Cranelift verifier in debug mode. Fix bug with table indices being the wrong type.
+- [#787](https://github.com/wasmerio/wasmer/pull/787) New crate `wasmer-interface-types` to implement WebAssembly Interface Types.
+- [#1213](https://github.com/wasmerio/wasmer/pull/1213) Fixed WASI `fdstat` to detect `isatty` properly.
+- [#1192](https://github.com/wasmerio/wasmer/pull/1192) Use `ExceptionCode` for error representation.
+- [#1191](https://github.com/wasmerio/wasmer/pull/1191) Fix singlepass miscompilation on `Operator::CallIndirect`.
+- [#1180](https://github.com/wasmerio/wasmer/pull/1180) Fix compilation for target `x86_64-unknown-linux-musl`.
+- [#1170](https://github.com/wasmerio/wasmer/pull/1170) Improve the WasiFs builder API with convenience methods for overriding stdin, stdout, and stderr as well as a new sub-builder for controlling the permissions and properties of preopened directories.  Also breaks that implementations of `WasiFile` must be `Send` -- please file an issue if this change causes you any issues.
+- [#1161](https://github.com/wasmerio/wasmer/pull/1161) Require imported functions to be `Send`. This is a breaking change that fixes a soundness issue in the API.
+- [#1140](https://github.com/wasmerio/wasmer/pull/1140) Use [`blake3`](https://github.com/BLAKE3-team/BLAKE3) as default hashing algorithm for caching.
+- [#1129](https://github.com/wasmerio/wasmer/pull/1129) Standard exception types for singlepass backend.
+
+## 0.13.1 - 2020-01-16
+- Fix bug in wapm related to the `package.wasmer_extra_flags` entry in the manifest
+
+## 0.13.0 - 2020-01-15
+
+Special thanks to [@repi](https://github.com/repi) and [@srenatus](https://github.com/srenatus) for their contributions!
+
+- [#1153](https://github.com/wasmerio/wasmer/pull/1153) Added Wasmex, an Elixir language integration, to the README
+- [#1133](https://github.com/wasmerio/wasmer/pull/1133) New `wasmer_trap` function in the C API, to properly error from within a host function
+- [#1147](https://github.com/wasmerio/wasmer/pull/1147) Remove `log` and `trace` macros from `wasmer-runtime-core`, remove `debug` and `trace` features from `wasmer-*` crates, use the `log` crate for logging and use `fern` in the Wasmer CLI binary to output log messages.  Colorized output will be enabled automatically if printing to a terminal, to force colorization on or off, set the `WASMER_COLOR` environment variable to `true` or `false`.
+- [#1128](https://github.com/wasmerio/wasmer/pull/1128) Fix a crash when a host function is missing and the `allow_missing_functions` flag is enabled
+- [#1099](https://github.com/wasmerio/wasmer/pull/1099) Remove `backend::Backend` from `wasmer_runtime_core`
+- [#1097](https://github.com/wasmerio/wasmer/pull/1097) Move inline breakpoint outside of runtime backend
+- [#1095](https://github.com/wasmerio/wasmer/pull/1095) Update to cranelift 0.52.
+- [#1092](https://github.com/wasmerio/wasmer/pull/1092) Add `get_utf8_string_with_nul` to `WasmPtr` to read nul-terminated strings from memory.
+- [#1071](https://github.com/wasmerio/wasmer/pull/1071) Add support for non-trapping float-to-int conversions, enabled by default.
+
+## 0.12.0 - 2019-12-18
+
+Special thanks to [@ethanfrey](https://github.com/ethanfrey), [@AdamSLevy](https://github.com/AdamSLevy), [@Jasper-Bekkers](https://github.com/Jasper-Bekkers), [@srenatus](https://github.com/srenatus) for their contributions!
+
+- [#1078](https://github.com/wasmerio/wasmer/pull/1078) Increase the maximum number of parameters `Func` can take
+- [#1062](https://github.com/wasmerio/wasmer/pull/1062) Expose some opt-in Emscripten functions to the C API
+- [#1032](https://github.com/wasmerio/wasmer/pull/1032) Change the signature of the Emscripten `abort` function to work with Emscripten 1.38.30
+- [#1060](https://github.com/wasmerio/wasmer/pull/1060) Test the capi with all the backends
+- [#1069](https://github.com/wasmerio/wasmer/pull/1069) Add function `get_memory_and_data` to `Ctx` to help prevent undefined behavior and mutable aliasing. It allows accessing memory while borrowing data mutably for the `Ctx` lifetime. This new function is now being used in `wasmer-wasi`.
+- [#1058](https://github.com/wasmerio/wasmer/pull/1058) Fix minor panic issue when `wasmer::compile_with` called with llvm backend.
+- [#858](https://github.com/wasmerio/wasmer/pull/858) Minor panic fix when wasmer binary with `loader` option run a module without exported `_start` function.
+- [#1056](https://github.com/wasmerio/wasmer/pull/1056) Improved `--invoke` args parsing (supporting `i32`, `i64`, `f32` and `f32`) in Wasmer CLI
+- [#1054](https://github.com/wasmerio/wasmer/pull/1054) Improve `--invoke` output in Wasmer CLI
+- [#1053](https://github.com/wasmerio/wasmer/pull/1053) For RuntimeError and breakpoints, use Box<Any + Send> instead of Box<Any>.
+- [#1052](https://github.com/wasmerio/wasmer/pull/1052) Fix minor panic and improve Error handling in singlepass backend.
+- [#1050](https://github.com/wasmerio/wasmer/pull/1050) Attach C & C++ headers to releases.
+- [#1033](https://github.com/wasmerio/wasmer/pull/1033) Set cranelift backend as default compiler backend again, require at least one backend to be enabled for Wasmer CLI
+- [#1044](https://github.com/wasmerio/wasmer/pull/1044) Enable AArch64 support in the LLVM backend.
+- [#1030](https://github.com/wasmerio/wasmer/pull/1030) Ability to generate `ImportObject` for a specific version WASI version with the C API.
+- [#1028](https://github.com/wasmerio/wasmer/pull/1028) Introduce strict/non-strict modes for `get_wasi_version`
+- [#1029](https://github.com/wasmerio/wasmer/pull/1029) Add the “floating” `WasiVersion::Latest` version.
+- [#1006](https://github.com/wasmerio/wasmer/pull/1006) Fix minor panic issue when `wasmer::compile_with` called with llvm backend
+- [#1009](https://github.com/wasmerio/wasmer/pull/1009) Enable LLVM verifier for all tests, add new llvm-backend-tests crate.
+- [#1022](https://github.com/wasmerio/wasmer/pull/1022) Add caching support for Singlepass backend.
+- [#1004](https://github.com/wasmerio/wasmer/pull/1004) Add the Auto backend to enable to adapt backend usage depending on wasm file executed.
+- [#1068](https://github.com/wasmerio/wasmer/pull/1068) Various cleanups for the singlepass backend on AArch64.
+
+## 0.11.0 - 2019-11-22
+
+- [#713](https://github.com/wasmerio/wasmer/pull/713) Add AArch64 support for singlepass.
+- [#995](https://github.com/wasmerio/wasmer/pull/995) Detect when a global is read without being initialized (emit a proper error instead of panicking)
+- [#996](https://github.com/wasmerio/wasmer/pull/997) Refactored spectests, emtests and wasitests to use default compiler logic
+- [#992](https://github.com/wasmerio/wasmer/pull/992) Updates WAPM version to 0.4.1, fix arguments issue introduced in #990
+- [#990](https://github.com/wasmerio/wasmer/pull/990) Default wasmer CLI to `run`.  Wasmer will now attempt to parse unrecognized command line options as if they were applied to the run command: `wasmer mywasm.wasm --dir=.` now works!
+- [#987](https://github.com/wasmerio/wasmer/pull/987) Fix `runtime-c-api` header files when compiled by gnuc.
+- [#957](https://github.com/wasmerio/wasmer/pull/957) Change the meaning of `wasmer_wasi::is_wasi_module` to detect any type of WASI module, add support for new wasi snapshot_preview1
+- [#934](https://github.com/wasmerio/wasmer/pull/934) Simplify float expressions in the LLVM backend.
+
+## 0.10.2 - 2019-11-18
+
+- [#968](https://github.com/wasmerio/wasmer/pull/968) Added `--invoke` option to the command
+- [#964](https://github.com/wasmerio/wasmer/pull/964) Enable cross-compilation for specific target
+- [#971](https://github.com/wasmerio/wasmer/pull/971) In LLVM backend, use unaligned loads and stores for non-atomic accesses to wasmer memory.
+- [#960](https://github.com/wasmerio/wasmer/pull/960) Fix `runtime-c-api` header files when compiled by clang.
+- [#925](https://github.com/wasmerio/wasmer/pull/925) Host functions can be closures with a captured environment.
+- [#917](https://github.com/wasmerio/wasmer/pull/917) Host functions (aka imported functions) may not have `&mut vm::Ctx` as first argument, i.e. the presence of the `&mut vm::Ctx` argument is optional.
+- [#915](https://github.com/wasmerio/wasmer/pull/915) All backends share the same definition of `Trampoline` (defined in `wasmer-runtime-core`).
+
+## 0.10.1 - 2019-11-11
+
+- [#952](https://github.com/wasmerio/wasmer/pull/952) Use C preprocessor to properly hide trampoline functions on Windows and non-x86_64 targets.
+
+## 0.10.0 - 2019-11-11
+
+Special thanks to [@newpavlov](https://github.com/newpavlov) and [@Maxgy](https://github.com/Maxgy) for their contributions!
+
+- [#942](https://github.com/wasmerio/wasmer/pull/942) Deny missing docs in runtime core and add missing docs
+- [#939](https://github.com/wasmerio/wasmer/pull/939) Fix bug causing attempts to append to files with WASI to delete the contents of the file
+- [#940](https://github.com/wasmerio/wasmer/pull/940) Update supported Rust version to 1.38+
+- [#923](https://github.com/wasmerio/wasmer/pull/923) Fix memory leak in the C API caused by an incorrect cast in `wasmer_trampoline_buffer_destroy`
+- [#921](https://github.com/wasmerio/wasmer/pull/921) In LLVM backend, annotate all memory accesses with TBAA metadata.
+- [#883](https://github.com/wasmerio/wasmer/pull/883) Allow floating point operations to have arbitrary inputs, even including SNaNs.
+- [#856](https://github.com/wasmerio/wasmer/pull/856) Expose methods in the runtime C API to get a WASI import object
+
+## 0.9.0 - 2019-10-23
+
+Special thanks to @alocquet for their contributions!
+
+- [#898](https://github.com/wasmerio/wasmer/pull/898) State tracking is now disabled by default in the LLVM backend. It can be enabled with `--track-state`.
+- [#861](https://github.com/wasmerio/wasmer/pull/861) Add descriptions to `unimplemented!` macro in various places
+- [#897](https://github.com/wasmerio/wasmer/pull/897) Removes special casing of stdin, stdout, and stderr in WASI.  Closing these files now works.  Removes `stdin`, `stdout`, and `stderr` from `WasiFS`, replaced by the methods `stdout`, `stdout_mut`, and so on.
+- [#863](https://github.com/wasmerio/wasmer/pull/863) Fix min and max for cases involving NaN and negative zero when using the LLVM backend.
+
+## 0.8.0 - 2019-10-02
+
+Special thanks to @jdanford for their contributions!
+
+- [#850](https://github.com/wasmerio/wasmer/pull/850) New `WasiStateBuilder` API. small, add misc. breaking changes to existing API (for example, changing the preopen dirs arg on `wasi::generate_import_object` from `Vec<String>` to `Vec<Pathbuf>`)
+- [#852](https://github.com/wasmerio/wasmer/pull/852) Make minor grammar/capitalization fixes to README.md
+- [#841](https://github.com/wasmerio/wasmer/pull/841) Slightly improve rustdoc documentation and small updates to outdated info in readme files
+- [#836](https://github.com/wasmerio/wasmer/pull/836) Update Cranelift fork version to `0.44.0`
+- [#839](https://github.com/wasmerio/wasmer/pull/839) Change supported version to stable Rust 1.37+
+- [#834](https://github.com/wasmerio/wasmer/pull/834) Fix panic when unwraping `wasmer` arguments
+- [#835](https://github.com/wasmerio/wasmer/pull/835) Add parallel execution example (independent instances created from the same `ImportObject` and `Module` run with rayon)
+- [#834](https://github.com/wasmerio/wasmer/pull/834) Fix panic when parsing numerical arguments for no-ABI targets run with the wasmer binary
+- [#833](https://github.com/wasmerio/wasmer/pull/833) Add doc example of using ImportObject's new `maybe_with_namespace` method
+- [#832](https://github.com/wasmerio/wasmer/pull/832) Delete unused runtime ABI
+- [#809](https://github.com/wasmerio/wasmer/pull/809) Fix bugs leading to panics in `LocalBacking`.
+- [#831](https://github.com/wasmerio/wasmer/pull/831) Add support for atomic operations, excluding wait and notify, to singlepass.
+- [#822](https://github.com/wasmerio/wasmer/pull/822) Update Cranelift fork version to `0.43.1`
+- [#829](https://github.com/wasmerio/wasmer/pull/829) Fix deps on `make bench-*` commands; benchmarks don't compile other backends now
+- [#807](https://github.com/wasmerio/wasmer/pull/807) Implement Send for `Instance`, breaking change on `ImportObject`, remove method `get_namespace` replaced with `with_namespace` and `maybe_with_namespace`
+- [#817](https://github.com/wasmerio/wasmer/pull/817) Add document for tracking features across backends and language integrations, [docs/feature_matrix.md]
+- [#823](https://github.com/wasmerio/wasmer/issues/823) Improved Emscripten / WASI integration
+- [#821](https://github.com/wasmerio/wasmer/issues/821) Remove patch version on most deps Cargo manifests.  This gives Wasmer library users more control over which versions of the deps they use.
+- [#820](https://github.com/wasmerio/wasmer/issues/820) Remove null-pointer checks in `WasmPtr` from runtime-core, re-add them in Emscripten
+- [#803](https://github.com/wasmerio/wasmer/issues/803) Add method to `Ctx` to invoke functions by their `TableIndex`
+- [#790](https://github.com/wasmerio/wasmer/pull/790) Fix flaky test failure with LLVM, switch to large code model.
+- [#788](https://github.com/wasmerio/wasmer/pull/788) Use union merge on the changelog file.
+- [#785](https://github.com/wasmerio/wasmer/pull/785) Include Apache license file for spectests.
+- [#786](https://github.com/wasmerio/wasmer/pull/786) In the LLVM backend, lower atomic wasm operations to atomic machine instructions.
+- [#784](https://github.com/wasmerio/wasmer/pull/784) Fix help string for wasmer run.
+
+## 0.7.0 - 2019-09-12
+
+Special thanks to @YaronWittenstein @penberg for their contributions.
+
+- [#776](https://github.com/wasmerio/wasmer/issues/776) Allow WASI preopened fds to be closed
+- [#774](https://github.com/wasmerio/wasmer/issues/774) Add more methods to the `WasiFile` trait
+- [#772](https://github.com/wasmerio/wasmer/issues/772) [#770](https://github.com/wasmerio/wasmer/issues/770) Handle more internal failures by passing back errors
+- [#756](https://github.com/wasmerio/wasmer/issues/756) Allow NULL parameter and 0 arity in `wasmer_export_func_call` C API
+- [#747](https://github.com/wasmerio/wasmer/issues/747) Return error instead of panicking on traps when using the Wasmer binary
+- [#741](https://github.com/wasmerio/wasmer/issues/741) Add validate Wasm fuzz target
+- [#733](https://github.com/wasmerio/wasmer/issues/733) Remove dependency on compiler backends for `middleware-common`
+- [#732](https://github.com/wasmerio/wasmer/issues/732) [#731](https://github.com/wasmerio/wasmer/issues/731) WASI bug fixes and improvements
+- [#726](https://github.com/wasmerio/wasmer/issues/726) Add serialization and deserialization for Wasi State
+- [#716](https://github.com/wasmerio/wasmer/issues/716) Improve portability of install script
+- [#714](https://github.com/wasmerio/wasmer/issues/714) Add Code of Conduct
+- [#708](https://github.com/wasmerio/wasmer/issues/708) Remove unconditional dependency on Cranelift in the C API
+- [#703](https://github.com/wasmerio/wasmer/issues/703) Fix compilation on AArch64 Linux
+- [#702](https://github.com/wasmerio/wasmer/issues/702) Add SharedMemory to Wasmer. Add `--enable-threads` flag, add partial implementation of atomics to LLVM backend.
+- [#698](https://github.com/wasmerio/wasmer/issues/698) [#690](https://github.com/wasmerio/wasmer/issues/690) [#687](https://github.com/wasmerio/wasmer/issues/690) Fix panics in Emscripten
+- [#689](https://github.com/wasmerio/wasmer/issues/689) Replace `wasmer_runtime_code::memory::Atomic` with `std::sync::atomic` atomics, changing its interface
+- [#680](https://github.com/wasmerio/wasmer/issues/680) [#673](https://github.com/wasmerio/wasmer/issues/673) [#669](https://github.com/wasmerio/wasmer/issues/669) [#660](https://github.com/wasmerio/wasmer/issues/660) [#659](https://github.com/wasmerio/wasmer/issues/659) Misc. runtime and singlepass fixes
+- [#677](https://github.com/wasmerio/wasmer/issues/677) [#675](https://github.com/wasmerio/wasmer/issues/675) [#674](https://github.com/wasmerio/wasmer/issues/674) LLVM backend fixes and improvements
+- [#671](https://github.com/wasmerio/wasmer/issues/671) Implement fs polling in `wasi::poll_oneoff` for Unix-like platforms
+- [#656](https://github.com/wasmerio/wasmer/issues/656) Move CI to Azure Pipelines
+- [#650](https://github.com/wasmerio/wasmer/issues/650) Implement `wasi::path_rename`, improve WASI FS public api, and allow open files to exist even when the underlying file is deleted
+- [#643](https://github.com/wasmerio/wasmer/issues/643) Implement `wasi::path_symlink` and improve WASI FS public api IO error reporting
+- [#608](https://github.com/wasmerio/wasmer/issues/608) Implement wasi syscalls `fd_allocate`, `fd_sync`, `fd_pread`, `path_link`, `path_filestat_set_times`; update WASI fs API in a WIP way; reduce coupling of WASI code to host filesystem; make debug messages from WASI more readable; improve rights-checking when calling syscalls; implement reference counting on inodes; misc bug fixes and improvements
+- [#616](https://github.com/wasmerio/wasmer/issues/616) Create the import object separately from instance instantiation in `runtime-c-api`
+- [#620](https://github.com/wasmerio/wasmer/issues/620) Replace one `throw()` with `noexcept` in llvm backend
+- [#618](https://github.com/wasmerio/wasmer/issues/618) Implement `InternalEvent::Breakpoint` in the llvm backend to allow metering in llvm
+- [#615](https://github.com/wasmerio/wasmer/issues/615) Eliminate `FunctionEnvironment` construction in `feed_event()` speeding up to 70% of compilation in clif
+- [#609](https://github.com/wasmerio/wasmer/issues/609) Update dependencies
+- [#602](https://github.com/wasmerio/wasmer/issues/602) C api extract instance context from instance
+- [#590](https://github.com/wasmerio/wasmer/issues/590) Error visibility changes in wasmer-c-api
+- [#589](https://github.com/wasmerio/wasmer/issues/589) Make `wasmer_byte_array` fields `public` in wasmer-c-api
+
+## 0.6.0 - 2019-07-31
+- [#603](https://github.com/wasmerio/wasmer/pull/603) Update Wapm-cli, bump version numbers
+- [#595](https://github.com/wasmerio/wasmer/pull/595) Add unstable public API for interfacing with the WASI file system in plugin-like usecases
+- [#598](https://github.com/wasmerio/wasmer/pull/598) LLVM Backend is now supported in Windows
+- [#599](https://github.com/wasmerio/wasmer/pull/599) Fix llvm backend failures in fat spec tests and simd_binaryen spec test.
+- [#579](https://github.com/wasmerio/wasmer/pull/579) Fix bug in caching with LLVM and Singlepass backends.
+  Add `default-backend-singlepass`, `default-backend-llvm`, and `default-backend-cranelift` features to `wasmer-runtime`
+  to control the `default_compiler()` function (this is a breaking change).  Add `compiler_for_backend` function in `wasmer-runtime`
+- [#561](https://github.com/wasmerio/wasmer/pull/561) Call the `data_finalizer` field on the `Ctx`
+- [#576](https://github.com/wasmerio/wasmer/pull/576) fix `Drop` of uninit `Ctx`
+- [#542](https://github.com/wasmerio/wasmer/pull/542) Add SIMD support to Wasmer (LLVM backend only)
+  - Updates LLVM to version 8.0
+
+## 0.5.7 - 2019-07-23
+- [#575](https://github.com/wasmerio/wasmer/pull/575) Prepare for release; update wapm to 0.3.6
+- [#555](https://github.com/wasmerio/wasmer/pull/555) WASI filesystem rewrite.  Major improvements
+  - adds virtual root showing all preopened directories
+  - improved sandboxing and code-reuse
+  - symlinks work in a lot more situations
+  - many misc. improvements to most syscalls touching the filesystem
+
+## 0.5.6 - 2019-07-16
+- [#565](https://github.com/wasmerio/wasmer/pull/565) Update wapm and bump version to 0.5.6
+- [#563](https://github.com/wasmerio/wasmer/pull/563) Improve wasi testing infrastructure
+  - fixes arg parsing from comments & fixes the mapdir test to have the native code doing the same thing as the WASI code
+  - makes wasitests-generate output stdout/stderr by default & adds function to print stdout and stderr for a command if it fails
+  - compiles wasm with size optimizations & strips generated wasm with wasm-strip
+- [#554](https://github.com/wasmerio/wasmer/pull/554) Finish implementation of `wasi::fd_seek`, fix bug in filestat
+- [#550](https://github.com/wasmerio/wasmer/pull/550) Fix singlepass compilation error with `imul` instruction
+
+
+## 0.5.5 - 2019-07-10
+- [#541](https://github.com/wasmerio/wasmer/pull/541) Fix dependency graph by making separate test crates; ABI implementations should not depend on compilers. Add Cranelift fork as git submodule of clif-backend
+- [#537](https://github.com/wasmerio/wasmer/pull/537) Add hidden flag (`--cache-key`) to use prehashed key into the compiled wasm cache and change compiler backend-specific caching to use directories
+- [#536](https://github.com/wasmerio/wasmer/pull/536) ~Update cache to use compiler backend name in cache key~
+
+## 0.5.4 - 2019-07-06
+- [#529](https://github.com/wasmerio/wasmer/pull/529) Updates the Wasm Interface library, which is used by wapm, with bug fixes and error message improvements
+
+## 0.5.3 - 2019-07-03
 - [#523](https://github.com/wasmerio/wasmer/pull/523) Update wapm version to fix bug related to signed packages in the global namespace and locally-stored public keys
 
 ## 0.5.2 - 2019-07-02
+- [#516](https://github.com/wasmerio/wasmer/pull/516) Add workaround for singlepass miscompilation on GetLocal
 - [#521](https://github.com/wasmerio/wasmer/pull/521) Update Wapm-cli, bump version numbers
 - [#518](https://github.com/wasmerio/wasmer/pull/518) Update Cranelift and WasmParser
 - [#514](https://github.com/wasmerio/wasmer/pull/514) [#519](https://github.com/wasmerio/wasmer/pull/519) Improved Emscripten network related calls, added a null check to `WasmPtr`
@@ -26,7 +293,7 @@ Blocks of changes will separated by version increments.
 - [#493](https://github.com/wasmerio/wasmer/pull/493) `wasmer_module_instantiate` has better error messages in the runtime C API
 - [#474](https://github.com/wasmerio/wasmer/pull/474) Set the install name of the dylib to `@rpath`
 - [#490](https://github.com/wasmerio/wasmer/pull/490) Add MiddlewareChain and StreamingCompiler to runtime
-- [#487](https://github.com/wasmerio/wasmer/pull/487) Fix stack offset check in singlepass backend 
+- [#487](https://github.com/wasmerio/wasmer/pull/487) Fix stack offset check in singlepass backend
 - [#450](https://github.com/wasmerio/wasmer/pull/450) Added Metering
 - [#481](https://github.com/wasmerio/wasmer/pull/481) Added context trampoline into runtime
 - [#484](https://github.com/wasmerio/wasmer/pull/484) Fix bugs in emscripten socket syscalls

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## 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, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, 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 project team at contact@wasmer.io. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project 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 project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,33 @@
+# How to Contribute to Wasmer
+
+Thank you for your interest in contributing to Wasmer. This document outlines some recommendations on how to contribute.
+
+## Issues & Feature Requests
+
+Please use the issue template and provide a failing example if possible to help us recreate the issue.
+
+## Pull Requests
+
+For large changes, please try reaching communicating with the Wasmer maintainers via GitHub Issues or Spectrum Chat to ensure we can accept the change once it is ready.
+
+We recommend trying the following commands before sending a pull request to ensure code quality:
+
+- `cargo fmt --all` Ensures all code is correctly formatted.
+- Run `cargo test` in the crates that you are modifying.
+- Run `cargo build --all` (nightly) or `cargo build --all --exclude wasmer-singlepass-backend`
+
+A comprehensive CI test suite will be run by a Wasmer team member after the PR has been created.
+
+### Common Build Issues
+
+#### LLVM Dependency
+
+`Didn't find usable system-wide LLVM`
+
+Building Wasmer with the LLVM backend requires LLVM to be installed
+
+#### Singlepass Nightly Only
+
+`error[E0554]: #![feature] may not be used on the stable release channel`
+
+Building Wasmer with the singlepass backend requires the nightly version of Rust

Cargo.toml

@@ -1,12 +1,13 @@
 [package]
-name = "wasmer"
-version = "0.5.3"
+name = "wasmer-bin"
+version = "0.17.0"
 authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
 edition = "2018"
 repository = "https://github.com/wasmerio/wasmer"
 publish = true
 description = "High-Performance WebAssembly JIT interpreter"
 license = "MIT"
+default-run = "wasmer"
 include = [
     "examples/**/*",
     "src/**/*",
@@ -17,34 +18,40 @@ include = [
     "/README.md",
     "rustfmt.toml"
 ]
+autoexamples = false
 
 [dependencies]
-byteorder = "1.3.1"
-errno = "0.2.4"
-structopt = "0.2.11"
-wabt = "0.7.2"
-hashbrown = "0.1.8"
-wasmer-clif-backend = { path = "lib/clif-backend" }
-wasmer-singlepass-backend = { path = "lib/singlepass-backend", optional = true }
+atty = "0.2"
+byteorder = "1.3"
+errno = "0.2"
+fern = { version = "0.5", features = ["colored"], optional = true }
+log = "0.4"
+structopt = "0.3"
+wabt = { version = "0.9.1", optional = true }
+wasmer = { path = "lib/api", default-features = false }
 wasmer-middleware-common = { path = "lib/middleware-common" }
-wasmer-runtime = { path = "lib/runtime" }
-# wasmer-runtime-abi = { path = "lib/runtime-abi", optional = true }
+wasmer-runtime = { path = "lib/runtime", default-features = false }
 wasmer-runtime-core = { path = "lib/runtime-core" }
-wasmer-emscripten = { path = "lib/emscripten" }
-wasmer-llvm-backend = { path = "lib/llvm-backend", optional = true }
-wasmer-wasi = { path = "lib/wasi", optional = true }
 wasmer-kernel-loader = { path = "lib/kernel-loader", optional = true }
-wasmer-dev-utils = { path = "lib/dev-utils", optional = true }
+
+# Backends
+wasmer-singlepass-backend = { path = "lib/singlepass-backend", optional = true }
+wasmer-clif-backend = { path = "lib/clif-backend", optional = true }
+wasmer-llvm-backend = { path = "lib/llvm-backend", optional = true }
+
+# Frontends
+wasmer-emscripten = { path = "lib/emscripten" }
+wasmer-wasi = { path = "lib/wasi", optional = true }
+wasmer-wasi-experimental-io-devices = { path = "lib/wasi-experimental-io-devices", optional = true }
 
 [workspace]
 members = [
+    "lib/api",
     "lib/clif-backend",
     "lib/singlepass-backend",
     "lib/runtime",
-    # "lib/runtime-abi",
     "lib/runtime-core",
     "lib/emscripten",
-    "lib/spectests",
     "lib/win-exception-handler",
     "lib/runtime-c-api",
     "lib/llvm-backend",
@@ -52,28 +59,74 @@ members = [
     "lib/middleware-common",
     "lib/kernel-loader",
     "lib/kernel-net",
-    "lib/dev-utils",
-    "examples/plugin-for-example"
+    "lib/wasi-experimental-io-devices",
+    "examples/parallel",
+    "examples/plugin-for-example",
+    "examples/parallel-guest",
+    "tests/test-generator",
+    "tests/generate-wasi-tests",
+    "tests/generate-emscripten-tests",
+    "tests/wast",
 ]
 
 [build-dependencies]
-wabt = "0.7.2"
-glob = "0.2.11"
-rustc_version = "0.2.3"
+anyhow = "1.0.19"
+generate-emscripten-tests = { path = "tests/generate-emscripten-tests" }
+generate-wasi-tests = { path = "tests/generate-wasi-tests" }
+test-generator = { path = "tests/test-generator" }
+glob = "0.3"
+rustc_version = "0.2"
+
+[dev-dependencies]
+anyhow = "1.0.19"
+wasmer-wast = { path = "tests/wast" }
+lazy_static = "1.4"
+# To allow parameterized tests
+test-case = "1.0.0"
+criterion = "0.3"
+glob = "0.3"
+libc = "0.2.60" # for `tests/dev-utils`'s Stdout capturing
+serde = { version = "1", features = ["derive"] } # used by the plugin example
+serde_json = "1"
+typetag = "0.1" # used by the plugin example
+wabt = "0.9.1"
 
 [features]
-default = ["fast-tests", "wasi"]
-"loader:kernel" = ["wasmer-kernel-loader"]
-debug = ["wasmer-runtime-core/debug"]
-trace = ["wasmer-runtime-core/trace"]
-extra-debug = ["wasmer-clif-backend/debug", "wasmer-runtime-core/debug"]
-# This feature will allow cargo test to run much faster
-fast-tests = []
-"backend:llvm" = ["wasmer-llvm-backend"]
-"backend:singlepass" = ["wasmer-singlepass-backend"]
+# Don't add the backend features in default, please add them on the Makefile
+# since we might want to autoconfigure them depending on the availability on the host.
+default = ["wasi", "wabt"]
+loader-kernel = ["wasmer-kernel-loader"]
+debug = ["fern", "log/max_level_debug", "log/release_max_level_debug"]
+trace = ["fern", "log/max_level_trace", "log/release_max_level_trace"]
+docs = ["wasmer-runtime/docs"]
+backend-cranelift = [
+    "wasmer-clif-backend",
+    "wasmer-clif-backend/generate-debug-information",
+    "wasmer-runtime-core/generate-debug-information",
+    "wasmer-runtime/cranelift",
+    "wasmer/cranelift",
+]
+backend-llvm = [
+    "wasmer-llvm-backend",
+    "wasmer-runtime/llvm",
+    "wasmer-runtime-core/generate-debug-information-no-export-symbols",
+    "wasmer/llvm",
+]
+backend-singlepass = [
+    "wasmer-singlepass-backend",
+    "wasmer-runtime/singlepass",
+    "wasmer/singlepass",
+]
 wasi = ["wasmer-wasi"]
-# vfs = ["wasmer-runtime-abi"]
+experimental-io-devices = ["wasmer-wasi-experimental-io-devices"]
+managed = ["backend-singlepass", "wasmer-runtime-core/managed"]
 
 [[example]]
 name = "plugin"
+required-features = ["wasi", "backend-cranelift"]
 crate-type = ["bin"]
+
+[[example]]
+name = "callback"
+crate-type = ["bin"]
+required-features = ["backend-cranelift"]

Dockerfile

@@ -1,25 +0,0 @@
-FROM circleci/rust:1.33.0-stretch as wasmer-build-env
-RUN sudo apt-get update && \
-  sudo apt-get install -y --no-install-recommends \
-  cmake \
-  && sudo rm -rf /var/lib/apt/lists/*
-RUN curl -SL https://releases.llvm.org/7.0.0/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz \
-    | tar -xJC /home/circleci
-ENV LLVM_SYS_70_PREFIX /home/circleci/clang+llvm-7.0.0-x86_64-linux-gnu-ubuntu-16.04/
-
-FROM wasmer-build-env AS wasmer-debug-env
-RUN sudo apt-get update && \
-  sudo apt-get install -y --no-install-recommends \
-  valgrind \
-  && sudo rm -rf /var/lib/apt/lists/*
-
-FROM wasmer-build-env AS wasmer-build
-WORKDIR /home/circleci/wasmer
-COPY . /home/circleci/wasmer
-RUN sudo chmod -R 777 .
-RUN cargo build --release
-
-FROM debian:stretch AS wasmer
-WORKDIR /root/
-COPY --from=wasmer-build /home/circleci/wasmer/target/release/wasmer .
-ENTRYPOINT ["./wasmer"]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Wasmer, Inc. and its affiliates.
+Copyright (c) 2019-present Wasmer, Inc. and its affiliates.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,111 +1,431 @@
-ifeq (test, $(firstword $(MAKECMDGOALS)))
-  runargs := $(wordlist 2, $(words $(MAKECMDGOALS)), $(MAKECMDGOALS))
-  $(eval $(runargs):;@true)
+.PHONY: spectests emtests clean build install lint precommit docs examples 
+
+# uname only works in *Unix like systems
+ifneq ($(OS), Windows_NT)
+  ARCH := $(shell uname -m)
+  UNAME_S := $(shell uname -s)
+else
+  # We can assume, if in windows it will likely be in x86_64
+  ARCH := x86_64
+  UNAME_S := 
 endif
 
-.PHONY: spectests emtests clean build install lint precommit
+backends :=
+
+# Singlepass is enabled
+RUST_VERSION := $(shell rustc -V)
+
+ifneq (, $(findstring nightly,$(RUST_VERSION)))
+  # Singlepass doesn't work yet on Windows
+  ifneq ($(OS), Windows_NT)
+    backends += singlepass
+  endif
+endif
+
+ifeq ($(ARCH), x86_64)
+  # In X64, Cranelift is enabled
+  backends += cranelift
+  # LLVM could be enabled if not in Windows
+  ifneq ($(OS), Windows_NT)
+    # Autodetect LLVM from llvm-config
+    ifneq (, $(shell which llvm-config))
+      LLVM_VERSION := $(shell llvm-config --version)
+      # If findstring is not empty, then it have found the value
+      ifneq (, $(findstring 8,$(LLVM_VERSION))$(findstring 9,$(LLVM_VERSION)))
+        backends += llvm
+      endif
+    else
+      ifneq (, $(shell which llvm-config-8))
+        backends += llvm
+      endif
+    endif
+  endif
+endif
+
+backends := $(filter-out ,$(backends))
+
+ifneq ($(OS), Windows_NT)
+  bold := $(shell tput bold)
+  green := $(shell tput setaf 2)
+  reset := $(shell tput sgr0)
+endif
+
+
+$(info Available backends: $(bold)$(green)${backends}$(reset))
+
+backend_features_spaced := $(foreach backend,$(backends),backend-$(backend))
+backend_features := --features "$(backend_features_spaced)"
+
+# $(info Cargo features ${backend_features})
+
+# Generate files
+generate-emtests:
+	WASM_EMSCRIPTEN_GENERATE_EMTESTS=1 cargo build --release \
+	&& echo "formatting" \
+	&& cargo fmt
+
+# To generate WASI tests you'll need to have the correct versions of the Rust nightly
+# toolchain installed, see `WasiVersion::get_compiler_toolchain` in
+# `tests/generate-wasi-tests/src/wasi_version.rs`
+#
+# or run `make wasitests-setup-toolchain` or `make wasitests-setup-toolchain-all`
+generate-wasitests: wasitests-setup
+	WASM_WASI_GENERATE_WASITESTS=1 cargo build --release -vv \
+	&& echo "formatting" \
+	&& cargo fmt
+
+generate-wasitests-all: wasitests-setup
+	WASI_TEST_GENERATE_ALL=1 WASM_WASI_GENERATE_WASITESTS=1 cargo build --release -vv \
+	&& echo "formatting" \
+	&& cargo fmt
+
+emtests-generate: generate-emtests
+wasitests-generate: generate-wasitests
+
+wasitests-setup-toolchain: wasitests-setup
+	WASM_WASI_SET_UP_TOOLCHAIN=1 cargo build --release -vv
+
+wasitests-setup-toolchain-all: wasitests-setup
+	WASI_TEST_GENERATE_ALL=1 WASM_WASI_SET_UP_TOOLCHAIN=1 cargo build --release -vv
+
+generate: generate-emtests generate-wasitests
+
+
+# Spectests
+spectests-singlepass:
+	cargo test singlepass::spec --release $(backend_features)
+
+spectests-cranelift:
+	cargo test cranelift::spec --release $(backend_features)
+
+spectests-llvm:
+	cargo test llvm::spec --release $(backend_features) -- --test-threads=1
 
-# This will re-generate the Rust test files based on spectests/*.wast
 spectests:
-	WASMER_RUNTIME_GENERATE_SPECTESTS=1 cargo build -p wasmer-runtime-core
+	cargo test spec --release $(backend_features) -- --test-threads=1
 
-emtests:
-	WASM_EMSCRIPTEN_GENERATE_EMTESTS=1 cargo build -p wasmer-emscripten
 
-wasitests:
-	WASM_WASI_GENERATE_WASITESTS=1 cargo build -p wasmer-wasi
+# Emscripten tests
+emtests-singlepass:
+	cargo test singlepass::emscripten --release $(backend_features)
 
-# clean:
-#     rm -rf artifacts
+emtests-cranelift:
+	cargo test cranelift::emscripten --release $(backend_features)
 
-build:
-	cargo build --features debug
+emtests-llvm:
+	cargo test llvm::emscripten --release $(backend_features) -- --test-threads=1
+
+emtests-all:
+	cargo test emscripten --release $(backend_features) -- --test-threads=1
+
+emtests: emtests-singlepass emtests-cranelift emtests-llvm
+
+
+# Middleware tests
+middleware-singlepass:
+	cargo test singlepass::middleware --release $(backend_features)
+
+middleware-cranelift:
+	cargo test cranelift::middleware --release $(backend_features)
+
+middleware-llvm:
+	cargo test llvm::middleware --release $(backend_features)
+
+middleware: middleware-singlepass middleware-cranelift middleware-llvm
+
+
+# Wasitests
+wasitests-setup:
+ifeq (,$(wildcard ./tests/wasi_test_resources/test_fs/temp))
+	rm -rf tests/wasi_test_resources/test_fs/temp
+endif
+	mkdir -p tests/wasi_test_resources/test_fs/temp
+
+wasitests-singlepass: wasitests-setup
+	cargo test singlepass::wasi --release $(backend_features)
+
+wasitests-cranelift: wasitests-setup
+	cargo test cranelift::wasi --release $(backend_features) -- --test-threads=1
+
+wasitests-llvm: wasitests-setup
+	cargo test llvm::wasi --release $(backend_features) -- --test-threads=1
+
+wasitests-all: wasitests-setup
+	cargo test wasi --release $(backend_features) -- --test-threads=1
+
+wasitests-unit: wasitests-setup
+	cargo test --manifest-path lib/wasi/Cargo.toml --release
+
+wasitests: wasitests-unit wasitests-singlepass wasitests-cranelift wasitests-llvm
+
+
+# Backends
+singlepass: wasitests-setup
+	cargo test -p wasmer-singlepass-backend --release
+	cargo test singlepass:: --release $(backend_features) -- --test-threads=1
+
+cranelift: wasitests-setup
+	cargo test -p wasmer-clif-backend --release
+	cargo test cranelift:: --release $(backend_features)
+
+llvm: wasitests-setup
+	cargo test -p wasmer-llvm-backend --release
+	cargo test llvm:: --release $(backend_features) -- --test-threads=1
+
+
+# All tests
+capi-singlepass:
+	cargo build --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features singlepass-backend,wasi
+
+capi-cranelift:
+	cargo build --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features cranelift-backend,wasi
+
+capi-llvm:
+	cargo build --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features llvm-backend,wasi
+
+capi-emscripten:
+	cargo build --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features singlepass-backend,emscripten
+
+# We use cranelift as the default backend for the capi for now
+capi: capi-cranelift
+
+test-capi-singlepass: capi-singlepass
+	cargo test --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features singlepass-backend,wasi
+
+test-capi-cranelift: capi-cranelift
+	cargo test --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features cranelift-backend,wasi
+
+test-capi-llvm: capi-llvm
+	cargo test --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features llvm-backend,wasi
+
+test-capi-emscripten: capi-emscripten
+	cargo test --manifest-path lib/runtime-c-api/Cargo.toml --release \
+		--no-default-features --features singlepass-backend,emscripten
+
+test-capi: test-capi-singlepass test-capi-cranelift test-capi-llvm test-capi-emscripten
+
+capi-test: test-capi
+
+test-rest:
+	cargo test --release -p wasmer-runtime
+	cargo test --release -p wasmer-runtime-core
+	cargo test --release -p wasmer-wasi-experimental-io-devices
+	cargo test --release -p wasmer-win-exception-handler
+	# This doesn't work in windows, commented for now
+	# cargo test --release -p wasmer-kernel-loader
+	# cargo test --release -p kernel-net
+
+test: $(backends) test-rest examples
+
+test-android:
+	ci/run-docker.sh x86_64-linux-android --manifest-path=lib/singlepass-backend/Cargo.toml
+	ci/run-docker.sh x86_64-linux-android runtime_core
+
+# Integration tests
+integration-tests: release-clif examples
+	echo "Running Integration Tests"
+	./tests/integration_tests/lua/test.sh
+	./tests/integration_tests/nginx/test.sh
+	./tests/integration_tests/cowsay/test.sh
+
+examples:
+	cargo build --release $(backend_features) --examples
+	test -f target/release/examples/callback && ./target/release/examples/callback || echo "skipping callback test"
+	test -f target/release/examples/plugin && ./target/release/examples/plugin || echo "skipping plugin test"
+
+# Utils
+lint:
+	cargo fmt --all -- --check
+
+precommit: lint test
+
+debug:
+	cargo build --release --features "debug trace"
 
 install:
 	cargo install --path .
 
-integration-tests: release
-	echo "Running Integration Tests"
-	./integration_tests/lua/test.sh
-	./integration_tests/nginx/test.sh
-	./integration_tests/cowsay/test.sh
+# Checks
+check-bench-singlepass:
+	cargo check --benches --all singlepass \
+	--exclude wasmer-clif-backend --exclude wasmer-llvm-backend --exclude wasmer-kernel-loader
+check-bench-clif:
+	cargo check --benches --all cranelift \
+	--exclude wasmer-singlepass-backend --exclude wasmer-llvm-backend --exclude wasmer-kernel-loader
+check-bench-llvm:
+	cargo check --benches --all llvm \
+	--exclude wasmer-singlepass-backend --exclude wasmer-clif-backend --exclude wasmer-kernel-loader
 
-lint:
-	cargo fmt --all -- --check
-	cargo +nightly-2019-05-20 clippy --all
+check-bench: check-bench-singlepass check-bench-llvm
 
-precommit: lint test
+check-kernel-net:
+	cargo check -p kernel-net --target=wasm32-wasi
 
-build-install:
+# checks that require a nightly version of Rust
+check-nightly: check-kernel-net
+
+# TODO: We wanted `--workspace --exclude wasmer-runtime`, but can't due
+# to https://github.com/rust-lang/cargo/issues/6745 .
+NOT_RUNTIME_CRATES = -p wasmer-clif-backend -p wasmer-singlepass-backend -p wasmer-middleware-common -p wasmer-runtime-core -p wasmer-emscripten -p wasmer-llvm-backend -p wasmer-wasi -p wasmer-kernel-loader
+RUNTIME_CHECK = cargo check --manifest-path lib/runtime/Cargo.toml --no-default-features
+check: check-bench
+	cargo check $(NOT_RUNTIME_CRATES)
+	cargo check --release $(NOT_RUNTIME_CRATES)
+	cargo check --all-features $(NOT_RUNTIME_CRATES)
+	cargo check --release --all-features $(NOT_RUNTIME_CRATES)
+	# wasmer-runtime doesn't work with all backends enabled at once.
+	#
+	# We test using manifest-path directly so as to disable the default.
+	# `--no-default-features` only disables the default features in the
+	# current package, not the package specified by `-p`. This is
+	# intentional.
+	#
+	# Test default features, test 'debug' feature only in non-release
+	# builds, test as many combined features as possible with each backend
+	# as default, and test a minimal set of features with only one backend
+	# at a time.
+	cargo check --manifest-path lib/runtime-core/Cargo.toml
+	cargo check --manifest-path lib/runtime/Cargo.toml
+	# Check some of the cases where deterministic execution could matter
+	cargo check --manifest-path lib/runtime/Cargo.toml --features "deterministic-execution"
+	cargo check --manifest-path lib/runtime/Cargo.toml --no-default-features \
+		--features=default-backend-singlepass,deterministic-execution
+	cargo check --manifest-path lib/runtime/Cargo.toml --no-default-features \
+		--features=default-backend-llvm,deterministic-execution
+	cargo check --release --manifest-path lib/runtime/Cargo.toml
+
+	$(RUNTIME_CHECK) \
+		--features=cranelift,cache,llvm,singlepass,default-backend-singlepass
+	$(RUNTIME_CHECK) --release \
+		--features=cranelift,cache,llvm,singlepass,default-backend-singlepass
+	$(RUNTIME_CHECK) \
+		--features=cranelift,cache,llvm,singlepass,default-backend-cranelift
+	$(RUNTIME_CHECK) --release \
+		--features=cranelift,cache,llvm,singlepass,default-backend-cranelift
+	$(RUNTIME_CHECK) \
+		--features=cranelift,cache,llvm,singlepass,default-backend-llvm
+	$(RUNTIME_CHECK) --release \
+		--features=cranelift,cache,llvm,singlepass,default-backend-llvm
+	$(RUNTIME_CHECK) \
+		--features=singlepass,default-backend-singlepass
+	$(RUNTIME_CHECK) --release \
+		--features=singlepass,default-backend-singlepass
+	$(RUNTIME_CHECK) \
+		--features=cranelift,default-backend-cranelift
+	$(RUNTIME_CHECK) --release \
+		--features=cranelift,default-backend-cranelift
+	$(RUNTIME_CHECK) \
+		--features=llvm,default-backend-llvm
+	$(RUNTIME_CHECK) --release \
+		--features=llvm,default-backend-llvm
+		--features=default-backend-singlepass,singlepass,cranelift,llvm,cache,deterministic-execution
+
+# Release
+release:
+	cargo build --release $(backend_features) --features experimental-io-devices,log/release_max_level_off
+
+# Release with musl target
+release-musl:
+	# backend-llvm is not included due to dependency on wabt.
+	# experimental-io-devices is not included due to missing x11-fb.
+	cargo build --release --target x86_64-unknown-linux-musl --features backend-singlepass,backend-cranelift,loader-kernel,log/release_max_level_off,wasi --no-default-features
+
+# This way of releasing is deprecated, since backends are now detected
+# automatically
+release-clif: release
+
+# This way of releasing is deprecated, since backends are now detected
+# automatically
+release-singlepass: release
+
+# This way of releasing is deprecated, since backends are now detected
+# automatically
+release-llvm: release
+
+bench-singlepass:
+# NOTE this will run some benchmarks using clif; TODO: fix this
+	cargo bench --all singlepass \
+	--exclude wasmer-clif-backend --exclude wasmer-llvm-backend --exclude wasmer-kernel-loader
+bench-clif:
+	cargo bench --all cranelift \
+	--exclude wasmer-singlepass-backend --exclude wasmer-llvm-backend --exclude wasmer-kernel-loader
+bench-llvm:
+# NOTE this will run some benchmarks using clif; TODO: fix this
+	cargo bench --all llvm \
+	--exclude wasmer-singlepass-backend --exclude wasmer-clif-backend --exclude wasmer-kernel-loader
+
+build-install-package:
+	# This command doesn't build the binary, just packages it
 	mkdir -p ./install/bin
 	cp ./wapm-cli/target/release/wapm ./install/bin/
 	cp ./target/release/wasmer ./install/bin/
-	tar -C ./install -zcvf wasmer.tar.gz bin/wapm bin/wasmer
+	# Create the wax binary as symlink to wapm
+	cd ./install/bin/ && ln -sf wapm wax && chmod +x wax
+	tar -C ./install -zcvf wasmer.tar.gz bin
+
+build-capi-package:
+	# This command doesn't build the C-API, just packages it
+	mkdir -p ./capi/
+	mkdir -p ./capi/include
+	mkdir -p ./capi/lib
+ifeq ($(OS), Windows_NT)
+	cp target/release/wasmer_runtime_c_api.dll ./capi/lib/wasmer.dll
+	cp target/release/wasmer_runtime_c_api.lib ./capi/lib/wasmer.lib
+else
+ifeq ($(UNAME_S), Darwin)
+	cp target/release/libwasmer_runtime_c_api.dylib ./capi/lib/libwasmer.dylib
+	cp target/release/libwasmer_runtime_c_api.a ./capi/lib/libwasmer.a
+	# Fix the rpath for the dylib
+	install_name_tool -id "@rpath/libwasmer.dylib" ./capi/lib/libwasmer.dylib
+else
+	cp target/release/libwasmer_runtime_c_api.so ./capi/lib/libwasmer.so
+	cp target/release/libwasmer_runtime_c_api.a ./capi/lib/libwasmer.a
+endif
+endif
+	find target/release/build -name 'wasmer.h*' -exec cp {} ./capi/include ';'
+	cp LICENSE ./capi/LICENSE
+	cp lib/runtime-c-api/doc/index.md ./capi/README.md
+	tar -C ./capi -zcvf wasmer-c-api.tar.gz lib include README.md LICENSE
+
+WAPM_VERSION = v0.5.0
+build-wapm:
+	git clone --branch $(WAPM_VERSION) https://github.com/wasmerio/wapm-cli.git
+	cargo build --release --manifest-path wapm-cli/Cargo.toml --features "telemetry update-notifications"
 
 # For installing the contents locally
 do-install:
 	tar -C ~/.wasmer -zxvf wasmer.tar.gz
 
-test:
-	# We use one thread so the emscripten stdouts doesn't collide
-	cargo test --all --exclude wasmer-runtime-c-api --exclude wasmer-emscripten --exclude wasmer-spectests --exclude wasmer-singlepass-backend --exclude wasmer-wasi --exclude wasmer-middleware-common -- $(runargs)
-	# cargo test --all --exclude wasmer-emscripten -- --test-threads=1 $(runargs)
-	cargo test --manifest-path lib/spectests/Cargo.toml --features clif
-	cargo test --manifest-path lib/middleware-common/Cargo.toml --features clif
-	@if [ ! -z "${CIRCLE_JOB}" ]; then rm -f /home/circleci/project/target/debug/deps/libcranelift_wasm* && rm -f /Users/distiller/project/target/debug/deps/libcranelift_wasm*; fi;
-	cargo test --manifest-path lib/spectests/Cargo.toml --features llvm
-	cargo test --manifest-path lib/runtime/Cargo.toml --features llvm
-	cargo test --manifest-path lib/middleware-common/Cargo.toml --features llvm
-	cargo build -p wasmer-runtime-c-api
-	cargo test -p wasmer-runtime-c-api -- --nocapture
-
-test-singlepass:
-	cargo test --manifest-path lib/spectests/Cargo.toml --features singlepass
-	cargo test --manifest-path lib/runtime/Cargo.toml --features singlepass
-	cargo test --manifest-path lib/middleware-common/Cargo.toml --features singlepass
-
-test-emscripten-llvm:
-	cargo test --manifest-path lib/emscripten/Cargo.toml --features llvm -- --test-threads=1 $(runargs)
-
-test-emscripten-clif:
-	cargo test --manifest-path lib/emscripten/Cargo.toml --features clif -- --test-threads=1 $(runargs)
-
-test-emscripten-singlepass:
-	cargo test --manifest-path lib/emscripten/Cargo.toml --features singlepass -- --test-threads=1 $(runargs)
-
-test-wasi-clif:
-	cargo test --manifest-path lib/wasi/Cargo.toml --features "clif" -- --test-threads=1 $(runargs)
-
-test-wasi-singlepass:
-	cargo test --manifest-path lib/wasi/Cargo.toml --features "singlepass" -- --test-threads=1 $(runargs)
-
-singlepass-debug-release:
-	cargo +nightly build --features backend:singlepass,debug --release
-
-singlepass-release:
-	cargo +nightly build --features backend:singlepass --release
-
-singlepass-build:
-	cargo +nightly build --features backend:singlepass,debug
-
-release:
-	# If you are in OS-X, you will need mingw-w64 for cross compiling to windows
-	# brew install mingw-w64
-	cargo build --release
-
-production-release:
-	cargo build --release --features backend:singlepass,backend:llvm,loader:kernel
-
-debug-release:
-	cargo build --release --features debug
-
-extra-debug-release:
-	cargo build --release --features extra-debug
-
 publish-release:
 	ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} -delete ${VERSION} ./artifacts/
 
 # cargo install cargo-deps
 # must install graphviz for `dot`
 dep-graph:
-	cargo deps --optional-deps --filter wasmer-wasi wasmer-kernel-loader wasmer-dev-utils wasmer-llvm-backend wasmer-emscripten wasmer-runtime-core wasmer-runtime wasmer-middleware-common wasmer-singlepass-backend wasmer-clif-backend wasmer --manifest-path Cargo.toml | dot -Tpng > wasmer_depgraph.png
+	cargo deps --optional-deps --filter wasmer-wasi wasmer-kernel-loader wasmer-llvm-backend wasmer-emscripten wasmer-runtime-core wasmer-runtime wasmer-middleware-common wasmer-singlepass-backend wasmer-clif-backend wasmer --manifest-path Cargo.toml | dot -Tpng > wasmer_depgraph.png
+
+docs-capi:
+	cd lib/runtime-c-api/ && doxygen doxyfile
+
+docs: docs-capi
+	cargo doc --release --features=backend-singlepass,backend-cranelift,backend-llvm,docs,wasi,managed --workspace --document-private-items --no-deps
+	mkdir -p api-docs
+	mkdir -p api-docs/c
+	cp -R target/doc api-docs/crates
+	cp -R lib/runtime-c-api/doc/html api-docs/c/runtime-c-api
+	echo '<!-- Build $(SOURCE_VERSION) --><meta http-equiv="refresh" content="0; url=rust/wasmer_runtime/index.html">' > api-docs/index.html
+	echo '<!-- Build $(SOURCE_VERSION) --><meta http-equiv="refresh" content="0; url=wasmer_runtime/index.html">' > api-docs/crates/index.html
+
+docs-publish:
+	git clone -b "gh-pages" --depth=1 https://wasmerbot:$(GITHUB_DOCS_TOKEN)@github.com/wasmerio/wasmer.git api-docs-repo
+	cp -R api-docs/* api-docs-repo/
+	cd api-docs-repo && git add index.html crates/* c/*
+	cd api-docs-repo && (git diff-index --quiet HEAD || git commit -m "Publishing GitHub Pages")
+	cd api-docs-repo && git push origin gh-pages

README.md

@@ -1,218 +1,128 @@
-<p align="center">
+
+<div align="center">
   <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
-    <img width="400" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/logo.png" alt="Wasmer logo">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
   </a>
-</p>
+  
+  <p>
+    <a href="https://dev.azure.com/wasmerio/wasmer/_build/latest?definitionId=3&branchName=master">
+      <img src="https://img.shields.io/azure-devops/build/wasmerio/wasmer/3.svg?style=flat-square" alt="Build Status">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square" alt="Slack channel">
+    </a> 
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square" alt="License">
+    </a>
+  </p>
 
-<p align="center">
-  <a href="https://circleci.com/gh/wasmerio/wasmer/">
-    <img src="https://img.shields.io/circleci/project/github/wasmerio/wasmer/master.svg" alt="Build Status">
-  </a>
-  <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
-    <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
-  </a>
-  <a href="https://spectrum.chat/wasmer">
-    <img src="https://withspectrum.github.io/badge/badge.svg" alt="Join the Wasmer Community">
-  </a>
-</p>
+  <h3>
+    <a href="https://wasmer.io/">Website</a>
+    <span> • </span>
+    <a href="https://docs.wasmer.io">Docs</a>
+    <span> • </span>
+    <a href="https://medium.com/wasmer/">Blog</a>
+    <span> • </span>
+    <a href="https://twitter.com/wasmerio">Twitter</a>
+    <span> • </span>
+    <a href="https://slack.wasmer.io/">Community Chat</a>
+  </h3>
 
-## Introduction
+</div>
 
-[Wasmer](https://wasmer.io/) is a standalone JIT WebAssembly runtime, aiming to be fully compatible with [WASI](https://github.com/WebAssembly/WASI) and [Emscripten](https://emscripten.org/).
+<br />
 
-Install Wasmer with:
+[Wasmer](https://wasmer.io/) is a standalone [WebAssembly](https://webassembly.org/) runtime:
+* **Universal**: Wasmer is available in *Linux, macOS and Windows* (for both Desktop and [ARM](https://medium.com/wasmer/running-webassembly-on-arm-7d365ed0e50c))
+* **Fast**: Wasmer aims to run WebAssembly at near-native speed
+* **Pluggable**: Wasmer can be used from almost **any programming language**
+* **Safe**: supporting [WASI](https://github.com/WebAssembly/WASI) and [Emscripten](https://emscripten.org/)
+
+It is used to run software fast, universally and safely: standalone applications and universal libraries.
+
+## Contents
+
+- [Quickstart](#quickstart)
+- [Language Integrations](#language-integrations)
+- [Contribute](#contribute)
+- [Community](#community)
+
+## Quickstart
+
+Get started with Wasmer:
+
+#### 1. Install Wasmer
 
 ```sh
 curl https://get.wasmer.io -sSfL | sh
 ```
+> Note: *Wasmer is also [available on Windows](https://github.com/wasmerio/wasmer/releases)*
 
-Wasmer runtime can also be embedded in different languages, so you can use WebAssembly anywhere ✨:
-
-* [🦀 **Rust**](https://github.com/wasmerio/wasmer-rust-example)
-* [**C/C++**](https://github.com/wasmerio/wasmer-c-api)
-* [**🐘 PHP**](https://github.com/wasmerio/php-ext-wasm)
-* [**🐍 Python**](https://github.com/wasmerio/python-ext-wasm)
-* [**💎 Ruby**](https://github.com/wasmerio/ruby-ext-wasm)
-* [**🐹 Go**](https://github.com/wasmerio/go-ext-wasm)
-
-### Usage
-
-Wasmer can execute both the standard binary format (`.wasm`) and the text
-format defined by the WebAssembly reference interpreter (`.wat`).
-
-Once installed, you will be able to run any WebAssembly files (_including Lua, PHP, SQLite and nginx!_):
+<details>
+  <summary><b>Alternative</b>: Install with Homebrew</summary>
+  <p>
 
 ```sh
-# Run Lua
-wasmer run examples/lua.wasm
-
-# Run PHP
-wasmer run examples/php.wasm
-
-# Run SQLite
-wasmer run examples/sqlite.wasm
-
-# Run nginx
-wasmer run examples/nginx/nginx.wasm -- -p examples/nginx -c nginx.conf
+brew install wasmer
 ```
 
-#### With WAPM
+</p>
+</details>
 
-Installing Wasmer through `wasmer.io` includes
-[wapm](https://github.com/wasmerio/wapm-cli), the WebAssembly package manager.
+#### 2. Use Wasmer
 
-Wapm allows you to easily download, run, and distribute WebAssembly binaries.
+Download a WASM file, and use it universally! You can start with QuickJS: [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)
 
-```sh
-# Install cowsay globally
-wapm install -g cowsay
-
-# Run cowsay
-wapm run cowsay "Hello, world!"
+```bash
+wasmer qjs.wasm
 ```
 
-For more information about wapm, check out the [website](https://www.wapm.io)
-and this [example program](https://github.com/wapm-packages/rust-wasi-example).
+#### 3. Next steps
 
-## Code Structure
+Here is what you can do next:
 
-Wasmer is structured into different directories:
+- [Use Wasmer from your Rust application](https://docs.wasmer.io/integrations/rust)
+- [Publish a Wasm package on WAPM](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [Read more about Wasmer](https://medium.com/wasmer/)
 
-- [`src`](./src): code related to the Wasmer executable itself
-- [`lib`](./lib): modularized libraries that Wasmer uses under the hood
-- [`examples`](./examples): some useful examples to getting started with Wasmer
 
-## Dependencies
+### Language Integrations
 
-Building Wasmer requires [rustup](https://rustup.rs/).
+Wasmer runtime can be used as a library embedded in different languages, so you can **use WebAssembly anywhere** 🎉
 
-To build on Windows, download and run [`rustup-init.exe`](https://win.rustup.rs/)
-then follow the onscreen instructions.
+| &nbsp; | Language | Docs | Author(s) | Maintenance | Release | Stars |
+|-|-|-|-|-|-|-|
+| ![Rust logo](./assets/languages/rust.svg) | [**Rust**](https://github.com/wasmerio/wasmer-rust-example) | [Docs](https://wasmerio.github.io/wasmer/crates/wasmer_runtime/) | Wasmer | actively developed | <a href="https://crates.io/crates/wasmer-runtime/" target="_blank">![last release](https://img.shields.io/crates/v/wasmer-runtime?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/wasmer?style=flat-square) |
+| ![C logo](./assets/languages/c.svg) | [**C/C++**](https://github.com/wasmerio/wasmer-c-api) | [Docs](https://wasmerio.github.io/wasmer/c/runtime-c-api/) | Wasmer | actively developed | <a href="https://github.com/wasmerio/wasmer-c-api/" target="_blank">![last release](https://img.shields.io/github/v/release/wasmerio/wasmer?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/wasmer?style=flat-square) |
+| ![Python logo](./assets/languages/python.svg) | [**Python**](https://github.com/wasmerio/python-ext-wasm) | [Docs](https://github.com/wasmerio/python-ext-wasm#api-of-the-wasmer-extensionmodule) | Wasmer | actively developed | <a href="https://pypi.org/project/wasmer/" target="_blank">![last release](https://img.shields.io/pypi/v/wasmer?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/python-ext-wasm?style=flat-square) |
+| ![Go logo](./assets/languages/go.svg) | [**Go**](https://github.com/wasmerio/go-ext-wasm) | [Docs](https://github.com/wasmerio/go-ext-wasm#basic-example-exported-function) | Wasmer | actively developed | <a href="https://github.com/wasmerio/go-ext-wasm" target="_blank">![last release](https://img.shields.io/github/v/release/wasmerio/go-ext-wasm?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/go-ext-wasm?style=flat-square) |
+| ![PHP logo](./assets/languages/php.svg) | [**PHP**](https://github.com/wasmerio/php-ext-wasm) | [Docs](https://wasmerio.github.io/php-ext-wasm/wasm/) | Wasmer | actively developed | <a href="https://pecl.php.net/package/wasm" target="_blank">![last release](https://img.shields.io/github/v/release/wasmerio/php-ext-wasm?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/php-ext-wasm?style=flat-square) |
+| ![Ruby logo](./assets/languages/ruby.svg) | [**Ruby**](https://github.com/wasmerio/ruby-ext-wasm) | [Docs](https://www.rubydoc.info/gems/wasmer/) | Wasmer | actively developed | <a href="https://rubygems.org/gems/wasmer" target="_blank">![last release](https://img.shields.io/gem/v/wasmer?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/ruby-ext-wasm?style=flat-square) |
+| ![Postgres logo](./assets/languages/postgres.svg) | [**Postgres**](https://github.com/wasmerio/postgres-ext-wasm) | |  Wasmer | actively developed | <a href="https://github.com/wasmerio/postgres-ext-wasm" target="_blank">![last release](https://img.shields.io/github/v/release/wasmerio/postgres-ext-wasm?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/postgres-ext-wasm?style=flat-square) |
+| ![JS Logo](./assets/languages/js.svg) | [**JavaScript**](https://github.com/wasmerio/wasmer-js) | [Docs](https://docs.wasmer.io/wasmer-js/wasmer-js) | Wasmer | actively developed | <a href="https://www.npmjs.com/package/@wasmer/wasi" target="_blank">![last release](https://img.shields.io/npm/v/@wasmer/wasi?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/wasmerio/wasmer-js?style=flat-square) |
+| ![C# logo](./assets/languages/csharp.svg) | [**C#/.Net**](https://github.com/migueldeicaza/WasmerSharp) | [Docs](https://migueldeicaza.github.io/WasmerSharp/) |[Miguel de Icaza](https://github.com/migueldeicaza) | actively developed | <a href="https://www.nuget.org/packages/WasmerSharp/" target="_blank">![last release](https://img.shields.io/nuget/v/WasmerSharp?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/migueldeicaza/WasmerSharp?style=flat-square) |
+| ![R logo](./assets/languages/r.svg) | [**R**](https://github.com/dirkschumacher/wasmr) | [Docs](https://github.com/dirkschumacher/wasmr#example) | [Dirk Schumacher](https://github.com/dirkschumacher) | actively developed | | ![number of Github stars](https://img.shields.io/github/stars/dirkschumacher/wasmr?style=flat-square) |
+| ![Elixir logo](./assets/languages/elixir.png) | [**Elixir**](https://github.com/tessi/wasmex) | [Docs](https://hexdocs.pm/wasmex/api-reference.html) | [Philipp Tessenow](https://github.com/tessi) | actively developed | <a href="https://hex.pm/packages/wasmex" target="_blank">![last release](https://img.shields.io/hexpm/v/wasmex?style=flat-square)</a> | ![number of Github stars](https://img.shields.io/github/stars/tessi/wasmex?style=flat-square) |
+| ❓ | [your language is missing?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) | | | | |
 
-To build on other systems, run:
 
-```sh
-curl https://sh.rustup.rs -sSf | sh
-```
+## Contribute
 
-### Other dependencies
+**We welcome any form of contribution, especially from new members of our community** 💜
 
-Please select your operating system:
+You can check how to build the Wasmer runtime in [our awesome docs](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)!
 
-- [macOS](#macos)
-- [Debian-based Linuxes](#debian-based-linuxes)
-- [FreeBSD](#freebsd)
-- [Microsoft Windows](#windows-msvc)
+### Testing
 
-#### macOS
+Test you want? The [Wasmer docs will show you how](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing).
 
-If you have [Homebrew](https://brew.sh/) installed:
+## Community
 
-```sh
-brew install cmake
-```
+Wasmer has an amazing community developers and contributors. Welcome, please join us! 👋
 
-Or, in case you have [MacPorts](https://www.macports.org/install.php):
+### Channels
 
-```sh
-sudo port install cmake
-```
-
-#### Debian-based Linuxes
-
-```sh
-sudo apt install cmake pkg-config libssl-dev
-```
-
-#### FreeBSD
-
-```sh
-pkg install cmake
-```
-
-#### Windows (MSVC)
-
-Windows support is _highly experimental_. Only simple Wasm programs may be run, and no syscalls are allowed. This means
-nginx and Lua do not work on Windows. See [this issue](https://github.com/wasmerio/wasmer/issues/176) regarding Emscripten syscall polyfills for Windows.
-
-1. Install [Visual Studio](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15)
-
-2. Install [Rust for Windows](https://win.rustup.rs)
-
-3. Install [Python for Windows](https://www.python.org/downloads/release/python-2714/). The Windows x86-64 MSI installer is fine.
-   Make sure to enable "Add python.exe to Path" during installation.
-
-4. Install [Git for Windows](https://git-scm.com/download/win). Allow it to add `git.exe` to your PATH (default
-   settings for the installer are fine).
-
-5. Install [CMake](https://cmake.org/download/). Ensure CMake is in your PATH.
-
-6. Install [LLVM 7.0](https://prereleases.llvm.org/win-snapshots/LLVM-7.0.0-r336178-win64.exe)
-
-## Building
-
-Wasmer is built with [Cargo](https://crates.io/), the Rust package manager.
-
-```sh
-# checkout code
-git clone https://github.com/wasmerio/wasmer.git
-cd wasmer
-
-# install tools
-# make sure that `python` is accessible.
-cargo install --path .
-```
-
-## Testing
-
-Thanks to [spec tests](https://github.com/wasmerio/wasmer/tree/master/lib/spectests/spectests) we can ensure 100% compatibility with the WebAssembly spec test suite.
-
-Tests can be run with:
-
-```sh
-make test
-```
-
-If you need to regenerate the Rust tests from the spec tests
-you can run:
-
-```sh
-make spectests
-```
-
-You can also run integration tests with:
-
-```sh
-make integration-tests
-```
-
-## Benchmarking
-
-Benchmarks can be run with:
-
-```sh
-cargo bench --all
-```
-
-## Roadmap
-
-Wasmer is an open project guided by strong principles, aiming to be modular, flexible and fast. It is open to the community to help set its direction.
-
-Below are some of the goals of this project (in order of priority):
-
-- [x] It should be 100% compatible with the [WebAssembly spec tests](https://github.com/wasmerio/wasmer/tree/master/lib/spectests/spectests)
-- [x] It should be fast _(partially achieved)_
-- [x] Support WASI - released in [0.3.0](https://github.com/wasmerio/wasmer/releases/tag/0.3.0)
-- [ ] Support Emscripten calls _(in the works)_
-- [ ] Support Rust ABI calls
-- [ ] Support Go ABI calls
-
-## Architecture
-
-If you would like to know how Wasmer works under the hood, please see [ARCHITECTURE.md](./ARCHITECTURE.md).
-
-## License
-
-Wasmer is primarily distributed under the terms of the [MIT license](http://opensource.org/licenses/MIT) ([LICENSE](./LICENSE)).
-
-[ATTRIBUTIONS](./ATTRIBUTIONS.md)
+- [Slack](https://slack.wasmer.io/)
+- [Twitter](https://twitter.com/wasmerio)
+- [Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)

assets/languages/c.svg

@@ -0,0 +1 @@
+<svg width="20" height="22" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 22"><defs><style>.cls-1{fill:#7f8b99;}.cls-2{fill:#a9b9cb;}.cls-3{fill:#fff;}</style></defs><title>c-logo-colored</title><path class="cls-1" d="M1,17.22l2.19,1.24L16.79,3.54,11,.26a2,2,0,0,0-2,0L1,4.78A2,2,0,0,0,0,6.52v9A2,2,0,0,0,1,17.22Z"/><path class="cls-2" d="M19,4.78,16.79,3.54,3.21,18.46,9,21.74a2,2,0,0,0,2,0l8-4.52a2,2,0,0,0,1-1.74v-9A2,2,0,0,0,19,4.78Z"/><path class="cls-3" d="M12.07,9.58l3.11,0A4.84,4.84,0,0,0,10.1,5.25,5.42,5.42,0,0,0,4.48,11a5.31,5.31,0,0,0,5.62,5.66c4,0,4.94-2.86,4.94-4.38h-3a1.73,1.73,0,0,1-2,1.75c-1.91,0-2.22-2.27-2.22-3,0-1.18.42-3,2.22-3A1.86,1.86,0,0,1,12.07,9.58Z"/></svg>

assets/languages/cpp.svg

@@ -0,0 +1 @@
+<svg width="20" height="22" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 22"><defs><style>.cls-1{fill:#659ad2;}.cls-2{fill:#0e4580;}.cls-3{fill:#035a9d;}.cls-4{fill:#fff;}</style></defs><title>c++-logo-colored</title><path class="cls-1" d="M19.72,5.5A2,2,0,0,0,19,4.77L11,.25a2,2,0,0,0-2,0L1,4.77A2,2,0,0,0,0,6.52v9a2,2,0,0,0,.28,1Z"/><path class="cls-2" d="M.28,16.5a2,2,0,0,0,.74.73l8,4.52a2,2,0,0,0,2,0l8-4.52a2,2,0,0,0,.74-.73L10,11Z"/><path class="cls-3" d="M20,6.52a2,2,0,0,0-.28-1L10,11l9.72,5.5a2,2,0,0,0,.28-1Z"/><path class="cls-4" d="M16.67,10.69h-.74V10h-.75v.73h-.74v.73h.74v.72h.75v-.72h.74Z"/><path class="cls-4" d="M19.44,10.69H18.7V10H18v.73h-.74v.73H18v.72h.74v-.72h.74Z"/><path class="cls-4" d="M12.86,12.62a3.3,3.3,0,1,1,0-3.24l2.8-1.58a6.5,6.5,0,1,0,0,6.4Z"/></svg>

assets/languages/csharp.svg

@@ -0,0 +1 @@
+<svg width="20" height="20" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><defs><style>.cls-1{fill:#0c9438;}.cls-2{fill:#219e38;opacity:0.85;}.cls-3{opacity:0.1;isolation:isolate;}.cls-4{fill:#fff;}</style></defs><title>csharp-logo-colored</title><path class="cls-1" d="M17.07,2.93a10,10,0,0,0-14.14,0L17.07,17.07A10,10,0,0,0,17.07,2.93Z"/><path class="cls-2" d="M2.93,2.93A10,10,0,0,0,17.07,17.07Z"/><path class="cls-3" d="M1,10.23a.76.76,0,0,1,0-.15c0,.15,0,.3,0,.45Z"/><path class="cls-4" d="M9.51,13.64a4.6,4.6,0,0,1-2.19.46,3.46,3.46,0,0,1-1.46-.25A3.66,3.66,0,0,1,4.63,13a4.05,4.05,0,0,1-1-2.84,4.34,4.34,0,0,1,.26-1.64,4.2,4.2,0,0,1,.88-1.41,4,4,0,0,1,1.32-.94A3.81,3.81,0,0,1,7.65,6a4.42,4.42,0,0,1,1.84.25v1A3.72,3.72,0,0,0,7.64,6.8,2.9,2.9,0,0,0,6.44,7a2.81,2.81,0,0,0-1,.69,3.4,3.4,0,0,0-.85,2.42,3.24,3.24,0,0,0,.79,2.29,2.68,2.68,0,0,0,.94.66,2.9,2.9,0,0,0,1.13.2,4,4,0,0,0,2.05-.53Z"/><path class="cls-4" d="M16.49,8.3l-.13.58H14.93l-.35,1.65h1.55l-.15.58H14.47L14,13.3h-.69l.47-2.19H12.39l-.46,2.19h-.68l.46-2.19H10.26l.11-.58h1.46l.33-1.65H10.64l.12-.58h1.52l.46-2.21h.69L13,8.3l1.38,0,.47-2.17h.66L15.05,8.3Zm-2.24.58H12.86l-.36,1.65h1.4Z"/></svg>

assets/languages/go.svg

@@ -0,0 +1 @@
+<svg width="32" height="12" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 12"><defs><style>.cls-1{fill:#38b6ac;}</style></defs><title>go-logo-colored</title><path class="cls-1" d="M2.4,3.62s-.07,0,0-.09l.33-.42A.25.25,0,0,1,2.86,3H8.43c.05,0,.08,0,0,.09l-.25.4a.24.24,0,0,1-.17.09Z"/><path class="cls-1" d="M.06,5.06C0,5.06,0,5,0,5l.32-.42a.3.3,0,0,1,.17-.08H7.62a.08.08,0,0,1,.08.1L7.57,5a.15.15,0,0,1-.14.1Z"/><path class="cls-1" d="M3.84,6.49c-.06,0-.09,0-.06-.09L4,6a.2.2,0,0,1,.16-.09H7.28A.09.09,0,0,1,7.37,6l0,.37a.13.13,0,0,1-.12.11Z"/><path class="cls-1" d="M31.94,4.55a4.86,4.86,0,0,0-2.2-3.49A5.72,5.72,0,0,0,25.31.25,6.56,6.56,0,0,0,21,2.87a6.74,6.74,0,0,0-1.08,2.05h-5a.43.43,0,0,0-.38.25c-.22.41-.6,1.24-.8,1.71-.11.27,0,.47.29.47h3c-.16.22-.28.41-.43.58a2.88,2.88,0,0,1-2.65,1A2.45,2.45,0,0,1,11.8,6.49a3.36,3.36,0,0,1,1.6-3,2.69,2.69,0,0,1,2.81-.23,2,2,0,0,1,.73.6c.2.23.22.21.45.15,1-.25,1.64-.45,2.62-.69.18,0,.24-.12.18-.25A5,5,0,0,0,18.39.87,5.48,5.48,0,0,0,14.26.11,6.88,6.88,0,0,0,9.9,2.82,6.12,6.12,0,0,0,8.58,7.41a4.93,4.93,0,0,0,2,3.47,5.49,5.49,0,0,0,4.18,1,6.45,6.45,0,0,0,4.44-2.66,6.88,6.88,0,0,0,.64-1.07,5,5,0,0,0,1.54,2.43A5.77,5.77,0,0,0,25.16,12c.41-.05.78-.06,1.19-.14a7.21,7.21,0,0,0,3.79-2A6.07,6.07,0,0,0,31.94,4.55Zm-5,4.1a2.83,2.83,0,0,1-2.55.09,2.58,2.58,0,0,1-1.42-2.95,3.37,3.37,0,0,1,2.72-2.73,2.58,2.58,0,0,1,3.18,2.09c0,.16,0,.32.05.52A3.44,3.44,0,0,1,26.9,8.65Z"/></svg>

assets/languages/js.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<svg width="20" height="20" viewBox="0 0 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
+    <g>
+        <path d="M0,0 L256,0 L256,256 L0,256 L0,0 Z" fill="#F7DF1E"></path>
+        <path d="M67.311746,213.932292 L86.902654,202.076241 C90.6821079,208.777346 94.1202286,214.447137 102.367086,214.447137 C110.272203,214.447137 115.256076,211.354819 115.256076,199.326883 L115.256076,117.528787 L139.313575,117.528787 L139.313575,199.666997 C139.313575,224.58433 124.707759,235.925943 103.3984,235.925943 C84.1532952,235.925943 72.9819429,225.958603 67.3113397,213.93026" fill="#000000"></path>
+        <path d="M152.380952,211.354413 L171.969422,200.0128 C177.125994,208.433981 183.827911,214.619835 195.684368,214.619835 C205.652521,214.619835 212.009041,209.635962 212.009041,202.762159 C212.009041,194.513676 205.479416,191.592025 194.481168,186.78207 L188.468419,184.202565 C171.111213,176.81473 159.597308,167.53534 159.597308,147.944838 C159.597308,129.901308 173.344508,116.153295 194.825752,116.153295 C210.119924,116.153295 221.117765,121.48094 229.021663,135.400432 L210.29059,147.428775 C206.166146,140.040127 201.699556,137.119289 194.826159,137.119289 C187.78047,137.119289 183.312254,141.587098 183.312254,147.428775 C183.312254,154.646349 187.78047,157.568406 198.089956,162.036622 L204.103924,164.614095 C224.553448,173.378641 236.067352,182.313448 236.067352,202.418387 C236.067352,224.071924 219.055137,235.927975 196.200432,235.927975 C173.860978,235.927975 159.425829,225.274311 152.381359,211.354413" fill="#000000"></path>
+    </g>
+</svg>

assets/languages/php.svg

@@ -0,0 +1 @@
+<svg width="27" height="14" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 27 14"><title>php-logo</title><path d="M2.14,2.94h4A3.05,3.05,0,0,1,8.69,4a3.59,3.59,0,0,1,.53,2.82,5.59,5.59,0,0,1-.47,1.61,4.6,4.6,0,0,1-1,1.42,3.31,3.31,0,0,1-1.6,1,6.9,6.9,0,0,1-1.76.22H2.64L2.08,14H0ZM3.88,4.7,3,9.33h.39a7.55,7.55,0,0,0,2.39-.29c.63-.22,1.06-1,1.28-2.25.18-1.08,0-1.7-.54-1.87a6.6,6.6,0,0,0-2-.23l-.35,0H3.87Z"/><path d="M11.59,0h2.06l-.59,2.94h1.86a3.72,3.72,0,0,1,2.27.65c.51.41.66,1.19.45,2.35l-1,5.13h-2.1l1-4.9a1.44,1.44,0,0,0-.09-1.1,1.26,1.26,0,0,0-1-.32l-1.66,0L11.5,11.07H9.43Z"/><path d="M19.85,2.94h4A3.08,3.08,0,0,1,26.41,4a3.59,3.59,0,0,1,.52,2.82,5.56,5.56,0,0,1-.46,1.61,4.81,4.81,0,0,1-1,1.42,3.31,3.31,0,0,1-1.6,1,6.79,6.79,0,0,1-1.76.22H20.36L19.79,14H17.71ZM21.6,4.7l-.9,4.63h.39a7.51,7.51,0,0,0,2.39-.29q1-.33,1.29-2.25c.17-1.08,0-1.7-.54-1.87a6.67,6.67,0,0,0-2-.23l-.34,0h-.32Z"/></svg>

assets/languages/postgres.svg

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+
+<svg width="21px" height="22px" viewBox="0 0 432.071 445.383" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+<g id="orginal" style="fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	</g>
+<g id="Layer_x0020_3" style="fill-rule:nonzero;clip-rule:nonzero;fill:none;stroke:#FFFFFF;stroke-width:12.4651;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;">
+<path style="fill:#000000;stroke:#000000;stroke-width:37.3953;stroke-linecap:butt;stroke-linejoin:miter;" d="M323.205,324.227c2.833-23.601,1.984-27.062,19.563-23.239l4.463,0.392c13.517,0.615,31.199-2.174,41.587-7c22.362-10.376,35.622-27.7,13.572-23.148c-50.297,10.376-53.755-6.655-53.755-6.655c53.111-78.803,75.313-178.836,56.149-203.322    C352.514-5.534,262.036,26.049,260.522,26.869l-0.482,0.089c-9.938-2.062-21.06-3.294-33.554-3.496c-22.761-0.374-40.032,5.967-53.133,15.904c0,0-161.408-66.498-153.899,83.628c1.597,31.936,45.777,241.655,98.47,178.31    c19.259-23.163,37.871-42.748,37.871-42.748c9.242,6.14,20.307,9.272,31.912,8.147l0.897-0.765c-0.281,2.876-0.157,5.689,0.359,9.019c-13.572,15.167-9.584,17.83-36.723,23.416c-27.457,5.659-11.326,15.734-0.797,18.367c12.768,3.193,42.305,7.716,62.268-20.224    l-0.795,3.188c5.325,4.26,4.965,30.619,5.72,49.452c0.756,18.834,2.017,36.409,5.856,46.771c3.839,10.36,8.369,37.05,44.036,29.406c29.809-6.388,52.6-15.582,54.677-101.107"/>
+<path style="fill:#336791;stroke:none;" d="M402.395,271.23c-50.302,10.376-53.76-6.655-53.76-6.655c53.111-78.808,75.313-178.843,56.153-203.326c-52.27-66.785-142.752-35.2-144.262-34.38l-0.486,0.087c-9.938-2.063-21.06-3.292-33.56-3.496c-22.761-0.373-40.026,5.967-53.127,15.902    c0,0-161.411-66.495-153.904,83.63c1.597,31.938,45.776,241.657,98.471,178.312c19.26-23.163,37.869-42.748,37.869-42.748c9.243,6.14,20.308,9.272,31.908,8.147l0.901-0.765c-0.28,2.876-0.152,5.689,0.361,9.019c-13.575,15.167-9.586,17.83-36.723,23.416    c-27.459,5.659-11.328,15.734-0.796,18.367c12.768,3.193,42.307,7.716,62.266-20.224l-0.796,3.188c5.319,4.26,9.054,27.711,8.428,48.969c-0.626,21.259-1.044,35.854,3.147,47.254c4.191,11.4,8.368,37.05,44.042,29.406c29.809-6.388,45.256-22.942,47.405-50.555    c1.525-19.631,4.976-16.729,5.194-34.28l2.768-8.309c3.192-26.611,0.507-35.196,18.872-31.203l4.463,0.392c13.517,0.615,31.208-2.174,41.591-7c22.358-10.376,35.618-27.7,13.573-23.148z"/>
+<path d="M215.866,286.484c-1.385,49.516,0.348,99.377,5.193,111.495c4.848,12.118,15.223,35.688,50.9,28.045c29.806-6.39,40.651-18.756,45.357-46.051c3.466-20.082,10.148-75.854,11.005-87.281"/>
+<path d="M173.104,38.256c0,0-161.521-66.016-154.012,84.109c1.597,31.938,45.779,241.664,98.473,178.316c19.256-23.166,36.671-41.335,36.671-41.335"/>
+<path d="M260.349,26.207c-5.591,1.753,89.848-34.889,144.087,34.417c19.159,24.484-3.043,124.519-56.153,203.329"/>
+<path style="stroke-linejoin:bevel;" d="M348.282,263.953c0,0,3.461,17.036,53.764,6.653c22.04-4.552,8.776,12.774-13.577,23.155c-18.345,8.514-59.474,10.696-60.146-1.069c-1.729-30.355,21.647-21.133,19.96-28.739c-1.525-6.85-11.979-13.573-18.894-30.338    c-6.037-14.633-82.796-126.849,21.287-110.183c3.813-0.789-27.146-99.002-124.553-100.599c-97.385-1.597-94.19,119.762-94.19,119.762"/>
+<path d="M188.604,274.334c-13.577,15.166-9.584,17.829-36.723,23.417c-27.459,5.66-11.326,15.733-0.797,18.365c12.768,3.195,42.307,7.718,62.266-20.229c6.078-8.509-0.036-22.086-8.385-25.547c-4.034-1.671-9.428-3.765-16.361,3.994z"/>
+<path d="M187.715,274.069c-1.368-8.917,2.93-19.528,7.536-31.942c6.922-18.626,22.893-37.255,10.117-96.339c-9.523-44.029-73.396-9.163-73.436-3.193c-0.039,5.968,2.889,30.26-1.067,58.548c-5.162,36.913,23.488,68.132,56.479,64.938"/>
+<path style="fill:#FFFFFF;stroke-width:4.155;stroke-linecap:butt;stroke-linejoin:miter;" d="M172.517,141.7c-0.288,2.039,3.733,7.48,8.976,8.207c5.234,0.73,9.714-3.522,9.998-5.559c0.284-2.039-3.732-4.285-8.977-5.015c-5.237-0.731-9.719,0.333-9.996,2.367z"/>
+<path style="fill:#FFFFFF;stroke-width:2.0775;stroke-linecap:butt;stroke-linejoin:miter;" d="M331.941,137.543c0.284,2.039-3.732,7.48-8.976,8.207c-5.238,0.73-9.718-3.522-10.005-5.559c-0.277-2.039,3.74-4.285,8.979-5.015c5.239-0.73,9.718,0.333,10.002,2.368z"/>
+<path d="M350.676,123.432c0.863,15.994-3.445,26.888-3.988,43.914c-0.804,24.748,11.799,53.074-7.191,81.435"/>
+<path style="stroke-width:3;" d="M0,60.232"/>
+</g>
+</svg>

assets/languages/python.svg

@@ -0,0 +1 @@
+<svg width="20" height="20" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><defs><style>.cls-1{fill:#387ab0;}.cls-2{fill:#feca3d;}</style></defs><title>python-logo-colored</title><path class="cls-1" d="M9.93,0C4.87,0,5.18,2.21,5.18,2.21V4.5H10v.7H3.25S0,4.82,0,10s2.84,5,2.84,5H4.53V12.56A2.71,2.71,0,0,1,7.32,9.7h4.79A2.58,2.58,0,0,0,14.8,7.08V2.67S15.23,0,9.93,0ZM7.26,1.53a.88.88,0,1,1-.87.88A.88.88,0,0,1,7.26,1.53Z"/><path class="cls-2" d="M10.07,20c5.06,0,4.75-2.21,4.75-2.21V15.5H10v-.7h6.76S20,15.18,20,10s-2.84-5-2.84-5H15.47V7.44a2.71,2.71,0,0,1-2.79,2.86H7.89A2.58,2.58,0,0,0,5.2,12.92v4.41S4.77,20,10.07,20Zm2.67-1.53a.88.88,0,1,1,.87-.88A.88.88,0,0,1,12.74,18.47Z"/></svg>

assets/languages/r.svg

@@ -0,0 +1,14 @@
+<svg width="24" height="18" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid" viewBox="0 0 724 561">
+  <defs>
+    <linearGradient id="gradientFill-1" x1="0" x2="1" y1="0" y2="1" gradientUnits="objectBoundingBox" spreadMethod="pad">
+      <stop offset="0" stop-color="rgb(203,206,208)" stop-opacity="1"/>
+      <stop offset="1" stop-color="rgb(132,131,139)" stop-opacity="1"/>
+    </linearGradient>
+    <linearGradient id="gradientFill-2" x1="0" x2="1" y1="0" y2="1" gradientUnits="objectBoundingBox" spreadMethod="pad">
+      <stop offset="0" stop-color="rgb(39,109,195)" stop-opacity="1"/>
+      <stop offset="1" stop-color="rgb(22,92,170)" stop-opacity="1"/>
+    </linearGradient>
+  </defs>
+  <path d="M361.453,485.937 C162.329,485.937 0.906,377.828 0.906,244.469 C0.906,111.109 162.329,3.000 361.453,3.000 C560.578,3.000 722.000,111.109 722.000,244.469 C722.000,377.828 560.578,485.937 361.453,485.937 ZM416.641,97.406 C265.289,97.406 142.594,171.314 142.594,262.484 C142.594,353.654 265.289,427.562 416.641,427.562 C567.992,427.562 679.687,377.033 679.687,262.484 C679.687,147.971 567.992,97.406 416.641,97.406 Z" fill="url(#gradientFill-1)" fill-rule="evenodd"/>
+  <path d="M550.000,377.000 C550.000,377.000 571.822,383.585 584.500,390.000 C588.899,392.226 596.510,396.668 602.000,402.500 C607.378,408.212 610.000,414.000 610.000,414.000 L696.000,559.000 L557.000,559.062 L492.000,437.000 C492.000,437.000 478.690,414.131 470.500,407.500 C463.668,401.969 460.755,400.000 454.000,400.000 C449.298,400.000 420.974,400.000 420.974,400.000 L421.000,558.974 L298.000,559.026 L298.000,152.938 L545.000,152.938 C545.000,152.938 657.500,154.967 657.500,262.000 C657.500,369.033 550.000,377.000 550.000,377.000 ZM496.500,241.024 L422.037,240.976 L422.000,310.026 L496.500,310.002 C496.500,310.002 531.000,309.895 531.000,274.877 C531.000,239.155 496.500,241.024 496.500,241.024 Z" fill="url(#gradientFill-2)" fill-rule="evenodd"/>
+</svg>

assets/languages/ruby.svg

@@ -0,0 +1 @@
+<svg width="20" height="20" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><defs><style>.cls-1{fill:#b11917;}</style></defs><title>ruby-logo-colored</title><path class="cls-1" d="M2,12.84l-.42-1C1.21,11,.86,10.15.51,9.3a.08.08,0,0,1,0-.1C1.23,8,2,6.73,2.67,5.49a.61.61,0,0,1,.12-.16l3.9-3.65a.74.74,0,0,1,.21-.13L10.2.33a.11.11,0,0,1,.1,0l2.77,2s0,0,0,.09c-.47,1.48-.93,3-1.4,4.44a.41.41,0,0,1,0,.09L6.39,11.82l-.09,0L2,12.83Z"/><path class="cls-1" d="M5.12,19.94Q6,16.38,6.9,12.83l6.78,2.63-.07,0A22.89,22.89,0,0,1,11,17.58a14.7,14.7,0,0,1-4.29,2,13.17,13.17,0,0,1-1.54.33Z"/><path class="cls-1" d="M12.68,7.55l6.67-.15c-.08.19-.14.37-.22.55a18.59,18.59,0,0,1-2.54,4.3c-.54.7-1.11,1.35-1.69,2l0,0Z"/><path class="cls-1" d="M7.39,12.08l4.48-4.19,2.21,6.79Z"/><path class="cls-1" d="M15.29,15.19l0,0,.05-.05c.59-.64,1.17-1.29,1.71-2A21.07,21.07,0,0,0,19.43,9.4L19.64,9h0q-.37,4.79-.73,9.55"/><path class="cls-1" d="M19.73,6.08l-5.34-3.9,0,0L17.61.38a.06.06,0,0,1,.06,0,3.5,3.5,0,0,1,2,2A4.49,4.49,0,0,1,20,3.54a6.5,6.5,0,0,1-.12,1.92C19.81,5.66,19.77,5.86,19.73,6.08Z"/><path class="cls-1" d="M18.46,19.09,9,19.74a21.13,21.13,0,0,0,5.66-4l.42.38"/><path class="cls-1" d="M12.66,6.67c.4-1.27.8-2.53,1.19-3.8l5,3.65h0Z"/><path class="cls-1" d="M4.32,19.48c-.67-1.94-1.43-3.87-2.11-5.81L6,12.83c-.56,2.23-1.12,4.44-1.67,6.65Z"/><path class="cls-1" d="M1.64,14.4c.64,1.87,1.29,3.73,1.94,5.6l-.3,0A4.44,4.44,0,0,1,2,19.53,3.32,3.32,0,0,1,.54,18.1,4.57,4.57,0,0,1,.15,17a.19.19,0,0,1,0-.08l1.45-2.49Z"/><path class="cls-1" d="M11.33,0h5.15l0,0L13.67,1.58s-.06,0-.09,0L11.36,0Z"/><path class="cls-1" d="M0,15.47V10.35l0,.08c.39.94.79,1.89,1.18,2.84a.08.08,0,0,1,0,.1L0,15.42A.13.13,0,0,1,0,15.47Z"/></svg>

assets/languages/rust.svg

@@ -0,0 +1 @@
+<svg width="22" height="22" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 22 22"><title>rust-logo</title><path d="M21.85,10.73l-.92-.57,0-.27.79-.74a.34.34,0,0,0,.1-.3.33.33,0,0,0-.2-.23l-1-.38A2,2,0,0,0,20.49,8l.64-.88a.34.34,0,0,0,0-.31.31.31,0,0,0-.24-.19l-1.07-.18c0-.08-.08-.16-.13-.24l.45-1a.31.31,0,0,0-.3-.45l-1.08,0-.18-.21.25-1.06a.31.31,0,0,0-.38-.38l-1.06.25a1.73,1.73,0,0,0-.21-.17l0-1.09a.32.32,0,0,0-.14-.28.31.31,0,0,0-.31,0l-1,.45-.24-.13L15.4,1.08a.31.31,0,0,0-.19-.24.34.34,0,0,0-.31,0L14,1.51l-.26-.08-.38-1a.33.33,0,0,0-.23-.2.34.34,0,0,0-.3.1l-.74.79-.27,0L11.27.15a.32.32,0,0,0-.54,0l-.57.92-.27,0L9.15.31a.32.32,0,0,0-.53.1l-.38,1L8,1.51,7.1.87a.32.32,0,0,0-.5.21L6.42,2.15l-.24.13-1-.45a.31.31,0,0,0-.31,0,.32.32,0,0,0-.14.28l0,1.09-.21.17L3.52,3.14a.31.31,0,0,0-.38.38l.25,1.06-.17.21-1.09,0a.32.32,0,0,0-.28.14.31.31,0,0,0,0,.31l.45,1-.13.24L1.08,6.6a.31.31,0,0,0-.24.19.34.34,0,0,0,0,.31L1.51,8a2,2,0,0,0-.08.26l-1,.38a.33.33,0,0,0-.2.23.34.34,0,0,0,.1.3l.79.74,0,.27-.92.57a.32.32,0,0,0,0,.54l.92.57,0,.27-.79.74a.34.34,0,0,0-.1.3.33.33,0,0,0,.2.23l1,.38a2,2,0,0,0,.08.26l-.64.88a.34.34,0,0,0,0,.31.31.31,0,0,0,.24.19l1.07.18.13.24-.45,1a.31.31,0,0,0,0,.31.32.32,0,0,0,.28.14l1.09,0a1.73,1.73,0,0,0,.17.21l-.25,1.06a.31.31,0,0,0,.38.38l1.06-.25.21.17,0,1.09a.32.32,0,0,0,.14.28.31.31,0,0,0,.31,0l1-.45.24.13.18,1.07a.31.31,0,0,0,.19.24.34.34,0,0,0,.31,0L8,20.49l.26.08.38,1a.33.33,0,0,0,.23.2.34.34,0,0,0,.3-.1l.74-.79.27,0,.57.92a.32.32,0,0,0,.54,0l.57-.92.27,0,.74.79a.34.34,0,0,0,.3.1.33.33,0,0,0,.23-.2l.38-1,.26-.08.88.64a.34.34,0,0,0,.31,0,.31.31,0,0,0,.19-.24l.18-1.07.24-.13,1,.45a.31.31,0,0,0,.31,0,.32.32,0,0,0,.14-.28l0-1.09a1.73,1.73,0,0,0,.21-.17l1.06.25a.31.31,0,0,0,.38-.38l-.25-1.06.18-.21,1.08,0a.31.31,0,0,0,.3-.45l-.45-1c.05-.08.09-.16.13-.24l1.07-.18a.31.31,0,0,0,.24-.19.34.34,0,0,0,0-.31L20.49,14a2,2,0,0,0,.08-.26l1-.38a.33.33,0,0,0,.2-.23.34.34,0,0,0-.1-.3l-.79-.74,0-.27.92-.57a.32.32,0,0,0,0-.54Zm-6.18,7.66a.65.65,0,0,1,.27-1.28.66.66,0,0,1,.5.78A.64.64,0,0,1,15.67,18.39Zm-.32-2.12a.59.59,0,0,0-.7.46l-.33,1.53A8,8,0,0,1,11,19a8.16,8.16,0,0,1-3.39-.74L7.28,16.7a.58.58,0,0,0-.7-.46l-1.35.29a7.88,7.88,0,0,1-.7-.83H11.1c.08,0,.12,0,.12-.08V13.3c0-.07,0-.08-.12-.08H9.18V11.74h2.08a1.32,1.32,0,0,1,1.28,1.11c.08.33.26,1.38.38,1.72s.63,1.13,1.17,1.13h3.39a10.43,10.43,0,0,1-.74.88ZM6.26,18.36a.64.64,0,0,1-.77-.5.65.65,0,0,1,.5-.78.65.65,0,0,1,.27,1.28ZM3.77,8.25a.65.65,0,1,1-.86-.33A.64.64,0,0,1,3.77,8.25ZM3,10.07l1.41-.63a.59.59,0,0,0,.3-.79L4.42,8H5.56v5.14H3.26A8.54,8.54,0,0,1,3,10.07Zm6.18-.5V8.05h2.71c.14,0,1,.16,1,.8s-.65.72-1.18.72ZM19,10.93c0,.2,0,.4,0,.6H18.2c-.09,0-.12.05-.12.13V12c0,.89-.5,1.09-.94,1.14s-.89-.18-.95-.44a2.81,2.81,0,0,0-1.31-2.2,3,3,0,0,0,1.65-2.29,2.59,2.59,0,0,0-1.26-2.12,3.63,3.63,0,0,0-1.73-.57H5A8.07,8.07,0,0,1,9.51,3l1,1.06a.6.6,0,0,0,.85,0L12.48,3A8.07,8.07,0,0,1,18,6.94l-.77,1.74a.59.59,0,0,0,.3.79l1.48.66A7,7,0,0,1,19,10.93Zm-8.53-8.8a.66.66,0,0,1,.93,0,.65.65,0,0,1,0,.92.66.66,0,0,1-.93,0A.65.65,0,0,1,10.51,2.13Zm7.65,6.15A.65.65,0,0,1,19,8a.65.65,0,1,1-.86.33Z"/></svg>

assets/languages/swift.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="20px" height="18px" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 36" version="1.1">
+ <defs>
+  <linearGradient id="a" x2="50%" x1="50%" y2="100%">
+   <stop stop-color="#F88A36" offset="0"/>
+   <stop stop-color="#FD2020" offset="1"/>
+  </linearGradient>
+ </defs>
+ <path d="m29.885 33.047c-4.667 2.696-11.084 2.973-17.54 0.206-5.2273-2.224-9.5646-6.117-12.345-10.565 1.3346 1.112 2.8916 2.002 4.5598 2.78 6.6672 3.125 13.333 2.911 18.024 0.008-0.003-0.003-0.005-0.005-0.007-0.008-6.673-5.116-12.345-11.789-16.571-17.238-0.8901-0.8898-1.5574-2.002-2.2247-3.0029 5.1159 4.671 13.235 10.565 16.126 12.234-6.116-6.451-11.566-14.458-11.344-14.236 9.676 9.787 18.685 15.348 18.685 15.348 0.298 0.168 0.528 0.308 0.713 0.433 0.195-0.496 0.366-1.011 0.51-1.545 1.557-5.672-0.222-12.123-4.115-17.461 9.008 5.4495 14.347 15.681 12.122 24.245-0.058 0.231-0.121 0.459-0.189 0.683 0.026 0.031 0.052 0.063 0.078 0.096 4.448 5.561 3.225 11.455 2.669 10.343-2.413-4.722-6.88-3.278-9.151-2.32z" fill="url(#a)"/>
+</svg>

azure-pipelines.yml

@@ -0,0 +1,340 @@
+name: $(Build.SourceBranch)-$(date:yyyyMMdd)$(rev:.r)
+
+# The Different jobs (lint, test, build to run)
+jobs:
+  - job: changelog
+    steps:
+      - bash: |
+          git --no-pager diff --name-only HEAD $(git merge-base HEAD master) --exit-code CHANGELOG.md
+        displayName: Changelog Updated
+
+  - job: lint
+    pool:
+      vmImage: "macos-10.14"
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - script: |
+          rustup component add rustfmt
+        displayName: Lint dependencies
+      - script: cargo fmt --all -- --check
+        displayName: Lint
+    variables:
+      rust_toolchain: '1.41.1'
+
+  - job: clippy_lint
+    pool:
+      vmImage: "ubuntu-16.04"
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - template: .azure/install-llvm.yml
+      - template: .azure/install-sccache.yml
+      - template: .azure/install-cmake.yml
+      - script: |
+          rustup component add rustfmt
+          rustup component add clippy || cargo install --git https://github.com/rust-lang/rust-clippy/ --force clippy
+        displayName: Lint dependencies with clippy
+      - script: cargo clippy --workspace
+        displayName: Clippy Lint
+    variables:
+      rust_toolchain: nightly-2019-12-19
+
+  - job: Test
+    strategy:
+      matrix:
+        linux:
+          poolName: "Azure Pipelines"
+          imageName: "ubuntu-16.04"
+          rust_toolchain: nightly-2019-12-19
+        android:
+          poolName: "Azure Pipelines"
+          imageName: "ubuntu-16.04"
+          rust_toolchain: nightly-2019-12-19
+          ANDROID: true
+        mac:
+          poolName: "Azure Pipelines"
+          imageName: "macos-10.14"
+          rust_toolchain: nightly-2019-12-19
+          # By default schannel checks revocation of certificates unlike some other SSL
+          # backends, but we've historically had problems on CI where a revocation
+          # server goes down presumably. See #43333 for more info
+          CARGO_HTTP_CHECK_REVOKE: false
+        arm:
+          poolName: "Packet"
+          rust_toolchain: nightly-2019-12-19
+        windows:
+          poolName: "Azure Pipelines"
+          imageName: "vs2017-win2016"
+          rust_toolchain: '1.41.1'
+    pool:
+      name: $(poolName)
+      vmImage: $(imageName)
+    condition: in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/staging', 'refs/heads/trying')
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - template: .azure/install-llvm.yml
+      - template: .azure/install-sccache.yml
+      - template: .azure/install-cmake.yml
+      - bash: |
+          hostname
+          uname -a
+        displayName: System info (*nix)
+        condition: and(succeeded(), not(eq(variables['Agent.OS'], 'Windows_NT')))
+      - bash: |
+          cat /proc/cpuinfo
+          cat /proc/meminfo
+        displayName: System info - Extended (Linux)
+        condition: and(succeeded(), eq(variables['Agent.OS'], 'Linux'))
+      - bash: |
+          sysctl -a | grep machdep.cpu
+        displayName: System info - Extended (Mac)
+        condition: and(succeeded(), eq(variables['Agent.OS'], 'Darwin'))
+      - bash: make test
+        displayName: Tests (*nix)
+        condition: and(succeeded(), not(eq(variables['Agent.OS'], 'Windows_NT')), not(variables['ANDROID']))
+      - bash: make test-android
+        displayName: Tests (Android)
+        condition: and(succeeded(), variables['ANDROID'])
+      - bash: make spectests
+        displayName: Tests (Windows)
+        condition: and(succeeded(), eq(variables['Agent.OS'], 'Windows_NT'), not(variables['ANDROID']))
+
+  - job: Check
+    pool:
+      vmImage: "ubuntu-16.04"
+    variables:
+      rust_toolchain: nightly-2019-12-19
+    condition: in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/staging', 'refs/heads/trying')
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - template: .azure/install-llvm.yml
+      - template: .azure/install-sccache.yml
+      - template: .azure/install-cmake.yml
+      - bash: |
+          make check
+          make check-nightly
+        displayName: Check with Flags
+        condition: and(succeeded(), not(eq(variables['Agent.OS'], 'Windows_NT')))
+
+  - job: Build_CLI
+    strategy:
+      matrix:
+        linux:
+          poolName: "Azure Pipelines"
+          imageName: "ubuntu-16.04"
+          rust_toolchain: nightly-2019-12-19
+        mac:
+          poolName: "Azure Pipelines"
+          imageName: "macos-10.14"
+          rust_toolchain: nightly-2019-12-19
+          MACOSX_DEPLOYMENT_TARGET: 10.10
+        arm:
+          poolName: "Packet"
+          rust_toolchain: nightly-2019-12-19
+        windows:
+          poolName: "Azure Pipelines"
+          imageName: "vs2017-win2016"
+          rust_toolchain: '1.41.1'
+          # RUSTFLAGS: -Ctarget-feature=+crt-static
+    pool:
+      name: $(poolName)
+      vmImage: $(imageName)
+    condition: |
+      or(
+        in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/staging', 'refs/heads/trying'),
+        startsWith(variables['Build.SourceBranch'], 'refs/tags')
+      )
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - template: .azure/install-llvm.yml
+      - template: .azure/install-sccache.yml
+      - template: .azure/install-cmake.yml
+      - template: .azure/install-innosetup.yml
+      - bash: |
+          mkdir -p artifacts
+        displayName: Create Artifacts Dir
+      - bash: make release
+        displayName: Build
+      - bash: sudo apt-get install musl-tools && make release-musl
+        displayName: Build (Linux Musl)
+        condition: and(succeeded(), eq(variables['Agent.OS'], 'Linux'), eq(variables['Agent.OSArchitecture'], 'X64'))
+      - bash: |
+          make build-wapm
+        displayName: Build WAPM
+        condition: |
+          startsWith(variables['Build.SourceBranch'], 'refs/tags')
+      - bash: |
+          make build-install-package
+          cp ./wasmer.tar.gz ./artifacts/$(./scripts/binary-name.sh)
+        displayName: Build Distribution (*nix)
+        condition: |
+          and(
+            succeeded(),
+            startsWith(variables['Build.SourceBranch'], 'refs/tags'),
+            not(eq(variables['Agent.OS'], 'Windows_NT'))
+          )
+      - bash: |
+          cd ./src/installer
+          iscc wasmer.iss
+          cp WasmerInstaller.exe ../../artifacts/wasmer-windows.exe
+        displayName: Build Distribution (Windows)
+        condition: |
+          and(
+            succeeded(),
+            startsWith(variables['Build.SourceBranch'], 'refs/tags'),
+            eq(variables['Agent.OS'], 'Windows_NT')
+          )
+      - publish: $(System.DefaultWorkingDirectory)/artifacts
+        artifact: cli-$(Agent.OS)-$(Agent.OSArchitecture)
+
+  - job: Build_Library
+    strategy:
+      matrix:
+        linux:
+          imageName: "ubuntu-16.04"
+          rust_toolchain: nightly-2019-12-19
+        mac:
+          imageName: "macos-10.14"
+          rust_toolchain: nightly-2019-12-19
+          MACOSX_DEPLOYMENT_TARGET: 10.10
+        windows:
+          imageName: "vs2017-win2016"
+          rust_toolchain: '1.41.1'
+          # RUSTFLAGS: -Ctarget-feature=+crt-static
+    pool:
+      vmImage: $(imageName)
+    condition: |
+      or(
+        in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/staging', 'refs/heads/trying'),
+        startsWith(variables['Build.SourceBranch'], 'refs/tags')
+      )
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - template: .azure/install-llvm.yml
+      - template: .azure/install-sccache.yml
+      - template: .azure/install-cmake.yml
+      - bash: |
+          mkdir -p artifacts
+        displayName: Create Artifacts Dir
+      - bash: |
+          make test-capi
+        displayName: Test c-api
+        condition: and(succeeded(), eq(variables['Agent.OSArchitecture'], 'X64'), not(eq(variables['Agent.OS'], 'Windows_NT')))
+      - bash: |
+          make capi
+        displayName: Build c-api
+      - bash: |
+          make build-capi-package
+          cp ./wasmer-c-api.tar.gz ./artifacts/$(./scripts/capi-name.sh)
+        displayName: Build c-api artifacts (Unix)
+        condition: |
+          and(
+            succeeded(),
+            not(eq(variables['Agent.OS'], 'Windows_NT'))
+          )
+      - bash: |
+          make build-capi-package
+          cp ./wasmer-c-api.tar.gz ./artifacts/wasmer-c-api-windows.tar.gz
+        displayName: Build c-api artifacts (Windows)
+        condition: |
+          and(
+            succeeded(),
+            eq(variables['Agent.OS'], 'Windows_NT')
+          )
+      - publish: $(System.DefaultWorkingDirectory)/artifacts
+        artifact: library-$(Agent.OS)-$(Agent.OSArchitecture)
+
+  - job: Build_Docs
+    pool:
+      vmImage: "ubuntu-16.04"
+    variables:
+      rust_toolchain: nightly-2019-12-19
+    condition: in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/staging', 'refs/heads/trying')
+    steps:
+      - checkout: self
+      - template: .azure/install-rust.yml
+      - template: .azure/install-llvm.yml
+      - template: .azure/install-sccache.yml
+      - template: .azure/install-cmake.yml
+      - bash: |
+          sudo apt-get install doxygen graphviz
+        displayName: Install doxygen
+      - bash: |
+          make docs
+        displayName: Build docs
+      - publish: $(System.DefaultWorkingDirectory)/api-docs
+        artifact: api-docs
+        displayName: Save Docs artifact
+
+  - job: Publish
+    dependsOn:
+      - Build_CLI
+      - Build_Library
+    condition: |
+      startsWith(variables['Build.SourceBranch'], 'refs/tags')
+    steps:
+      # - download: current
+      - task: DownloadPipelineArtifact@1
+        inputs:
+          targetPath: $(Build.ArtifactStagingDirectory)
+      - bash: |
+          ls $ARTIFACT_STAGING_DIRECTORY
+        displayName: List Artifacts
+        env:
+          ARTIFACT_STAGING_DIRECTORY: $(Build.ArtifactStagingDirectory)
+      - script: VERSION_TAG=`git describe --tags` && echo "##vso[task.setvariable variable=VERSION_TAG]$VERSION_TAG"
+        displayName: Set the tag name as an environment variable
+      - task: GithubRelease@0
+        displayName: "Create GitHub Release with artifacts"
+        condition: and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/tags'))
+        inputs:
+          gitHubConnection: 'wasmer'
+          repositoryName: 'wasmerio/wasmer'
+          action: 'create'
+          target: '$(Build.SourceVersion)'
+          title: '$(VERSION_TAG)'
+          addChangeLog: false
+          tagSource: 'auto'
+          # TODO: automate it all by getting the release notes from somewhere else and using the `releaseNotesFile` key
+          isDraft: false
+          isPreRelease: false
+          assets: '$(Build.ArtifactStagingDirectory)/**'
+          assetUploadMode: 'replace' # Don't delete previously uploaded assets (default)
+
+  - job: Publish_Docs
+    dependsOn:
+      - Build_Docs
+    displayName: Deploy API Documentation to GitHub
+    pool:
+      vmImage: "ubuntu-16.04"
+    condition: in(variables['Build.SourceBranch'], 'refs/heads/master')
+    steps:
+      - checkout: self
+      - task: DownloadPipelineArtifact@2
+        inputs:
+          artifactName: api-docs
+          targetPath: $(System.DefaultWorkingDirectory)/api-docs
+      - bash: |
+          git config --global user.email "bot@wasmer.io"
+          git config --global user.name "wasmerbot"
+          make docs-publish
+        env:
+          RUST_DOCS_DIR: $(Pipeline.Workspace)/api-docs
+          GITHUB_DOCS_TOKEN: $(GITHUB_DOCS_TOKEN)
+          SOURCE_VERSION: $(Build.SourceVersion)
+
+# We only run the pipelines on PRs to Master
+pr:
+  - master
+
+# Otherwise, we test in any of these branches (master or bors related)
+trigger:
+  - master
+  - staging
+  - trying
+  - refs/tags/*

benches/metering_benchmark.rs

@@ -133,23 +133,22 @@ static WAT_GAS: &'static str = r#"
               (elem (i32.const 0) $f2))
         "#;
 
-#[cfg(feature = "llvm")]
+#[cfg(feature = "backend-llvm")]
 fn get_compiler(limit: u64, metering: bool) -> impl Compiler {
-    use wasmer_llvm_backend::code::LLVMModuleCodeGenerator;
+    use wasmer_llvm_backend::ModuleCodeGenerator;
     use wasmer_runtime_core::codegen::{MiddlewareChain, StreamingCompiler};
-    let c: StreamingCompiler<LLVMModuleCodeGenerator, _, _, _, _> =
-        StreamingCompiler::new(move || {
-            let mut chain = MiddlewareChain::new();
-            if metering {
-                chain.push(Metering::new(limit));
-            }
-            chain
-        });
+    let c: StreamingCompiler<ModuleCodeGenerator, _, _, _, _> = StreamingCompiler::new(move || {
+        let mut chain = MiddlewareChain::new();
+        if metering {
+            chain.push(Metering::new(limit));
+        }
+        chain
+    });
 
     c
 }
 
-#[cfg(feature = "singlepass")]
+#[cfg(feature = "backend-singlepass")]
 fn get_compiler(limit: u64, metering: bool) -> impl Compiler {
     use wasmer_runtime_core::codegen::{MiddlewareChain, StreamingCompiler};
     use wasmer_singlepass_backend::ModuleCodeGenerator as SinglePassMCG;
@@ -163,16 +162,16 @@ fn get_compiler(limit: u64, metering: bool) -> impl Compiler {
     c
 }
 
-#[cfg(not(any(feature = "llvm", feature = "clif", feature = "singlepass")))]
-fn get_compiler(_limit: u64, metering: bool) -> impl Compiler {
-    panic!("compiler not specified, activate a compiler via features");
-    use wasmer_clif_backend::CraneliftCompiler;
-    CraneliftCompiler::new()
-}
+#[cfg(not(any(
+    feature = "backend-llvm",
+    feature = "backend-cranelift",
+    feature = "backend-singlepass"
+)))]
+compile_error!("compiler not specified, activate a compiler via features");
 
-#[cfg(feature = "clif")]
+#[cfg(feature = "backend-cranelift")]
 fn get_compiler(_limit: u64, metering: bool) -> impl Compiler {
-    panic!("cranelift does not implement metering");
+    unimplemented!("cranelift does not implement metering");
     use wasmer_clif_backend::CraneliftCompiler;
     CraneliftCompiler::new()
 }
@@ -194,8 +193,8 @@ fn bench_metering(c: &mut Criterion) {
             let wasm_binary = wat2wasm(WAT).unwrap();
             let module = compile_with(&wasm_binary, &compiler).unwrap();
             let import_object = imports! {};
-            let mut instance = module.instantiate(&import_object).unwrap();
-            let add_to: Func<(i32, i32), i32> = instance.func("add_to").unwrap();
+            let instance = module.instantiate(&import_object).unwrap();
+            let add_to: Func<(i32, i32), i32> = instance.exports.get("add_to").unwrap();
             b.iter(|| black_box(add_to.call(100, 4)))
         })
         .with_function("Gas Metering", |b| {
@@ -207,8 +206,8 @@ fn bench_metering(c: &mut Criterion) {
                    "gas" => Func::new(gas),
                 },
             };
-            let mut gas_instance = gas_module.instantiate(&gas_import_object).unwrap();
-            let gas_add_to: Func<(i32, i32), i32> = gas_instance.func("add_to").unwrap();
+            let gas_instance = gas_module.instantiate(&gas_import_object).unwrap();
+            let gas_add_to: Func<(i32, i32), i32> = gas_instance.exports.get("add_to").unwrap();
             b.iter(|| black_box(gas_add_to.call(100, 4)))
         })
         .with_function("Built-in Metering", |b| {
@@ -220,11 +219,14 @@ fn bench_metering(c: &mut Criterion) {
                 .instantiate(&metering_import_object)
                 .unwrap();
             metering::set_points_used(&mut metering_instance, 0u64);
-            let metering_add_to: Func<(i32, i32), i32> = metering_instance.func("add_to").unwrap();
+            let metering_add_to: Func<(i32, i32), i32> =
+                metering_instance.exports.get("add_to").unwrap();
             b.iter(|| black_box(metering_add_to.call(100, 4)))
         }),
     );
 }
 
+#[cfg(not(feature = "backend-cranelift"))]
 criterion_group!(benches, bench_metering);
+#[cfg(not(feature = "backend-cranelift"))]
 criterion_main!(benches);

bors.toml

@@ -1,10 +1,6 @@
 status = [
-    "ci/circleci: lint",
-    "ci/circleci: test",
-    "ci/circleci: test-macos",
-    "ci/circleci: test-rust-nightly",
-    "continuous-integration/appveyor/branch"
+    "wasmerio.wasmer"
 ]
 required_approvals = 1
-timeout_sec = 900
+timeout_sec = 7200
 delete_merged_branches = true 

build.rs

@@ -0,0 +1,137 @@
+//! A kind of meta-build.rs that can be configured to do different things.
+//!
+//! Please try to keep this file as clean as possible.
+
+use generate_emscripten_tests;
+use generate_wasi_tests;
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+use std::process::Command;
+use test_generator::{
+    build_ignores_from_textfile, emscripten_processor, test_directory, test_directory_module,
+    wasi_processor, wast_processor, with_backends, with_test_module, Testsuite,
+};
+
+static EMTESTS_ENV_VAR: &str = "WASM_EMSCRIPTEN_GENERATE_EMTESTS";
+static WASITESTS_ENV_VAR: &str = "WASM_WASI_GENERATE_WASITESTS";
+static WASITESTS_SET_UP_TOOLCHAIN: &str = "WASM_WASI_SET_UP_TOOLCHAIN";
+static WASITESTS_GENERATE_ALL: &str = "WASI_TEST_GENERATE_ALL";
+
+fn is_truthy_env(name: &str) -> bool {
+    env::var(name).map(|n| n == "1").unwrap_or_default()
+}
+
+fn main() -> anyhow::Result<()> {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=test/ignores.txt");
+    println!("cargo:rerun-if-env-changed={}", EMTESTS_ENV_VAR);
+    println!("cargo:rerun-if-env-changed={}", WASITESTS_ENV_VAR);
+    println!("cargo:rerun-if-env-changed={}", WASITESTS_SET_UP_TOOLCHAIN);
+    println!("cargo:rerun-if-env-changed={}", WASITESTS_GENERATE_ALL);
+
+    let wasi_versions = if is_truthy_env(WASITESTS_GENERATE_ALL) {
+        generate_wasi_tests::ALL_WASI_VERSIONS
+    } else {
+        generate_wasi_tests::LATEST_WASI_VERSION
+    };
+
+    // Install the Rust WASI toolchains for each of the versions
+    if is_truthy_env(WASITESTS_SET_UP_TOOLCHAIN) {
+        generate_wasi_tests::install_toolchains(wasi_versions);
+    }
+
+    // Generate the WASI Wasm files
+    if is_truthy_env(WASITESTS_ENV_VAR) {
+        generate_wasi_tests::build(wasi_versions);
+    }
+
+    // Generate Emscripten Wasm files
+    if is_truthy_env(EMTESTS_ENV_VAR) {
+        generate_emscripten_tests::build();
+    }
+
+    let out_dir = PathBuf::from(
+        env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"),
+    );
+    let ignores = build_ignores_from_textfile("tests/ignores.txt".into())?;
+
+    // Spectests test generation
+    let mut spectests = Testsuite {
+        buffer: String::new(),
+        path: vec![],
+        ignores: ignores.clone(),
+    };
+    let backends = vec!["singlepass", "cranelift", "llvm"];
+    with_backends(&mut spectests, &backends, |mut spectests| {
+        with_test_module(&mut spectests, "spec", |mut spectests| {
+            let _spec_tests = test_directory(spectests, "tests/spectests", wast_processor)?;
+            with_test_module(&mut spectests, "custom", |spectests| {
+                let _spec_tests = test_directory(spectests, "tests/custom", wast_processor)?;
+                Ok(())
+            })?;
+            Ok(())
+        })?;
+        Ok(())
+    })?;
+
+    // Emscripten tests generation
+    let mut emtests = Testsuite {
+        buffer: String::new(),
+        path: vec![],
+        ignores: ignores.clone(),
+    };
+    with_backends(&mut emtests, &backends, |mut emtests| {
+        with_test_module(&mut emtests, "emscripten", |emtests| {
+            let _emscripten_tests = test_directory(
+                emtests,
+                "tests/emscripten_resources/emtests",
+                emscripten_processor,
+            )?;
+            Ok(())
+        })?;
+        Ok(())
+    })?;
+
+    // WASI tests generation
+    let mut wasitests = Testsuite {
+        buffer: String::new(),
+        path: vec![],
+        ignores: ignores.clone(),
+    };
+    with_backends(&mut wasitests, &backends, |mut wasitests| {
+        with_test_module(&mut wasitests, "wasi", |wasitests| {
+            test_directory_module(
+                wasitests,
+                "tests/wasi_test_resources/unstable",
+                wasi_processor,
+            )?;
+            test_directory_module(
+                wasitests,
+                "tests/wasi_test_resources/snapshot1",
+                wasi_processor,
+            )?;
+            Ok(())
+        })?;
+        Ok(())
+    })?;
+
+    let spectests_output = out_dir.join("generated_spectests.rs");
+    fs::write(&spectests_output, spectests.buffer)?;
+
+    let emtests_output = out_dir.join("generated_emtests.rs");
+    fs::write(&emtests_output, emtests.buffer)?;
+
+    let wasitests_output = out_dir.join("generated_wasitests.rs");
+    fs::write(&wasitests_output, wasitests.buffer)?;
+
+    // Write out our auto-generated tests and opportunistically format them with
+    // `rustfmt` if it's installed.
+    // Note: We need drop because we don't want to run `unwrap` or `expect` as
+    // the command might fail, but we don't care about it's result.
+    drop(Command::new("rustfmt").arg(&spectests_output).status());
+    drop(Command::new("rustfmt").arg(&emtests_output).status());
+    drop(Command::new("rustfmt").arg(&wasitests_output).status());
+
+    Ok(())
+}

ci/README.md

@@ -0,0 +1,3 @@
+# About this directory
+
+This directory is originally copied from [rust-lang/libc/ci](https://github.com/rust-lang/libc/tree/master/ci).

ci/android-install-ndk.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env sh
+# Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+set -ex
+
+NDK=android-ndk-r19c
+curl --retry 20 -O https://dl.google.com/android/repository/${NDK}-linux-x86_64.zip
+unzip -q -d ndk ${NDK}-linux-x86_64.zip
+mv ./ndk/"$NDK"/* ./ndk/
+
+rm -rf ./${NDK}-linux-x86_64.zip

ci/android-install-sdk.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env sh
+# Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+set -ex
+
+# Prep the SDK and emulator
+#
+# Note that the update process requires that we accept a bunch of licenses, and
+# we can't just pipe `yes` into it for some reason, so we take the same strategy
+# located in https://github.com/appunite/docker by just wrapping it in a script
+# which apparently magically accepts the licenses.
+
+SDK=4333796
+mkdir sdk
+curl --retry 20 https://dl.google.com/android/repository/sdk-tools-linux-${SDK}.zip -O
+unzip -q -d sdk sdk-tools-linux-${SDK}.zip
+
+case "$1" in
+  arm | armv7)
+    api=24
+    image="system-images;android-${api};google_apis;armeabi-v7a"
+    ;;
+  aarch64)
+    api=24
+    image="system-images;android-${api};google_apis;arm64-v8a"
+    ;;
+  i686)
+    api=28
+    image="system-images;android-${api};default;x86"
+    ;;
+  x86_64)
+    api=28
+    image="system-images;android-${api};default;x86_64"
+    ;;
+  *)
+    echo "invalid arch: $1"
+    exit 1
+    ;;
+esac;
+
+# Try to fix warning about missing file.
+# See https://askubuntu.com/a/1078784
+mkdir -p /root/.android/
+echo '### User Sources for Android SDK Manager' >> /root/.android/repositories.cfg
+echo '#Fri Nov 03 10:11:27 CET 2017 count=0' >> /root/.android/repositories.cfg
+
+# Print all available packages
+# yes | ./sdk/tools/bin/sdkmanager --list --verbose
+
+# --no_https avoids
+# javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: No trusted certificate found
+#
+# | grep -v = || true    removes the progress bar output from the sdkmanager
+# which produces an insane amount of output.
+yes | ./sdk/tools/bin/sdkmanager --licenses --no_https | grep -v = || true
+yes | ./sdk/tools/bin/sdkmanager --no_https \
+        "emulator" \
+        "platform-tools" \
+        "platforms;android-${api}" \
+        "${image}" | grep -v = || true
+
+echo "no" |
+    ./sdk/tools/bin/avdmanager create avd \
+        --name "${1}" \
+        --package "${image}" | grep -v = || true

ci/android-sysimage.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+set -ex
+
+URL=https://dl.google.com/android/repository/sys-img/android
+
+main() {
+    local arch="${1}"
+    local name="${2}"
+    local dest=/system
+    local td
+    td="$(mktemp -d)"
+
+    apt-get install --no-install-recommends e2tools
+
+    pushd "${td}"
+    curl --retry 5 -O "${URL}/${name}"
+    unzip -q "${name}"
+
+    local system
+    system="$(find . -name system.img)"
+    mkdir -p ${dest}/{bin,lib,lib64}
+
+    # Extract android linker and libraries to /system
+    # This allows android executables to be run directly (or with qemu)
+    if [ "${arch}" = "x86_64" ] || [ "${arch}" = "arm64" ]; then
+        e2cp -p "${system}:/bin/linker64" "${dest}/bin/"
+        e2cp -p "${system}:/lib64/libdl.so" "${dest}/lib64/"
+        e2cp -p "${system}:/lib64/libc.so" "${dest}/lib64/"
+        e2cp -p "${system}:/lib64/libm.so" "${dest}/lib64/"
+    else
+        e2cp -p "${system}:/bin/linker" "${dest}/bin/"
+        e2cp -p "${system}:/lib/libdl.so" "${dest}/lib/"
+        e2cp -p "${system}:/lib/libc.so" "${dest}/lib/"
+        e2cp -p "${system}:/lib/libm.so" "${dest}/lib/"
+    fi
+
+    # clean up
+    apt-get purge --auto-remove -y e2tools
+
+    popd
+
+    rm -rf "${td}"
+}
+
+main "${@}"

ci/docker/aarch64-linux-android/Dockerfile

@@ -0,0 +1,53 @@
+FROM ubuntu:19.10
+
+RUN dpkg --add-architecture i386 && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+  file \
+  curl \
+  ca-certificates \
+  python \
+  unzip \
+  expect \
+  openjdk-8-jre \
+  libstdc++6:i386 \
+  libpulse0 \
+  gcc \
+  libc6-dev \
+  make \
+  cmake # cmake is necessary to build wabt
+
+WORKDIR /android/
+COPY android* /android/
+
+ENV ANDROID_ARCH=aarch64
+ENV PATH=$PATH:/android/sdk/tools:/android/sdk/platform-tools
+
+RUN sh /android/android-install-ndk.sh $ANDROID_ARCH
+RUN sh /android/android-install-sdk.sh $ANDROID_ARCH
+ENV ANDROID_NDK_HOME=/android/ndk
+
+RUN mv /root/.android /tmp
+RUN chmod 777 -R /tmp/.android
+RUN chmod 755 /android/sdk/tools/* /android/sdk/emulator/qemu/linux-x86_64/*
+
+ENV PATH=$PATH:/rust/bin:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin \
+    CARGO_TARGET_AARCH64_LINUX_ANDROID_AR=aarch64-linux-android-ar \
+    CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER=aarch64-linux-android28-clang++ \
+    CC_aarch64_linux_android=aarch64-linux-android28-clang \
+    CXX_aarch64_linux_android=aarch64-linux-android28-clang++ \
+    CARGO_TARGET_AARCH64_LINUX_ANDROID_RUNNER=/tmp/runtest \
+    HOME=/tmp
+
+ADD runtest-android.rs /tmp/runtest.rs
+
+ENTRYPOINT [ \
+  "bash", \
+  "-c", \
+  # set SHELL so android can detect a 64bits system, see
+  # http://stackoverflow.com/a/41789144
+  "SHELL=/bin/dash /android/sdk/emulator/emulator @aarch64 -no-window & \
+   rustc /tmp/runtest.rs -o /tmp/runtest && \
+   exec \"$@\"", \
+  "--" \
+]

ci/docker/x86_64-linux-android/Dockerfile

@@ -0,0 +1,32 @@
+FROM ubuntu:19.10
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+  ca-certificates \
+  curl \
+  gcc \
+  g++ \
+  libc-dev \
+  python \
+  unzip \
+  make \
+  cmake # cmake is necessary to build wabt
+
+WORKDIR /android/
+ENV ANDROID_ARCH=x86_64
+COPY android-install-ndk.sh /android/
+RUN sh /android/android-install-ndk.sh $ANDROID_ARCH
+ENV ANDROID_NDK_HOME=/android/ndk/
+
+# We do not run x86_64-linux-android tests on an android emulator.
+# See ci/android-sysimage.sh for informations about how tests are run.
+COPY android-sysimage.sh /android/
+RUN bash /android/android-sysimage.sh x86_64 x86_64-24_r07.zip
+
+ENV PATH=$PATH:/rust/bin:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin \
+    CARGO_TARGET_X86_64_LINUX_ANDROID_AR=x86_64-linux-android-ar \
+    CARGO_TARGET_X86_64_LINUX_ANDROID_LINKER=x86_64-linux-android28-clang++ \
+    CC_x86_64_linux_android=x86_64-linux-android28-clang \
+    CXX_x86_64_linux_android=x86_64-linux-android28-clang++ \
+    LD_LIBRARY_PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/x86_64-linux-android/ \
+    HOME=/tmp

ci/run-docker.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env sh
+
+# Small script to run tests for a target (or all targets) inside all the
+# respective docker images.
+
+set -e
+
+echo "${HOME}"
+pwd
+
+TARGET="${1}"
+shift
+
+echo "Building docker container for target $target"
+
+# use -f so we can use ci/ as build context
+image_tag=test-"$TARGET"
+docker build -t "$image_tag" -f "ci/docker/${TARGET}/Dockerfile" ci/
+mkdir -p target
+
+set -x
+
+docker run \
+  --rm \
+  --user "$(id -u)":"$(id -g)" \
+  --env CARGO_HOME=/cargo \
+  --env CARGO_TARGET_DIR=/checkout/target \
+  --volume "$(dirname "$(dirname "$(command -v cargo)")")":/cargo \
+  --volume "$(rustc --print sysroot)":/rust:ro \
+  --volume "$(pwd)":/checkout:ro \
+  --volume "$(pwd)"/target:/checkout/target \
+  --init \
+  --workdir /checkout \
+  "$image_tag" \
+  sh -c "HOME=/tmp PATH=\$PATH:/rust/bin exec cargo test --target ${TARGET} $@"

ci/runtest-android.rs

@@ -0,0 +1,60 @@
+use std::env;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn main() {
+    let args = env::args_os()
+        .skip(1)
+        .filter(|arg| arg != "--quiet")
+        .collect::<Vec<_>>();
+    assert_eq!(args.len(), 1);
+    let test = PathBuf::from(&args[0]);
+
+    // required to run an executable depending on wabt-rs
+    let android_ndk_home = env::var("ANDROID_NDK_HOME").expect("Can't get ANDROID_NDK_HOME!");
+    let path = format!("{}/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/x86_64-linux-android/libc++_shared.so", android_ndk_home);
+    let libcpp_shared = Path::new(&path);
+
+    let dst = Path::new("/data/local/tmp");
+    let dst_exec = Path::new("/data/local/tmp").join(test.file_name().unwrap());
+
+    let status = Command::new("adb")
+        .arg("wait-for-device")
+        .status()
+        .expect("failed to run: adb wait-for-device");
+    assert!(status.success());
+
+    let status = Command::new("adb")
+        .arg("push")
+        .arg(&test)
+        .arg(&libcpp_shared)
+        .arg(&dst)
+        .status()
+        .expect("failed to run: adb pushr");
+    assert!(status.success());
+
+    let output = Command::new("adb")
+        .arg("shell")
+        .arg("LD_LIBRARY_PATH=/data/local/tmp/")
+        .arg(&dst_exec)
+        .output()
+        .expect("failed to run: adb shell");
+    assert!(status.success());
+
+    println!(
+        "status: {}\nstdout ---\n{}\nstderr ---\n{}",
+        output.status,
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    stdout
+        .lines()
+        .find(|l| {
+            (l.starts_with("PASSED ") && l.contains(" tests")) || l.starts_with("test result: ok")
+        })
+        .unwrap_or_else(|| {
+            panic!("failed to find successful test run");
+        });
+}

docs/docker.md

@@ -1,39 +0,0 @@
-# Dockerfile Documentation
-The `Dockerfile` included in the project root directory could be used for development purposes or to build a small image containing the `wasmer` executable.
-
-The `wasmer-build-env` stage in the Dockerfile contains the dependencies needed to compile Wasmer including LLVM.
-
-The `wasmer-debug-env` stage adds the `valgrind` profiling tool to the `wasmer-build-env` stage.
-
-The `wasmer-build` stage in the Dockerfile will copy the current directory, assuming the build context is the `wasmer` project, and build the project using `cargo build --release`.
-
-The `wasmer` stage will copy the resulting `wasmer` executable from the `wasmer-build` stage into a new base image to create a smaller image containing `wasmer`.
-
-## Example Usages
-
-### Wasmer image
-1. From the `wasmer` project directory, build the image:
-`docker build -t wasmer --target=wasmer .`
-
-2. List options:
-`docker run wasmer --help`
-
-3. Mount a directory, and run an example wasm file:
-`docker run -v /Users/admin/Documents/wasmer-workspace:/root/wasmer-workspace wasmer run /root/wasmer-workspace/examples/hello.wasm`
-
-### Profiling
-1. Build `wasmer-debug-env`:
-   `docker build --tag=wasmer-debug-env --target wasmer-debug-env .`
-
-2. Mount a directory from the host and run interactively:
-   `docker run -it -v /Users/admin/Documents/wasmer-workspace:/home/circleci/wasmer-workspace wasmer-debug-env /bin/bash`
-
-3. Inside the container, build `wasmer` and run profiling tool:
-```
-cd /home/circleci/wasmer-workspace/wasmer`
-cargo build
-valgrind --tool=callgrind --dump-instr=yes --collect-jumps=yes --simulate-cache=yes target/debug/wasmer run test.wasm
-```
-
-The `callgrind.out` can be viewed with the `qcachegrind` tool on Mac OS (`brew install qcachegrind`).
-

examples/callback-guest/README.md

@@ -0,0 +1,5 @@
+# Call back guest
+
+This is part of the `callback` example.  This Wasm module passes host imports and its own functions to the Wasm host to execute.
+
+See `examples/callback.rs` for the host

examples/callback-guest/callback-guest.rs

@@ -0,0 +1,24 @@
+extern "C" {
+    fn call_guest_fn(f: u32) -> u32;
+    fn call_guest_fn2(f: u32) -> u32;
+    fn host_callback() -> u32;
+}
+
+#[no_mangle]
+fn test_callback() -> u32 {
+    42
+}
+
+#[no_mangle]
+fn test_callback2() -> u32 {
+    45
+}
+
+fn main() {
+    unsafe { call_guest_fn(test_callback as usize as u32) };
+    unsafe { call_guest_fn(host_callback as usize as u32) };
+    unsafe { call_guest_fn(test_callback2 as usize as u32) };
+    unsafe { call_guest_fn2(test_callback2 as usize as u32) };
+    unsafe { call_guest_fn2(test_callback as usize as u32) };
+    unsafe { call_guest_fn2(host_callback as usize as u32) };
+}

examples/callback.rs

@@ -0,0 +1,45 @@
+/// This example demonstrates the use of callbacks: calling functions (Host and Wasm)
+/// passed to us from the Wasm via hostcall
+use wasmer::{compiler::compile, func, imports, vm::Ctx, Func};
+use wasmer_runtime_core::{structures::TypedIndex, types::TableIndex};
+
+static WASM: &'static str = "examples/callback-guest/callback-guest.wasm";
+
+/// This function matches our arbitrarily decided callback signature
+/// in this example we'll only call functions that take no arguments and return one value
+fn host_callback(_ctx: &mut Ctx) -> u32 {
+    55
+}
+
+fn call_guest_fn(ctx: &mut Ctx, guest_fn: u32) -> u32 {
+    // We get a TableIndex from our raw value passed in
+    let guest_fn_typed = TableIndex::new(guest_fn as usize);
+    // and use it to call the corresponding function
+    let result = ctx.call_with_table_index(guest_fn_typed, &[]).unwrap();
+
+    println!("Guest fn {} returned {:?}", guest_fn, result);
+
+    0
+}
+
+fn main() {
+    let wasm_bytes =
+        std::fs::read(WASM).expect(&format!("Could not read in WASM plugin at {}", WASM));
+
+    let imports = imports! {
+        "env" => {
+            "call_guest_fn" => func!(call_guest_fn),
+            "call_guest_fn2" => func!(call_guest_fn),
+            "host_callback" => func!(host_callback),
+        },
+    };
+
+    let module = compile(&wasm_bytes[..]).unwrap();
+    let instance = module
+        .instantiate(&imports)
+        .expect("failed to instantiate wasm module");
+
+    let entry_point: Func<(u32, u32), u32> = instance.exports.get("main").unwrap();
+
+    entry_point.call(0, 0).expect("START");
+}

examples/fib.wat

@@ -0,0 +1,20 @@
+(module
+    (func $main (result i32)
+        (call $fib (i32.const 40))
+    )
+
+    (func $fib (param $n i32) (result i32)
+        (if (i32.eq (get_local $n) (i32.const 0))
+            (then (return (i32.const 1)))
+        )
+        (if (i32.eq (get_local $n) (i32.const 1))
+            (then (return (i32.const 1)))
+        )
+        (i32.add
+            (call $fib (i32.sub (get_local $n) (i32.const 1)))
+            (call $fib (i32.sub (get_local $n) (i32.const 2)))
+        )
+    )
+
+    (export "main" (func $main))
+)

examples/hello_world/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "hello_world"
+version = "0.1.0"
+authors = ["losfair <zhy20000919@hotmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

examples/hello_world/src/main.rs

@@ -0,0 +1,7 @@
+fn main() {
+    for i in 0..8 {
+        let s = format!("Hello, {}", i);
+        println!("{}", s);
+    }
+    panic!("OK");
+}

examples/iterative_hash/Cargo.lock

@@ -0,0 +1,74 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "blake2"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "byte-tools"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "crypto-mac"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "digest"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "iterative_hash"
+version = "0.1.0"
+dependencies = [
+ "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "opaque-debug"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "subtle"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "typenum"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[metadata]
+"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
+"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
+"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
+"checksum generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
+"checksum opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "93f5bb2e8e8dec81642920ccff6b61f1eb94fa3020c5a325c9851ff604152409"
+"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
+"checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"

examples/iterative_hash/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "iterative_hash"
+version = "0.1.0"
+authors = ["losfair <zhy20000919@hotmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]
+blake2 = "0.8"

examples/iterative_hash/src/main.rs

@@ -0,0 +1,29 @@
+use blake2::{Blake2b, Digest};
+use std::time::{Duration, SystemTime};
+
+fn main() {
+    let mut data: Vec<u8> = b"test".to_vec();
+    let now = SystemTime::now();
+
+    let mut last_millis: u128 = 0;
+    let mut round_count: usize = 0;
+    let mut record_count: usize = 0;
+
+    for i in 0.. {
+        let mut hasher = Blake2b::new();
+        hasher.input(&data);
+        let out = hasher.result();
+        data = out.to_vec();
+
+        if i != 0 && i % 1000 == 0 {
+            let millis = now.elapsed().unwrap().as_millis();
+            let diff = millis - last_millis;
+            if diff >= 100 {
+                record_count += 1;
+                println!("{}", ((i - round_count) as u128) * 1000000 / diff );
+                last_millis = millis;
+                round_count = i;
+            }
+        }
+    }
+}

examples/many_params.wat

@@ -0,0 +1,57 @@
+;; Test case for correctness of reading state with the presence of parameters passed on (machine) stack.
+;; Usage: Run with a backend with support for OSR. Interrupt execution randomly.
+;; Should see the stack frame for `$foo` to have locals `[0] = 1, [1] = 2, [2] = 3, [3] = 4, [4] = 5, [5] = 6, [6] = 7, [7] = 8` with high probability.
+;; If the logic for reading stack parameters is broken, it's likely to see `[0] = 1, [1] = 2, [2] = 3, [3] = 4, [4] = 5, [5] = ?, [6] = ?, [7] = ?`.
+
+(module
+    (import "wasi_unstable" "proc_exit" (func $__wasi_proc_exit (param i32)))
+    (func $long_running
+        (local $count i32)
+        (loop
+            (if (i32.eq (get_local $count) (i32.const 1000000)) (then (return)))
+            (set_local $count (i32.add (i32.const 1) (get_local $count)))
+            (br 0)
+        )
+        (unreachable)
+    )
+
+    (func $foo (param i32) (param i64) (param i32) (param i32) (param i32) (param i64) (param i64) (param i64) (result i32)
+        (set_local 2 (i32.const 3))
+        (call $long_running)
+        (i32.add
+            (i32.mul (i32.const 2) (get_local 0))
+            (i32.add
+                (i32.mul (i32.const 3) (i32.wrap/i64 (get_local 1)))
+                (i32.add
+                    (i32.mul (i32.const 5) (get_local 2))
+                    (i32.add
+                        (i32.mul (i32.const 7) (get_local 3))
+                        (i32.add
+                            (i32.mul (i32.const 11) (get_local 4))
+                            (i32.add
+                                (i32.mul (i32.const 13) (i32.wrap/i64 (get_local 5)))
+                                (i32.add
+                                    (i32.mul (i32.const 17) (i32.wrap/i64 (get_local 6)))
+                                    (i32.mul (i32.const 19) (i32.wrap/i64 (get_local 7)))
+                                )
+                            )
+                        )
+                    )
+                )
+            )
+        )
+    )
+    (func $_start (export "_start")
+        (local $count i32)
+        (loop
+            (if (i32.eq (get_local $count) (i32.const 10000)) (then (return)))
+            (set_local $count (i32.add (i32.const 1) (get_local $count)))
+            (call $foo (i32.const 1) (i64.const 2) (i32.const 30) (i32.const 4) (i32.const 5) (i64.const 6) (i64.const 7) (i64.const 8))
+            (if (i32.ne (i32.const 455))
+                (then unreachable)
+            )
+            (br 0)
+        )
+        (unreachable)
+    )
+)

examples/no_abi_simple_plugin.rs

@@ -0,0 +1,11 @@
+extern "C" {
+    fn it_works() -> i32;
+}
+
+#[no_mangle]
+pub fn plugin_entrypoint(n: i32) -> i32 {
+    let result = unsafe { it_works() };
+    result + n
+}
+
+fn main() {}

examples/parallel-guest/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "parallel-guest"
+version = "0.1.0"
+authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
+license = "MIT"
+edition = "2018"
+publish = false
+
+[dependencies]
+md5 = "0.6"
+lazy_static = "1"

examples/parallel-guest/src/main.rs

@@ -0,0 +1,82 @@
+#[macro_use]
+extern crate lazy_static;
+
+extern "C" {
+    fn get_hashed_password(ptr: u32, len: u32) -> u32;
+    fn print_char(c: u32);
+}
+
+fn print_str(s: &str) {
+    for c in s.chars() {
+        unsafe { print_char(c as u32) };
+    }
+    unsafe { print_char(b'\n' as u32) };
+}
+
+fn load_hashed_password() -> Option<String> {
+    let mut buffer = String::with_capacity(32);
+    for _ in 0..32 {
+        buffer.push(0 as char);
+    }
+    let result =
+        unsafe { get_hashed_password(buffer.as_mut_ptr() as u32, buffer.capacity() as u32) };
+
+    if result == 0 {
+        Some(buffer)
+    } else {
+        None
+    }
+}
+
+lazy_static! {
+    static ref HASHED_PASSWORD: String = load_hashed_password().unwrap();
+}
+
+static PASSWORD_CHARS: &'static [u8] = b"abcdefghijklmnopqrstuvwxyz0123456789";
+
+// for simplicty we define a scheme for mapping numbers onto passwords
+fn num_to_password(mut num: u64) -> String {
+    let mut extra_zero = num == 0;
+    let mut out = String::new();
+    while num > 0 {
+        out.push(PASSWORD_CHARS[num as usize % PASSWORD_CHARS.len()] as char);
+        extra_zero = extra_zero || num == PASSWORD_CHARS.len() as u64;
+        num /= PASSWORD_CHARS.len() as u64;
+    }
+
+    if extra_zero {
+        out.push(PASSWORD_CHARS[0] as char);
+    }
+
+    out
+}
+
+#[repr(C)]
+struct RetStr {
+    ptr: u32,
+    len: u32,
+}
+
+// returns a (pointer, len) to the password or null
+#[no_mangle]
+fn check_password(from: u64, to: u64) -> u64 {
+    for i in from..to {
+        let password = num_to_password(i);
+        let digest = md5::compute(&password);
+
+        let hash_as_str = format!("{:x}", digest);
+        if hash_as_str == *HASHED_PASSWORD {
+            let ret = RetStr {
+                ptr: password.as_ptr() as usize as u32,
+                len: password.len() as u32,
+            };
+            // leak the data so ending the function doesn't corrupt it, if we cared the host could free it after
+            std::mem::forget(password);
+            return unsafe { std::mem::transmute(ret) };
+        }
+    }
+
+    return 0;
+}
+
+fn main() {}

examples/parallel/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "parallel"
+version = "0.1.0"
+authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+repository = "https://github.com/wasmerio/wasmer"
+publish = false
+license = "MIT"
+
+[dependencies]
+rayon = "1.2"
+time = "0.1"
+wasmer-runtime = { path = "../../lib/runtime" }
+wasmer-runtime-core = { path = "../../lib/runtime-core" }

examples/parallel/README.md

@@ -0,0 +1,5 @@
+# Parallel Wasmer example
+
+This example shows executing independent code from multiple threads on an "embarassingly parallel" problem
+
+This is a toy example of cracking md5 hashes.  This is not a benchmark.  This example is not optimized, it will compare poorly to an implementation that is.

examples/parallel/src/main.rs

@@ -0,0 +1,140 @@
+use rayon::prelude::*;
+use wasmer_runtime::{
+    compile_with, compiler_for_backend, func, imports, instantiate, Backend, Func,
+};
+use wasmer_runtime_core::{
+    memory::ptr::{Array, WasmPtr},
+    vm::Ctx,
+};
+
+static PLUGIN_LOCATION: &'static str = "../parallel-guest.wasm";
+
+fn get_hashed_password(ctx: &mut Ctx, ptr: WasmPtr<u8, Array>, len: u32) -> u32 {
+    // "hard" password - 7 characters
+    //let password = b"2ab96390c7dbe3439de74d0c9b0b1767";
+    // "easy" password - 5 characters
+    let password = b"ab56b4d92b40713acc5af89985d4b786";
+    let memory = ctx.memory(0);
+    if let Some(writer) = ptr.deref(memory, 0, len) {
+        for (i, byte) in password.iter().enumerate() {
+            writer[i].set(*byte)
+        }
+
+        0
+    } else {
+        u32::max_value()
+    }
+}
+
+#[repr(C)]
+struct RetStr {
+    ptr: u32,
+    len: u32,
+}
+
+fn print_char(_cxt: &mut Ctx, c: u32) {
+    print!("{}", c as u8 as char);
+}
+
+fn main() {
+    let wasm_bytes = std::fs::read(PLUGIN_LOCATION).expect(&format!(
+        "Could not read in WASM plugin at {}",
+        PLUGIN_LOCATION
+    ));
+
+    let imports = imports! {
+        "env" => {
+            "get_hashed_password" => func!(get_hashed_password),
+            "print_char" => func!(print_char),
+        },
+    };
+    let compiler = compiler_for_backend(Backend::default()).unwrap();
+    let module = compile_with(&wasm_bytes[..], compiler.as_ref()).unwrap();
+
+    println!("Parallel");
+    let start_ts = time::SteadyTime::now();
+    for outer in 0..1000u64 {
+        let start = outer * 1000;
+        let end = start + 1000;
+        let out = (start..=end)
+            .into_par_iter()
+            .filter_map(|i| {
+                let instance = module
+                    .clone()
+                    .instantiate(&imports)
+                    .expect("failed to instantiate wasm module");
+                let check_password: Func<(u64, u64), u64> =
+                    instance.exports.get("check_password").unwrap();
+                let j = i * 10000;
+                let result = check_password.call(j, j + 10000).unwrap();
+                print!(".");
+                use std::io::Write;
+                std::io::stdout().flush().unwrap();
+                if result != 0 {
+                    let res: RetStr = unsafe { std::mem::transmute(result) };
+
+                    let ctx = instance.context();
+                    let memory = ctx.memory(0);
+                    let wasm_ptr: WasmPtr<u8, Array> = WasmPtr::new(res.ptr);
+                    let password_str = wasm_ptr
+                        .get_utf8_string(memory, res.len)
+                        .unwrap()
+                        .to_string();
+                    Some(password_str)
+                } else {
+                    None
+                }
+            })
+            .find_first(|_: &String| true);
+        if out.is_some() {
+            let end_ts = time::SteadyTime::now();
+            let delta = end_ts - start_ts;
+            println!(
+                "Password cracked: \"{}\" in {}.{:03}",
+                out.unwrap(),
+                delta.num_seconds(),
+                (delta.num_milliseconds() % 1000),
+            );
+            break;
+        }
+    }
+
+    println!("Serial:");
+    let start_ts = time::SteadyTime::now();
+    let instance =
+        instantiate(&wasm_bytes[..], &imports).expect("failed to instantiate wasm module");
+
+    let check_password: Func<(u64, u64), u64> = instance.exports.get("check_password").unwrap();
+
+    let mut out: Option<RetStr> = None;
+    for i in (0..=u64::max_value()).step_by(10000) {
+        let result = check_password.call(i, i + 10000).unwrap();
+        print!(".");
+        use std::io::Write;
+        std::io::stdout().flush().unwrap();
+        if result != 0 {
+            out = Some(unsafe { std::mem::transmute(result) });
+            break;
+        }
+    }
+    println!("");
+
+    if let Some(res) = out {
+        let ctx = instance.context();
+        let memory = ctx.memory(0);
+        let wasm_ptr: WasmPtr<u8, Array> = WasmPtr::new(res.ptr);
+
+        let password_str = wasm_ptr.get_utf8_string(memory, res.len).unwrap();
+
+        let end_ts = time::SteadyTime::now();
+        let delta = end_ts - start_ts;
+        println!(
+            "Password cracked: \"{}\" in {}.{:03}",
+            password_str,
+            delta.num_seconds(),
+            (delta.num_milliseconds() % 1000),
+        );
+    } else {
+        println!("Password not found!");
+    }
+}

examples/plugin-for-example/Cargo.toml

@@ -2,6 +2,7 @@
 name = "plugin-for-example"
 version = "0.1.0"
 authors = ["The Wasmer Engineering Team <enigneering@wasmer.io>"]
+license = "MIT"
 edition = "2018"
 
 [dependencies]

examples/plugin.rs

@@ -1,6 +1,11 @@
-use wasmer_runtime::{func, imports, instantiate};
-use wasmer_runtime_core::vm::Ctx;
-use wasmer_wasi::generate_import_object;
+use serde::{Deserialize, Serialize};
+use wasmer::compiler::compile;
+use wasmer::{func, imports, vm::Ctx, Func};
+use wasmer_wasi::{
+    generate_import_object_for_version,
+    state::{self, WasiFile, WasiFsError},
+    types,
+};
 
 static PLUGIN_LOCATION: &'static str = "examples/plugin-for-example.wasm";
 
@@ -9,15 +14,135 @@ fn it_works(_ctx: &mut Ctx) -> i32 {
     5
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct LoggingWrapper {
+    pub wasm_module_name: String,
+}
+
+// std io trait boiler plate so we can implement WasiFile
+// LoggingWrapper is a write-only type so we just want to immediately
+// fail when reading or Seeking
+impl std::io::Read for LoggingWrapper {
+    fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "can not read from logging wrapper",
+        ))
+    }
+    fn read_to_end(&mut self, _buf: &mut Vec<u8>) -> std::io::Result<usize> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "can not read from logging wrapper",
+        ))
+    }
+    fn read_to_string(&mut self, _buf: &mut String) -> std::io::Result<usize> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "can not read from logging wrapper",
+        ))
+    }
+    fn read_exact(&mut self, _buf: &mut [u8]) -> std::io::Result<()> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "can not read from logging wrapper",
+        ))
+    }
+}
+impl std::io::Seek for LoggingWrapper {
+    fn seek(&mut self, _pos: std::io::SeekFrom) -> std::io::Result<u64> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "can not seek logging wrapper",
+        ))
+    }
+}
+impl std::io::Write for LoggingWrapper {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        let stdout = std::io::stdout();
+        let mut out = stdout.lock();
+        out.write(b"[")?;
+        out.write(self.wasm_module_name.as_bytes())?;
+        out.write(b"]: ")?;
+        out.write(buf)
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        std::io::stdout().flush()
+    }
+    fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
+        let stdout = std::io::stdout();
+        let mut out = stdout.lock();
+        out.write(b"[")?;
+        out.write(self.wasm_module_name.as_bytes())?;
+        out.write(b"]: ")?;
+        out.write_all(buf)
+    }
+    fn write_fmt(&mut self, fmt: std::fmt::Arguments) -> std::io::Result<()> {
+        let stdout = std::io::stdout();
+        let mut out = stdout.lock();
+        out.write(b"[")?;
+        out.write(self.wasm_module_name.as_bytes())?;
+        out.write(b"]: ")?;
+        out.write_fmt(fmt)
+    }
+}
+
+// the WasiFile methods aren't relevant for a write-only Stdout-like implementation
+// we must use typetag and serde so that our trait objects can be safely Serialized and Deserialized
+#[typetag::serde]
+impl WasiFile for LoggingWrapper {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _len: u64) -> Result<(), WasiFsError> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), WasiFsError> {
+        Ok(())
+    }
+    fn bytes_available(&self) -> Result<usize, WasiFsError> {
+        // return an arbitrary amount
+        Ok(1024)
+    }
+}
+
+/// Called by the program when it wants to set itself up
+fn initialize(ctx: &mut Ctx) {
+    let state = unsafe { state::get_wasi_state(ctx) };
+    let wasi_file_inner = LoggingWrapper {
+        wasm_module_name: "example module name".to_string(),
+    };
+    // swap stdout with our new wasifile
+    let _old_stdout = state
+        .fs
+        .swap_file(types::__WASI_STDOUT_FILENO, Box::new(wasi_file_inner))
+        .unwrap();
+}
+
 fn main() {
     // Load the plugin data
     let wasm_bytes = std::fs::read(PLUGIN_LOCATION).expect(&format!(
         "Could not read in WASM plugin at {}",
         PLUGIN_LOCATION
     ));
+    let module = compile(&wasm_bytes).expect("wasm compilation");
+
+    // get the version of the WASI module in a non-strict way, meaning we're
+    // allowed to have extra imports
+    let wasi_version = wasmer_wasi::get_wasi_version(&module, false)
+        .expect("WASI version detected from Wasm module");
 
     // WASI imports
-    let mut base_imports = generate_import_object(vec![], vec![], vec![], vec![]);
+    let mut base_imports =
+        generate_import_object_for_version(wasi_version, vec![], vec![], vec![], vec![]);
     // env is the default namespace for extern functions
     let custom_imports = imports! {
         "env" => {
@@ -27,11 +152,14 @@ fn main() {
     // The WASI imports object contains all required import functions for a WASI module to run.
     // Extend this imports with our custom imports containing "it_works" function so that our custom wasm code may run.
     base_imports.extend(custom_imports);
-    let instance =
-        instantiate(&wasm_bytes[..], &base_imports).expect("failed to instantiate wasm module");
+    let mut instance = module
+        .instantiate(&base_imports)
+        .expect("failed to instantiate wasm module");
+    // set up logging by replacing stdout
+    initialize(instance.context_mut());
 
     // get a reference to the function "plugin_entrypoint" which takes an i32 and returns an i32
-    let entry_point = instance.func::<(i32), i32>("plugin_entrypoint").unwrap();
+    let entry_point: Func<i32, i32> = instance.exports.get("plugin_entrypoint").unwrap();
     // call the "entry_point" function in WebAssembly with the number "2" as the i32 argument
     let result = entry_point.call(2).expect("failed to execute plugin");
     println!("result: {}", result);

examples/simple/main.rs

@@ -1,53 +1,20 @@
 use wabt::wat2wasm;
-use wasmer_runtime_core::{
-    backend::Compiler,
-    error,
-    global::Global,
-    memory::Memory,
-    prelude::*,
-    table::Table,
+use wasmer_runtime::{
+    compile, error, func, imports,
     types::{ElementType, MemoryDescriptor, TableDescriptor, Value},
     units::Pages,
+    Ctx, Global, Memory, Table,
 };
 
-#[cfg(feature = "clif")]
-fn get_compiler() -> impl Compiler {
-    use wasmer_clif_backend::CraneliftCompiler;
-    CraneliftCompiler::new()
-}
-
-#[cfg(feature = "llvm")]
-fn get_compiler() -> impl Compiler {
-    use wasmer_llvm_backend::LLVMCompiler;
-    LLVMCompiler::new()
-}
-
-#[cfg(feature = "singlepass")]
-fn get_compiler() -> impl Compiler {
-    use wasmer_singlepass_backend::SinglePassCompiler;
-    SinglePassCompiler::new()
-}
-
-#[cfg(not(any(feature = "llvm", feature = "clif", feature = "singlepass")))]
-fn get_compiler() -> impl Compiler {
-    panic!("compiler not specified, activate a compiler via features");
-    use wasmer_clif_backend::CraneliftCompiler;
-    CraneliftCompiler::new()
-}
-
 static EXAMPLE_WASM: &'static [u8] = include_bytes!("simple.wasm");
 
 fn main() -> error::Result<()> {
     let wasm_binary = wat2wasm(IMPORT_MODULE.as_bytes()).expect("WAST not valid or malformed");
 
-    let inner_module = wasmer_runtime_core::compile_with(&wasm_binary, &get_compiler())?;
+    let inner_module = compile(&wasm_binary)?;
 
-    let memory = Memory::new(MemoryDescriptor {
-        minimum: Pages(1),
-        maximum: Some(Pages(1)),
-        shared: false,
-    })
-    .unwrap();
+    let memory_desc = MemoryDescriptor::new(Pages(1), Some(Pages(1)), false).unwrap();
+    let memory = Memory::new(memory_desc).unwrap();
 
     let global = Global::new(Value::I32(42));
 
@@ -75,7 +42,7 @@ fn main() -> error::Result<()> {
         "env" => inner_instance,
     };
 
-    let outer_module = wasmer_runtime_core::compile_with(EXAMPLE_WASM, &get_compiler())?;
+    let outer_module = compile(EXAMPLE_WASM)?;
     let outer_instance = outer_module.instantiate(&outer_imports)?;
     let ret = outer_instance.call("main", &[Value::I32(42)])?;
     println!("ret: {:?}", ret);
@@ -83,7 +50,7 @@ fn main() -> error::Result<()> {
     Ok(())
 }
 
-fn print_num(ctx: &mut vm::Ctx, n: i32) -> Result<i32, ()> {
+fn print_num(ctx: &mut Ctx, n: i32) -> Result<i32, ()> {
     println!("print_num({})", n);
 
     let memory: &Memory = ctx.memory(0);

examples/trie_traversal/trie_traversal.rs

@@ -0,0 +1,67 @@
+#[link(wasm_import_module = "wasmer_suspend")]
+extern "C" {
+    fn suspend();
+}
+
+use std::collections::BTreeMap;
+
+#[derive(Default)]
+struct Node {
+    count: usize,
+    children: BTreeMap<char, Node>,
+}
+
+impl Node {
+    fn insert(&mut self, mut s: impl Iterator<Item = char>) {
+        match s.next() {
+            Some(x) => {
+                self.children.entry(x).or_default().insert(s);
+            }
+            None => {
+                self.count += 1;
+            }
+        }
+    }
+
+    fn for_each_dyn(&self, cb: &dyn Fn(&str, usize), prefix: &mut String) {
+        if self.count > 0 {
+            cb(&prefix, self.count);
+        }
+
+        for (k, v) in self.children.iter() {
+            prefix.push(*k);
+            v.for_each_dyn(cb, prefix);
+            prefix.pop().unwrap();
+        }
+    }
+}
+
+fn main() {
+    let mut root = Node::default();
+    root.insert("Ava".chars());
+    root.insert("Alexander".chars());
+    root.insert("Aiden".chars());
+    root.insert("Bella".chars());
+    root.insert("Brianna".chars());
+    root.insert("Brielle".chars());
+    root.insert("Charlotte".chars());
+    root.insert("Chloe".chars());
+    root.insert("Camila".chars());
+
+    println!("Tree ready, suspending.");
+    unsafe {
+        suspend();
+    }
+
+    root.for_each_dyn(
+        &|seq, count| {
+            println!("{}: {}", seq, count);
+            unsafe {
+                suspend();
+            }
+        },
+        &mut "".into(),
+    );
+
+    println!("[END]");
+}

fuzz/.gitignore

@@ -0,0 +1,4 @@
+
+target
+corpus
+artifacts

fuzz/Cargo.toml

@@ -0,0 +1,33 @@
+
+[package]
+name = "wasmer-fuzz"
+version = "0.0.1"
+authors = ["Automatically generated"]
+publish = false
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+wasmer-runtime = { path = "../lib/runtime" }
+wasmer-runtime-core = { path = "../lib/runtime-core" }
+wasmer = { path = "../" }
+wasmer-llvm-backend = { path = "../lib/llvm-backend" }
+wasmer-singlepass-backend = { path = "../lib/singlepass-backend" }
+libfuzzer-sys = { git = "https://github.com/rust-fuzz/libfuzzer-sys.git" }
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "simple_instantiate"
+path = "fuzz_targets/simple_instantiate.rs"
+
+[[bin]]
+name = "validate_wasm"
+path = "fuzz_targets/validate_wasm.rs"
+
+[[bin]]
+name = "compile_wasm"
+path = "fuzz_targets/compile_wasm.rs"

fuzz/README.md

@@ -0,0 +1,59 @@
+This directory contains the fuzz tests for wasmer. To fuzz, we use the `cargo-fuzz` package.
+
+## Installation
+
+You may need to install the `cargo-fuzz` package to get the `cargo fuzz` subcommand. Use
+
+```sh
+$ cargo install cargo-fuzz
+```
+
+`cargo-fuzz` is documented in the [Rust Fuzz Book](https://rust-fuzz.github.io/book/cargo-fuzz.html).
+
+## Running a fuzzer (simple_instantiate, validate_wasm, compile_wasm)
+
+Once `cargo-fuzz` is installed, you can run the `simple_instantiate` fuzzer with
+```sh
+cargo fuzz run simple_instantiate
+```
+or the `validate_wasm` fuzzer
+```sh
+cargo fuzz run validate_wasm
+```
+or the `compile_wasm` fuzzer
+```sh
+cargo fuzz run compile_wasm
+```
+
+You should see output that looks something like this:
+
+```
+INFO: Seed: 3276026494
+INFO:        8 files found in wasmer/fuzz/corpus/simple_instantiate
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+INFO: seed corpus: files: 8 min: 1b max: 1b total: 8b rss: 133Mb
+#9      INITED ft: 3 corp: 3/3b lim: 4 exec/s: 0 rss: 142Mb
+#23     NEW    ft: 4 corp: 4/5b lim: 4 exec/s: 0 rss: 142Mb L: 2/2 MS: 4 ChangeByte-InsertByte-ShuffleBytes-ChangeBit-
+#25     NEW    ft: 5 corp: 5/6b lim: 4 exec/s: 0 rss: 142Mb L: 1/2 MS: 2 ChangeBinInt-ChangeBit-
+#27     NEW    ft: 6 corp: 6/9b lim: 4 exec/s: 0 rss: 142Mb L: 3/3 MS: 2 InsertByte-ChangeByte-
+#190    REDUCE ft: 6 corp: 6/7b lim: 4 exec/s: 0 rss: 142Mb L: 1/2 MS: 3 ChangeBit-EraseBytes-CrossOver-
+#205    REDUCE ft: 7 corp: 7/11b lim: 4 exec/s: 0 rss: 142Mb L: 4/4 MS: 5 ShuffleBytes-CrossOver-InsertByte-ChangeBinInt-CrossOver-
+```
+It will continue to generate random inputs forever, until it finds a bug or is terminated. The testcases for bugs it finds go into `fuzz/artifacts/simple_instantiate` and you can rerun the fuzzer on a single input by passing it on the command line `cargo fuzz run simple_instantiate my_testcase.wasm`.
+
+## Seeding the corpus, optional
+
+The fuzzer works best when it has examples of small Wasm files to start with. Using `wast2json` from [wabt](https://github.com/WebAssembly/wabt), we can easily produce `.wasm` files out of the WebAssembly spec tests.
+
+```sh
+mkdir spec-test-corpus
+for i in lib/spectests/spectests/*.wast; do wast2json --enable-all $i -o spec-test-corpus/$(basename $i).json; done
+mv spec-test-corpus/*.wasm fuzz/corpus/simple_instantiate/
+rm -r spec-test-corpus
+```
+
+The corpus directory is created on the first run of the fuzzer. If it doesn't exist, run it first and then seed the corpus. The fuzzer will pick up new files added to the corpus while it is running.
+
+## Trophy case
+
+- [x] https://github.com/wasmerio/wasmer/issues/558

fuzz/fuzz_targets/compile_wasm.rs

@@ -0,0 +1,25 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+extern crate wasmer_runtime;
+extern crate wasmer_runtime_core;
+extern crate wasmer_llvm_backend;
+extern crate wasmer_singlepass_backend;
+
+use wasmer_runtime::{compile, compile_with};
+use wasmer_runtime_core::backend::Compiler;
+
+fn get_llvm_compiler() -> impl Compiler {
+    use wasmer_llvm_backend::LLVMCompiler;
+    LLVMCompiler::new()
+}
+fn get_singlepass_compiler() -> impl Compiler {
+    use wasmer_singlepass_backend::SinglePassCompiler;
+    SinglePassCompiler::new()
+}
+
+fuzz_target!(|data: &[u8]| {
+    let _ = compile_with(data, &get_llvm_compiler());
+    let _ = compile(data);
+    let _ = compile_with(data, &get_singlepass_compiler());
+});

fuzz/fuzz_targets/simple_instantiate.rs

@@ -0,0 +1,11 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+extern crate wasmer_runtime;
+
+use wasmer_runtime::{imports, instantiate};
+
+fuzz_target!(|data: &[u8]| {
+    let import_object = imports! {};
+    instantiate(data, &import_object);
+});

fuzz/fuzz_targets/validate_wasm.rs

@@ -0,0 +1,20 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+
+extern crate wasmer_bin;
+extern crate wasmer_runtime_core;
+
+use wasmer_runtime_core::backend::Features;
+
+fuzz_target!(|data: &[u8]| {
+    let _ = wasmer_bin::utils::is_wasm_binary(data);
+    let _ = wasmer_runtime_core::validate_and_report_errors_with_features(
+        &data,
+        Features {
+            // Modify these values to explore additional parts of wasmer.
+            simd: false,
+            threads: false,
+        },
+    );
+});

lib/README.md

@@ -24,6 +24,7 @@ Wasmer intends to support different integrations:
 
 - [WASI](./wasi): run WebAssembly files with the [WASI ABI](https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/).
 - [Emscripten](./emscripten): run Emscripten-generated WebAssembly files, such as [Lua](../examples/lua.wasm) or [nginx](../examples/nginx/nginx.wasm).
+- **Your own ABI**: Do you want to create your own ABI? Here's a [repo showcasing how](https://github.com/wasmerio/wasmer-rust-customabi-example)!
 - Go ABI: _we will work on this soon! Want to give us a hand? ✋_
 - Blazor: _research period, see [tracking issue](https://github.com/wasmerio/wasmer/issues/97)_
 

lib/api/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "wasmer"
+version = "0.17.0"
+authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+publish = true
+description = "The high-level public API of the Wasmer WebAssembly runtime"
+readme = "README.md"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+wasmer-runtime-core = { version = "0.17.0", path = "../runtime-core" }
+
+[dependencies.wasmer-singlepass-backend]
+path = "../singlepass-backend"
+version = "0.17.0"
+optional = true
+
+[dependencies.wasmer-llvm-backend]
+path = "../llvm-backend"
+version = "0.17.0"
+optional = true
+
+[dependencies.wasmer-clif-backend]
+path = "../clif-backend"
+version = "0.17.0"
+optional = true
+
+[features]
+# Note: we should have default backends depending on the architecture
+# This target-directed-features is available in nightly
+# https://github.com/rust-lang/cargo/issues/7914
+default = ["cranelift", "default-backend-cranelift"]
+
+singlepass = ["wasmer-singlepass-backend"]
+llvm = ["wasmer-llvm-backend"]
+cranelift = ["wasmer-clif-backend"]
+
+default-backend-singlepass = ["singlepass"]
+default-backend-llvm = ["llvm"]
+default-backend-cranelift = ["cranelift"]
+
+deterministic-execution = ["wasmer-singlepass-backend/deterministic-execution", "wasmer-runtime-core/deterministic-execution"]

lib/api/README.md

@@ -0,0 +1,5 @@
+# Wasmer
+
+Wasmer is a universal WebAssembly runtime.
+
+This crate is not ready to be used directly yet. If you're interested in using the Wasmer runtime, checkout the [wasmer-runtime](https://crates.io/crates/wasmer-runtime) crate!

lib/api/src/lib.rs

@@ -0,0 +1,411 @@
+#![deny(
+    dead_code,
+//    missing_docs,
+    nonstandard_style,
+    unused_imports,
+    unused_mut,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+// Aspirational. I hope to have no unsafe code in this crate.
+#![forbid(unsafe_code)]
+#![doc(html_favicon_url = "https://wasmer.io/static/icons/favicon.ico")]
+#![doc(html_logo_url = "https://avatars3.githubusercontent.com/u/44205449?s=200&v=4")]
+
+//! TODO: Write high value, high-level API intro docs here
+//! Intro/background information
+//!
+//! quick links to places in this document/other crates/standards etc.
+//!
+//! example code, link to projects using it
+//!
+//! more info, what to do if you run into problems
+
+#[macro_use]
+extern crate serde;
+
+pub use crate::module::*;
+pub use wasmer_runtime_core::instance::{DynFunc, Instance};
+pub use wasmer_runtime_core::memory::Memory;
+pub use wasmer_runtime_core::table::Table;
+pub use wasmer_runtime_core::typed_func::DynamicFunc;
+pub use wasmer_runtime_core::Func;
+pub use wasmer_runtime_core::{func, imports};
+
+pub mod module {
+    //! Types and functions for WebAssembly modules.
+    //!
+    //! # Usage
+    //! ## Create a Module
+    //!
+    //! ```
+    //! ```
+    //!
+    //! ## Get the exports from a Module
+    //! ```
+    //! # use wasmer::*;
+    //! # fn get_exports(module: &Module) {
+    //! let exports: Vec<ExportDescriptor> = module.exports().collect();
+    //! # }
+    //! ```
+    // TODO: verify that this is the type we want to export, with extra methods on it
+    pub use wasmer_runtime_core::module::Module;
+    // should this be in here?
+    pub use wasmer_runtime_core::types::{ExportDescriptor, ExternDescriptor, ImportDescriptor};
+    // TODO: implement abstract module API
+}
+
+pub mod memory {
+    //! Types and functions for Wasm linear memory.
+    pub use wasmer_runtime_core::memory::{Atomically, Memory, MemoryView};
+}
+
+pub mod wasm {
+    //! Various types exposed by the Wasmer Runtime relating to Wasm.
+    //!
+    //! TODO: Add index with links to sub sections
+    //
+    //! # Globals
+    //!
+    //! # Tables
+    pub use wasmer_runtime_core::backend::Features;
+    pub use wasmer_runtime_core::export::Export;
+    pub use wasmer_runtime_core::global::Global;
+    pub use wasmer_runtime_core::instance::{DynFunc, Instance};
+    pub use wasmer_runtime_core::memory::Memory;
+    pub use wasmer_runtime_core::module::Module;
+    pub use wasmer_runtime_core::table::Table;
+    pub use wasmer_runtime_core::types::{ExportDescriptor, ExternDescriptor, ImportDescriptor};
+    pub use wasmer_runtime_core::types::{
+        FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type, Value,
+    };
+    pub use wasmer_runtime_core::Func;
+}
+
+pub mod vm {
+    //! Various types exposed by the Wasmer Runtime relating to the VM.
+    pub use wasmer_runtime_core::vm::Ctx;
+}
+
+pub mod compiler {
+    //! Types and functions for compiling wasm;
+    use crate::module::Module;
+    pub use wasmer_runtime_core::backend::{
+        BackendCompilerConfig, Compiler, CompilerConfig, Features,
+    };
+    pub use wasmer_runtime_core::compile_with;
+    #[cfg(unix)]
+    pub use wasmer_runtime_core::fault::{pop_code_version, push_code_version};
+    pub use wasmer_runtime_core::state::CodeVersion;
+
+    /// Enum used to select which compiler should be used to generate code.
+    #[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Backend {
+        #[cfg(feature = "singlepass")]
+        /// Singlepass backend
+        Singlepass,
+        #[cfg(feature = "cranelift")]
+        /// Cranelift backend
+        Cranelift,
+        #[cfg(feature = "llvm")]
+        /// LLVM backend
+        LLVM,
+        /// Auto backend
+        Auto,
+    }
+
+    impl Backend {
+        /// Get a list of the currently enabled (via feature flag) backends.
+        pub fn variants() -> &'static [&'static str] {
+            &[
+                #[cfg(feature = "singlepass")]
+                "singlepass",
+                #[cfg(feature = "cranelift")]
+                "cranelift",
+                #[cfg(feature = "llvm")]
+                "llvm",
+                "auto",
+            ]
+        }
+
+        /// Stable string representation of the backend.
+        /// It can be used as part of a cache key, for example.
+        pub fn to_string(&self) -> &'static str {
+            match self {
+                #[cfg(feature = "singlepass")]
+                Backend::Singlepass => "singlepass",
+                #[cfg(feature = "cranelift")]
+                Backend::Cranelift => "cranelift",
+                #[cfg(feature = "llvm")]
+                Backend::LLVM => "llvm",
+                Backend::Auto => "auto",
+            }
+        }
+    }
+
+    impl Default for Backend {
+        fn default() -> Self {
+            #[cfg(all(feature = "default-backend-singlepass", not(feature = "docs")))]
+            return Backend::Singlepass;
+
+            #[cfg(any(feature = "default-backend-cranelift", feature = "docs"))]
+            return Backend::Cranelift;
+
+            #[cfg(all(feature = "default-backend-llvm", not(feature = "docs")))]
+            return Backend::LLVM;
+        }
+    }
+
+    impl std::str::FromStr for Backend {
+        type Err = String;
+        fn from_str(s: &str) -> Result<Backend, String> {
+            match s.to_lowercase().as_str() {
+                #[cfg(feature = "singlepass")]
+                "singlepass" => Ok(Backend::Singlepass),
+                #[cfg(feature = "cranelift")]
+                "cranelift" => Ok(Backend::Cranelift),
+                #[cfg(feature = "llvm")]
+                "llvm" => Ok(Backend::LLVM),
+                "auto" => Ok(Backend::Auto),
+                _ => Err(format!("The backend {} doesn't exist", s)),
+            }
+        }
+    }
+
+    /// Compile WebAssembly binary code into a [`Module`].
+    /// This function is useful if it is necessary to
+    /// compile a module before it can be instantiated
+    /// (otherwise, the [`instantiate`] function should be used).
+    ///
+    /// [`Module`]: struct.Module.html
+    /// [`instantiate`]: fn.instantiate.html
+    ///
+    /// # Params:
+    /// * `wasm`: A `&[u8]` containing the
+    ///   binary code of the wasm module you want to compile.
+    /// # Errors:
+    /// If the operation fails, the function returns `Err(error::CompileError::...)`.
+    pub fn compile(wasm: &[u8]) -> crate::error::CompileResult<Module> {
+        wasmer_runtime_core::compile_with(&wasm[..], &default_compiler())
+    }
+
+    /// The same as `compile` but takes a `CompilerConfig` for the purpose of
+    /// changing the compiler's behavior
+    pub fn compile_with_config(
+        wasm: &[u8],
+        compiler_config: CompilerConfig,
+    ) -> crate::error::CompileResult<Module> {
+        wasmer_runtime_core::compile_with_config(&wasm[..], &default_compiler(), compiler_config)
+    }
+
+    /// The same as `compile_with_config` but takes a `Compiler` for the purpose of
+    /// changing the backend.
+    pub fn compile_with_config_with(
+        wasm: &[u8],
+        compiler_config: CompilerConfig,
+        compiler: &dyn Compiler,
+    ) -> crate::error::CompileResult<Module> {
+        wasmer_runtime_core::compile_with_config(&wasm[..], compiler, compiler_config)
+    }
+
+    /// Copied from runtime core; TODO: figure out what we want to do here
+    pub fn default_compiler() -> impl Compiler {
+        #[cfg(any(
+            all(
+                feature = "default-backend-llvm",
+                not(feature = "docs"),
+                any(
+                    feature = "default-backend-cranelift",
+                    feature = "default-backend-singlepass"
+                )
+            ),
+            all(
+                not(feature = "docs"),
+                feature = "default-backend-cranelift",
+                feature = "default-backend-singlepass"
+            )
+        ))]
+        compile_error!(
+            "The `default-backend-X` features are mutually exclusive.  Please choose just one"
+        );
+
+        #[cfg(all(feature = "default-backend-llvm", not(feature = "docs")))]
+        use wasmer_llvm_backend::LLVMCompiler as DefaultCompiler;
+
+        #[cfg(all(feature = "default-backend-singlepass", not(feature = "docs")))]
+        use wasmer_singlepass_backend::SinglePassCompiler as DefaultCompiler;
+
+        #[cfg(any(feature = "default-backend-cranelift", feature = "docs"))]
+        use wasmer_clif_backend::CraneliftCompiler as DefaultCompiler;
+
+        DefaultCompiler::new()
+    }
+
+    /// Get the `Compiler` as a trait object for the given `Backend`.
+    /// Returns `Option` because support for the requested `Compiler` may
+    /// not be enabled by feature flags.
+    ///
+    /// To get a list of the enabled backends as strings, call `Backend::variants()`.
+    pub fn compiler_for_backend(backend: Backend) -> Option<Box<dyn Compiler>> {
+        match backend {
+            #[cfg(feature = "cranelift")]
+            Backend::Cranelift => Some(Box::new(wasmer_clif_backend::CraneliftCompiler::new())),
+
+            #[cfg(any(feature = "singlepass"))]
+            Backend::Singlepass => Some(Box::new(
+                wasmer_singlepass_backend::SinglePassCompiler::new(),
+            )),
+
+            #[cfg(feature = "llvm")]
+            Backend::LLVM => Some(Box::new(wasmer_llvm_backend::LLVMCompiler::new())),
+
+            Backend::Auto => {
+                #[cfg(feature = "default-backend-singlepass")]
+                return Some(Box::new(
+                    wasmer_singlepass_backend::SinglePassCompiler::new(),
+                ));
+                #[cfg(feature = "default-backend-cranelift")]
+                return Some(Box::new(wasmer_clif_backend::CraneliftCompiler::new()));
+                #[cfg(feature = "default-backend-llvm")]
+                return Some(Box::new(wasmer_llvm_backend::LLVMCompiler::new()));
+            }
+        }
+    }
+}
+
+pub mod codegen {
+    //! Types and functions for generating native code.
+    pub use wasmer_runtime_core::codegen::ModuleCodeGenerator;
+}
+
+// TODO: `import` or `imports`?
+pub mod import {
+    //! Types and functions for Wasm imports.
+    pub use wasmer_runtime_core::import::{
+        ImportObject, ImportObjectIterator, LikeNamespace, Namespace,
+    };
+    pub use wasmer_runtime_core::types::{ExternDescriptor, ImportDescriptor};
+    pub use wasmer_runtime_core::{func, imports};
+}
+
+pub mod export {
+    //! Types and functions for Wasm exports.
+    pub use wasmer_runtime_core::export::Export;
+    pub use wasmer_runtime_core::types::{ExportDescriptor, ExternDescriptor};
+}
+
+pub mod units {
+    //! Various unit types.
+    pub use wasmer_runtime_core::units::{Bytes, Pages};
+}
+
+pub mod types {
+    //! Types used in the Wasm runtime and conversion functions.
+    pub use wasmer_runtime_core::types::{
+        ElementType, FuncDescriptor, FuncSig, GlobalDescriptor, GlobalInit, MemoryDescriptor,
+        TableDescriptor, Type, Value, ValueType,
+    };
+}
+
+pub mod error {
+    //! Various error types returned by Wasmer APIs.
+    pub use wasmer_runtime_core::backend::ExceptionCode;
+    pub use wasmer_runtime_core::error::{
+        CallError, CompileError, CompileResult, CreationError, Error, LinkError, ResolveError,
+        RuntimeError,
+    };
+
+    #[derive(Debug)]
+    pub enum CompileFromFileError {
+        CompileError(CompileError),
+        IoError(std::io::Error),
+    }
+
+    impl std::fmt::Display for CompileFromFileError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                CompileFromFileError::CompileError(ce) => write!(f, "{}", ce),
+                CompileFromFileError::IoError(ie) => write!(f, "{}", ie),
+            }
+        }
+    }
+
+    impl std::error::Error for CompileFromFileError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            match self {
+                CompileFromFileError::CompileError(ce) => Some(ce),
+                CompileFromFileError::IoError(ie) => Some(ie),
+            }
+        }
+    }
+
+    impl From<CompileError> for CompileFromFileError {
+        fn from(other: CompileError) -> Self {
+            CompileFromFileError::CompileError(other)
+        }
+    }
+    impl From<std::io::Error> for CompileFromFileError {
+        fn from(other: std::io::Error) -> Self {
+            CompileFromFileError::IoError(other)
+        }
+    }
+}
+
+/// Idea for generic trait; consider rename; it will need to be moved somewhere else
+pub trait CompiledModule {
+    fn new(bytes: impl AsRef<[u8]>) -> error::CompileResult<Module>;
+    fn new_with_compiler(
+        bytes: impl AsRef<[u8]>,
+        compiler: Box<dyn compiler::Compiler>,
+    ) -> error::CompileResult<Module>;
+    fn from_binary(bytes: impl AsRef<[u8]>) -> error::CompileResult<Module>;
+    fn from_binary_unchecked(bytes: impl AsRef<[u8]>) -> error::CompileResult<Module>;
+    fn from_file(file: impl AsRef<std::path::Path>) -> Result<Module, error::CompileFromFileError>;
+
+    fn validate(bytes: impl AsRef<[u8]>) -> error::CompileResult<()>;
+}
+
+// this implementation should be moved
+impl CompiledModule for Module {
+    fn new(bytes: impl AsRef<[u8]>) -> error::CompileResult<Module> {
+        let bytes = bytes.as_ref();
+        wasmer_runtime_core::compile_with(bytes, &compiler::default_compiler())
+    }
+
+    fn new_with_compiler(
+        bytes: impl AsRef<[u8]>,
+        compiler: Box<dyn compiler::Compiler>,
+    ) -> error::CompileResult<Module> {
+        let bytes = bytes.as_ref();
+        wasmer_runtime_core::compile_with(bytes, &*compiler)
+    }
+
+    fn from_binary(bytes: impl AsRef<[u8]>) -> error::CompileResult<Module> {
+        let bytes = bytes.as_ref();
+        wasmer_runtime_core::compile_with(bytes, &compiler::default_compiler())
+    }
+
+    fn from_binary_unchecked(bytes: impl AsRef<[u8]>) -> error::CompileResult<Module> {
+        // TODO: optimize this
+        Self::from_binary(bytes)
+    }
+
+    fn from_file(file: impl AsRef<std::path::Path>) -> Result<Module, error::CompileFromFileError> {
+        use std::fs;
+        use std::io::Read;
+        let path = file.as_ref();
+        let mut f = fs::File::open(path)?;
+        // TODO: ideally we can support a streaming compilation API and not have to read in the entire file
+        let mut bytes = vec![];
+        f.read_to_end(&mut bytes)?;
+
+        Ok(Module::from_binary(bytes.as_slice())?)
+    }
+
+    fn validate(bytes: impl AsRef<[u8]>) -> error::CompileResult<()> {
+        // TODO: optimize this
+        let _ = Self::from_binary(bytes)?;
+        Ok(())
+    }
+}

lib/clif-backend/Cargo.toml

@@ -1,40 +1,44 @@
 [package]
 name = "wasmer-clif-backend"
-version = "0.5.3"
+version = "0.17.0"
 description = "Wasmer runtime Cranelift compiler backend"
 license = "MIT"
 authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
 repository = "https://github.com/wasmerio/wasmer"
+keywords = ["wasm", "webassembly", "compiler", "JIT", "AOT"]
+categories = ["wasm"]
 edition = "2018"
+readme = "README.md"
 
 [dependencies]
-wasmer-runtime-core = { path = "../runtime-core", version = "0.5.3" }
-cranelift-native = { git = "https://github.com/wasmerio/cranelift.git", rev = "2ada531d79b34a9e6c94c81f2615677e22d68780" }
-cranelift-codegen = { git = "https://github.com/wasmerio/cranelift.git", rev = "2ada531d79b34a9e6c94c81f2615677e22d68780" }
-cranelift-entity = { git = "https://github.com/wasmerio/cranelift.git", rev = "2ada531d79b34a9e6c94c81f2615677e22d68780" }
-cranelift-frontend = { git = "https://github.com/wasmerio/cranelift.git", rev = "2ada531d79b34a9e6c94c81f2615677e22d68780" }
-cranelift-wasm = { git = "https://github.com/wasmerio/cranelift.git", rev = "2ada531d79b34a9e6c94c81f2615677e22d68780" }
-hashbrown = "0.1"
-target-lexicon = "0.4.0"
-wasmparser = "0.32.1"
-byteorder = "1"
-nix = "0.13.0"
-libc = "0.2.49"
-rayon = "1.0"
+wasmer-runtime-core = { path = "../runtime-core", version = "0.17.0" }
+cranelift-native = "0.59.0"
+cranelift-codegen = "0.59.0"
+cranelift-entity = "0.59.0"
+cranelift-frontend = { package = "wasmer-clif-fork-frontend", version = "0.59.0" } 
+cranelift-wasm = { package = "wasmer-clif-fork-wasm", version = "0.59.0" }
+target-lexicon = "0.10"
+wasmparser = "0.51.3"
+byteorder = "1.3.2"
+nix = "0.15.0"
+libc = "0.2.60"
+rayon = "1.1"
+wasm-debug = { optional = true, version = "0.2" }
 
 # Dependencies for caching.
 [dependencies.serde]
 version = "1.0"
+features = ["rc"]
 [dependencies.serde_derive]
 version = "1.0"
 [dependencies.serde_bytes]
-version = "0.10"
+version = "0.11"
 [dependencies.serde-bench]
 version = "0.0.7"
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3", features = ["errhandlingapi", "minwindef", "minwinbase", "winnt"] }
-wasmer-win-exception-handler = { path = "../win-exception-handler", version = "0.5.3" }
+wasmer-win-exception-handler = { path = "../win-exception-handler", version = "0.17.0" }
 
 [features]
-debug = ["wasmer-runtime-core/debug"]
+generate-debug-information = ["wasm-debug"]

lib/clif-backend/README.md

@@ -1,21 +1,21 @@
 <p align="center">
   <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
-    <img width="400" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/logo.png" alt="Wasmer logo">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
   </a>
 </p>
 
 <p align="center">
-  <a href="https://circleci.com/gh/wasmerio/wasmer/">
-    <img src="https://img.shields.io/circleci/project/github/wasmerio/wasmer/master.svg" alt="Build Status">
+  <a href="https://dev.azure.com/wasmerio/wasmer/_build/latest?definitionId=3&branchName=master">
+    <img src="https://img.shields.io/azure-devops/build/wasmerio/wasmer/3.svg?style=flat-square" alt="Build Status">
   </a>
   <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
-    <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
+    <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square" alt="License">
   </a>
   <a href="https://spectrum.chat/wasmer">
     <img src="https://withspectrum.github.io/badge/badge.svg" alt="Join the Wasmer Community">
   </a>
   <a href="https://crates.io/crates/wasmer-clif-backend">
-    <img src="https://img.shields.io/crates/d/wasmer-clif-backend.svg" alt="Number of downloads from crates.io">
+    <img src="https://img.shields.io/crates/d/wasmer-clif-backend.svg?style=flat-square" alt="Number of downloads from crates.io">
   </a>
   <a href="https://docs.rs/wasmer-clif-backend">
     <img src="https://docs.rs/wasmer-clif-backend/badge.svg" alt="Read our API documentation">
@@ -28,4 +28,26 @@ Wasmer is a standalone JIT WebAssembly runtime, aiming to be fully
 compatible with Emscripten, Rust and Go. [Learn
 more](https://github.com/wasmerio/wasmer).
 
-This crate represents the Cranelift backend.
+This crate represents the Cranelift backend integration for Wasmer.
+
+## Usage
+
+### Usage in Wasmer Standalone
+
+If you are using the `wasmer` CLI, you can specify the backend with:
+
+```sh
+wasmer run program.wasm --backend=cranelift
+```
+
+### Usage in Wasmer Embedded
+
+If you are using Wasmer Embedded, you can specify
+the Cranelift backend to the [`compile_with` function](https://docs.rs/wasmer-runtime-core/*/wasmer_runtime_core/fn.compile_with.html):
+
+```rust
+use wasmer_clif_backend::CraneliftCompiler;
+
+// ...
+let module = wasmer_runtime_core::compile_with(&wasm_binary[..], &CraneliftCompiler::new());
+```

lib/clif-backend/src/cache.rs

@@ -1,6 +1,6 @@
 use crate::relocation::{ExternalRelocation, TrapSink};
 
-use hashbrown::HashMap;
+use std::collections::HashMap;
 use std::sync::Arc;
 use wasmer_runtime_core::{
     backend::{sys::Memory, CacheGen},

lib/clif-backend/src/code.rs

@@ -7,18 +7,19 @@ use crate::{
 };
 
 use cranelift_codegen::entity::EntityRef;
-use cranelift_codegen::ir::{self, Ebb, Function, InstBuilder};
+use cranelift_codegen::ir::{self, Block, Function, InstBuilder};
 use cranelift_codegen::isa::CallConv;
 use cranelift_codegen::{cursor::FuncCursor, isa};
 use cranelift_frontend::{FunctionBuilder, Position, Variable};
-use cranelift_wasm::{self, FuncTranslator};
+use cranelift_wasm::{self, FuncTranslator, ModuleTranslationState};
 use cranelift_wasm::{get_vmctx_value_label, translate_operator};
-use cranelift_wasm::{FuncEnvironment, ReturnMode, WasmError};
+use cranelift_wasm::{FuncEnvironment, ReturnMode, TargetEnvironment, WasmError};
+
 use std::mem;
 use std::sync::{Arc, RwLock};
 use wasmer_runtime_core::error::CompileError;
 use wasmer_runtime_core::{
-    backend::{Backend, CacheGen, Token},
+    backend::{CacheGen, CompilerConfig, Token},
     cache::{Artifact, Error as CacheError},
     codegen::*,
     memory::MemoryType,
@@ -32,8 +33,10 @@ use wasmer_runtime_core::{
 };
 use wasmparser::Type as WpType;
 
+static BACKEND_ID: &str = "cranelift";
+
 pub struct CraneliftModuleCodeGenerator {
-    isa: Box<isa::TargetIsa>,
+    isa: Option<Box<dyn isa::TargetIsa>>,
     signatures: Option<Arc<Map<SigIndex, FuncSig>>>,
     pub clif_signatures: Map<SigIndex, ir::Signature>,
     function_signatures: Option<Arc<Map<FuncIndex, SigIndex>>>,
@@ -44,9 +47,8 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
     for CraneliftModuleCodeGenerator
 {
     fn new() -> Self {
-        let isa = get_isa();
         CraneliftModuleCodeGenerator {
-            isa,
+            isa: None,
             clif_signatures: Map::new(),
             functions: vec![],
             function_signatures: None,
@@ -54,8 +56,12 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
         }
     }
 
-    fn backend_id() -> Backend {
-        Backend::Cranelift
+    fn new_with_target(_: Option<String>, _: Option<String>, _: Option<String>) -> Self {
+        unimplemented!("cross compilation is not available for clif backend")
+    }
+
+    fn backend_id() -> &'static str {
+        BACKEND_ID
     }
 
     fn check_precondition(&mut self, _module_info: &ModuleInfo) -> Result<(), CodegenError> {
@@ -65,6 +71,7 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
     fn next_function(
         &mut self,
         module_info: Arc<RwLock<ModuleInfo>>,
+        loc: WasmSpan,
     ) -> Result<&mut CraneliftFunctionCodeGenerator, CodegenError> {
         // define_function_body(
 
@@ -89,13 +96,21 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
             func,
             func_translator,
             next_local: 0,
-            clif_signatures: self.clif_signatures.clone(),
-            module_info: Arc::clone(&module_info),
-            target_config: self.isa.frontend_config().clone(),
             position: Position::default(),
+            func_env: FunctionEnvironment {
+                module_info: Arc::clone(&module_info),
+                target_config: self.isa.as_ref().unwrap().frontend_config().clone(),
+                clif_signatures: self.clif_signatures.clone(),
+            },
+            loc,
         };
 
-        debug_assert_eq!(func_env.func.dfg.num_ebbs(), 0, "Function must be empty");
+        let generate_debug_info = module_info.read().unwrap().generate_debug_info;
+        if generate_debug_info {
+            func_env.func.collect_debug_info();
+        }
+
+        debug_assert_eq!(func_env.func.dfg.num_blocks(), 0, "Function must be empty");
         debug_assert_eq!(func_env.func.dfg.num_insts(), 0, "Function must be empty");
 
         let mut builder = FunctionBuilder::new(
@@ -104,188 +119,27 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
             &mut func_env.position,
         );
 
-        // TODO srcloc
-        //builder.set_srcloc(cur_srcloc(&reader));
+        builder.set_srcloc(ir::SourceLoc::new(loc.start()));
 
-        let entry_block = builder.create_ebb();
-        builder.append_ebb_params_for_function_params(entry_block);
+        let entry_block = builder.create_block();
+        builder.append_block_params_for_function_params(entry_block);
         builder.switch_to_block(entry_block); // This also creates values for the arguments.
         builder.seal_block(entry_block);
         // Make sure the entry block is inserted in the layout before we make any callbacks to
         // `environ`. The callback functions may need to insert things in the entry block.
-        builder.ensure_inserted_ebb();
+        builder.ensure_inserted_block();
 
         declare_wasm_parameters(&mut builder, entry_block);
 
         // Set up the translation state with a single pushed control block representing the whole
         // function and its return values.
-        let exit_block = builder.create_ebb();
-        builder.append_ebb_params_for_function_returns(exit_block);
+        let exit_block = builder.create_block();
+        builder.append_block_params_for_function_returns(exit_block);
         func_env
             .func_translator
             .state
             .initialize(&builder.func.signature, exit_block);
 
-        #[cfg(feature = "debug")]
-        {
-            use cranelift_codegen::cursor::{Cursor, FuncCursor};
-            use cranelift_codegen::ir::InstBuilder;
-            let entry_ebb = func.layout.entry_block().unwrap();
-            let ebb = func.dfg.make_ebb();
-            func.layout.insert_ebb(ebb, entry_ebb);
-            let mut pos = FuncCursor::new(&mut func).at_first_insertion_point(ebb);
-            let params = pos.func.dfg.ebb_params(entry_ebb).to_vec();
-
-            let new_ebb_params: Vec<_> = params
-                .iter()
-                .map(|&param| {
-                    pos.func
-                        .dfg
-                        .append_ebb_param(ebb, pos.func.dfg.value_type(param))
-                })
-                .collect();
-
-            let start_debug = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::I32),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("strtdbug");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let end_debug = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![ir::AbiParam::special(
-                        ir::types::I64,
-                        ir::ArgumentPurpose::VMContext,
-                    )],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("enddbug");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let i32_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::I32),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("i32print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let i64_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::I64),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("i64print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let f32_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::F32),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("f32print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let f64_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::F64),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("f64print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let vmctx = pos
-                .func
-                .special_param(ir::ArgumentPurpose::VMContext)
-                .expect("missing vmctx parameter");
-
-            let func_index = pos.ins().iconst(
-                ir::types::I32,
-                func_index.index() as i64 + self.module.info.imported_functions.len() as i64,
-            );
-
-            pos.ins().call(start_debug, &[vmctx, func_index]);
-
-            for param in new_ebb_params.iter().cloned() {
-                match pos.func.dfg.value_type(param) {
-                    ir::types::I32 => pos.ins().call(i32_print, &[vmctx, param]),
-                    ir::types::I64 => pos.ins().call(i64_print, &[vmctx, param]),
-                    ir::types::F32 => pos.ins().call(f32_print, &[vmctx, param]),
-                    ir::types::F64 => pos.ins().call(f64_print, &[vmctx, param]),
-                    _ => unimplemented!(),
-                };
-            }
-
-            pos.ins().call(end_debug, &[vmctx]);
-
-            pos.ins().jump(entry_ebb, new_ebb_params.as_slice());
-        }
-
         self.functions.push(func_env);
         Ok(self.functions.last_mut().unwrap())
     }
@@ -293,19 +147,33 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
     fn finalize(
         self,
         module_info: &ModuleInfo,
-    ) -> Result<(Caller, Box<dyn CacheGen>), CodegenError> {
-        let mut func_bodies: Map<LocalFuncIndex, ir::Function> = Map::new();
+    ) -> Result<
+        (
+            Caller,
+            Option<wasmer_runtime_core::codegen::DebugMetadata>,
+            Box<dyn CacheGen>,
+        ),
+        CodegenError,
+    > {
+        let mut func_bodies: Map<LocalFuncIndex, (ir::Function, WasmSpan)> = Map::new();
         for f in self.functions.into_iter() {
-            func_bodies.push(f.func);
+            func_bodies.push((f.func, f.loc));
         }
 
-        let (func_resolver_builder, handler_data) =
-            FuncResolverBuilder::new(&*self.isa, func_bodies, module_info)?;
+        let (func_resolver_builder, debug_metadata, handler_data) =
+            FuncResolverBuilder::new(&**self.isa.as_ref().unwrap(), func_bodies, module_info)?;
 
-        let trampolines = Arc::new(Trampolines::new(&*self.isa, module_info));
+        let trampolines = Arc::new(Trampolines::new(&**self.isa.as_ref().unwrap(), module_info));
+
+        let signatures_empty = Map::new();
+        let signatures = if self.signatures.is_some() {
+            &self.signatures.as_ref().unwrap()
+        } else {
+            &signatures_empty
+        };
 
         let (func_resolver, backend_cache) = func_resolver_builder.finalize(
-            &self.signatures.as_ref().unwrap(),
+            signatures,
             Arc::clone(&trampolines),
             handler_data.clone(),
         )?;
@@ -317,13 +185,24 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
 
         Ok((
             Caller::new(handler_data, trampolines, func_resolver),
+            debug_metadata,
             cache_gen,
         ))
     }
 
+    fn feed_compiler_config(&mut self, config: &CompilerConfig) -> Result<(), CodegenError> {
+        self.isa = Some(get_isa(Some(config)));
+        Ok(())
+    }
+
     fn feed_signatures(&mut self, signatures: Map<SigIndex, FuncSig>) -> Result<(), CodegenError> {
         self.signatures = Some(Arc::new(signatures));
-        let call_conv = self.isa.frontend_config().default_call_conv;
+        let call_conv = self
+            .isa
+            .as_ref()
+            .unwrap()
+            .frontend_config()
+            .default_call_conv;
         for (_sig_idx, func_sig) in self.signatures.as_ref().unwrap().iter() {
             self.clif_signatures
                 .push(convert_func_sig(func_sig, call_conv));
@@ -339,7 +218,7 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
         Ok(())
     }
 
-    fn feed_import_function(&mut self) -> Result<(), CodegenError> {
+    fn feed_import_function(&mut self, _sigindex: SigIndex) -> Result<(), CodegenError> {
         Ok(())
     }
 
@@ -384,10 +263,10 @@ pub struct CraneliftFunctionCodeGenerator {
     func: Function,
     func_translator: FuncTranslator,
     next_local: usize,
-    pub clif_signatures: Map<SigIndex, ir::Signature>,
-    module_info: Arc<RwLock<ModuleInfo>>,
-    target_config: isa::TargetFrontendConfig,
     position: Position,
+    func_env: FunctionEnvironment,
+    /// Where the function lives in the Wasm module as a span of bytes
+    loc: WasmSpan,
 }
 
 pub struct FunctionEnvironment {
@@ -396,7 +275,7 @@ pub struct FunctionEnvironment {
     clif_signatures: Map<SigIndex, ir::Signature>,
 }
 
-impl FuncEnvironment for FunctionEnvironment {
+impl TargetEnvironment for FunctionEnvironment {
     /// Gets configuration information needed for compiling functions
     fn target_config(&self) -> isa::TargetFrontendConfig {
         self.target_config
@@ -414,6 +293,13 @@ impl FuncEnvironment for FunctionEnvironment {
         self.target_config().pointer_bytes()
     }
 
+    /// Return Cranelift reference type.
+    fn reference_type(&self) -> ir::Type {
+        ir::types::R64
+    }
+}
+
+impl FuncEnvironment for FunctionEnvironment {
     /// Sets up the necessary preamble definitions in `func` to access the global identified
     /// by `index`.
     ///
@@ -583,7 +469,7 @@ impl FuncEnvironment for FunctionEnvironment {
                 let local_memory_bound = func.create_global_value(ir::GlobalValueData::Load {
                     base: local_memory_ptr,
                     offset: (vm::LocalMemory::offset_bound() as i32).into(),
-                    global_type: ptr_type,
+                    global_type: ir::types::I32,
                     readonly: false,
                 });
 
@@ -691,7 +577,7 @@ impl FuncEnvironment for FunctionEnvironment {
         let table_count = func.create_global_value(ir::GlobalValueData::Load {
             base: table_struct_ptr,
             offset: (vm::LocalTable::offset_count() as i32).into(),
-            global_type: ptr_type,
+            global_type: ir::types::I32,
             // The table length can change, so it can't be readonly.
             readonly: false,
         });
@@ -813,7 +699,8 @@ impl FuncEnvironment for FunctionEnvironment {
                 colocated: false,
             });
 
-            pos.ins().symbol_value(ir::types::I64, sig_index_global)
+            let val = pos.ins().symbol_value(ir::types::I64, sig_index_global);
+            pos.ins().ireduce(ir::types::I32, val)
 
             // let dynamic_sigindices_array_ptr = pos.ins().load(
             //     ptr_type,
@@ -844,7 +731,9 @@ impl FuncEnvironment for FunctionEnvironment {
     }
 
     /// Generates a call IR with `callee` and `call_args` and inserts it at `pos`
-    /// TODO: add support for imported functions
+    ///
+    /// It's about generating code that calls a local or imported function; in
+    /// WebAssembly: `(call $foo)`.
     fn translate_call(
         &mut self,
         mut pos: FuncCursor,
@@ -916,20 +805,31 @@ impl FuncEnvironment for FunctionEnvironment {
                     readonly: true,
                 });
 
-                let imported_vmctx_addr = pos.func.create_global_value(ir::GlobalValueData::Load {
-                    base: imported_func_struct_addr,
-                    offset: (vm::ImportedFunc::offset_vmctx() as i32).into(),
-                    global_type: ptr_type,
-                    readonly: true,
-                });
+                let imported_func_ctx_addr =
+                    pos.func.create_global_value(ir::GlobalValueData::Load {
+                        base: imported_func_struct_addr,
+                        offset: (vm::ImportedFunc::offset_func_ctx() as i32).into(),
+                        global_type: ptr_type,
+                        readonly: true,
+                    });
+
+                let imported_func_ctx_vmctx_addr =
+                    pos.func.create_global_value(ir::GlobalValueData::Load {
+                        base: imported_func_ctx_addr,
+                        offset: (vm::FuncCtx::offset_vmctx() as i32).into(),
+                        global_type: ptr_type,
+                        readonly: true,
+                    });
 
                 let imported_func_addr = pos.ins().global_value(ptr_type, imported_func_addr);
-                let imported_vmctx_addr = pos.ins().global_value(ptr_type, imported_vmctx_addr);
+                let imported_func_ctx_vmctx_addr = pos
+                    .ins()
+                    .global_value(ptr_type, imported_func_ctx_vmctx_addr);
 
                 let sig_ref = pos.func.dfg.ext_funcs[callee].signature;
 
                 let mut args = Vec::with_capacity(call_args.len() + 1);
-                args.push(imported_vmctx_addr);
+                args.push(imported_func_ctx_vmctx_addr);
                 args.extend(call_args.iter().cloned());
 
                 Ok(pos
@@ -938,7 +838,6 @@ impl FuncEnvironment for FunctionEnvironment {
             }
         }
     }
-
     /// Generates code corresponding to wasm `memory.grow`.
     ///
     /// `index` refers to the linear memory to query.
@@ -1067,6 +966,159 @@ impl FuncEnvironment for FunctionEnvironment {
 
         Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
     }
+    fn translate_memory_copy(
+        &mut self,
+        _pos: FuncCursor,
+        _clif_mem_index: cranelift_wasm::MemoryIndex,
+        _heap: ir::Heap,
+        _dst: ir::Value,
+        _src: ir::Value,
+        _len: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("memory.copy not yet implemented");
+    }
+
+    fn translate_memory_fill(
+        &mut self,
+        _pos: FuncCursor,
+        _clif_mem_index: cranelift_wasm::MemoryIndex,
+        _heap: ir::Heap,
+        _dst: ir::Value,
+        _val: ir::Value,
+        _len: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("memory.fill not yet implemented");
+    }
+
+    fn translate_memory_init(
+        &mut self,
+        _pos: FuncCursor,
+        _clif_mem_index: cranelift_wasm::MemoryIndex,
+        _heap: ir::Heap,
+        _seg_index: u32,
+        _dst: ir::Value,
+        _src: ir::Value,
+        _len: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("memory.init not yet implemented");
+    }
+
+    fn translate_data_drop(
+        &mut self,
+        _pos: FuncCursor,
+        _seg_index: u32,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("data.drop not yet implemented");
+    }
+
+    fn translate_table_size(
+        &mut self,
+        _pos: FuncCursor,
+        _index: cranelift_wasm::TableIndex,
+        _table: ir::Table,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!("table.size not yet implemented");
+    }
+
+    fn translate_table_copy(
+        &mut self,
+        _pos: FuncCursor,
+        _dst_table_index: cranelift_wasm::TableIndex,
+        _dst_table: ir::Table,
+        _src_table_index: cranelift_wasm::TableIndex,
+        _src_table: ir::Table,
+        _dst: ir::Value,
+        _src: ir::Value,
+        _len: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("table.copy not yet implemented");
+    }
+
+    fn translate_table_init(
+        &mut self,
+        _pos: FuncCursor,
+        _seg_index: u32,
+        _table_index: cranelift_wasm::TableIndex,
+        _table: ir::Table,
+        _dst: ir::Value,
+        _src: ir::Value,
+        _len: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("table.init not yet implemented");
+    }
+
+    fn translate_elem_drop(
+        &mut self,
+        _pos: FuncCursor,
+        _seg_index: u32,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("elem.drop not yet implemented");
+    }
+
+    fn translate_table_grow(
+        &mut self,
+        _pos: FuncCursor,
+        _table_index: u32,
+        _delta: ir::Value,
+        _init_value: ir::Value,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!("table.grow not yet implemented");
+    }
+
+    fn translate_table_get(
+        &mut self,
+        _pos: FuncCursor,
+        _table_index: u32,
+        _index: ir::Value,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!("table.get not yet implemented");
+    }
+
+    fn translate_table_set(
+        &mut self,
+        _pos: FuncCursor,
+        _table_index: u32,
+        _value: ir::Value,
+        _index: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("table.set not yet implemented");
+    }
+
+    fn translate_table_fill(
+        &mut self,
+        _pos: FuncCursor,
+        _table_index: u32,
+        _dst: ir::Value,
+        _val: ir::Value,
+        _len: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("table.fill not yet implemented");
+    }
+
+    fn translate_ref_func(
+        &mut self,
+        _pos: FuncCursor,
+        _func_index: u32,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!("ref.func not yet implemented");
+    }
+
+    fn translate_custom_global_get(
+        &mut self,
+        _pos: FuncCursor,
+        _global_index: cranelift_wasm::GlobalIndex,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!("custom global.get not yet implemented");
+    }
+
+    fn translate_custom_global_set(
+        &mut self,
+        _pos: FuncCursor,
+        _global_index: cranelift_wasm::GlobalIndex,
+        _val: ir::Value,
+    ) -> cranelift_wasm::WasmResult<()> {
+        unimplemented!("custom global.set not yet implemented");
+    }
 }
 
 impl FunctionEnvironment {
@@ -1108,9 +1160,21 @@ impl FunctionCodeGenerator<CodegenError> for CraneliftFunctionCodeGenerator {
         Ok(())
     }
 
-    fn feed_local(&mut self, ty: WpType, n: usize) -> Result<(), CodegenError> {
+    fn feed_local(&mut self, ty: WpType, n: usize, loc: u32) -> Result<(), CodegenError> {
         let mut next_local = self.next_local;
-        cranelift_wasm::declare_locals(&mut self.builder(), n as u32, ty, &mut next_local)?;
+        let mut builder = FunctionBuilder::new(
+            &mut self.func,
+            &mut self.func_translator.func_ctx,
+            &mut self.position,
+        );
+        builder.set_srcloc(ir::SourceLoc::new(loc));
+        cranelift_wasm::declare_locals(
+            &mut builder,
+            n as u32,
+            ty,
+            &mut next_local,
+            &mut self.func_env,
+        )?;
         self.next_local = next_local;
         Ok(())
     }
@@ -1119,7 +1183,12 @@ impl FunctionCodeGenerator<CodegenError> for CraneliftFunctionCodeGenerator {
         Ok(())
     }
 
-    fn feed_event(&mut self, event: Event, _module_info: &ModuleInfo) -> Result<(), CodegenError> {
+    fn feed_event(
+        &mut self,
+        event: Event,
+        _module_info: &ModuleInfo,
+        source_loc: u32,
+    ) -> Result<(), CodegenError> {
         let op = match event {
             Event::Wasm(x) => x,
             Event::WasmOwned(ref x) => x,
@@ -1131,11 +1200,6 @@ impl FunctionCodeGenerator<CodegenError> for CraneliftFunctionCodeGenerator {
         //let builder = self.builder.as_mut().unwrap();
         //let func_environment = FuncEnv::new();
         //let state = TranslationState::new();
-        let mut function_environment = FunctionEnvironment {
-            module_info: Arc::clone(&self.module_info),
-            target_config: self.target_config.clone(),
-            clif_signatures: self.clif_signatures.clone(),
-        };
 
         if self.func_translator.state.control_stack.is_empty() {
             return Ok(());
@@ -1146,8 +1210,18 @@ impl FunctionCodeGenerator<CodegenError> for CraneliftFunctionCodeGenerator {
             &mut self.func_translator.func_ctx,
             &mut self.position,
         );
-        let state = &mut self.func_translator.state;
-        translate_operator(op, &mut builder, state, &mut function_environment)?;
+        builder.func.collect_debug_info();
+        builder.set_srcloc(ir::SourceLoc::new(source_loc));
+        let module_state = ModuleTranslationState::new();
+        let func_state = &mut self.func_translator.state;
+        translate_operator(
+            &module_state,
+            op,
+            &mut builder,
+            func_state,
+            &mut self.func_env,
+        )?;
+
         Ok(())
     }
 
@@ -1166,7 +1240,7 @@ impl FunctionCodeGenerator<CodegenError> for CraneliftFunctionCodeGenerator {
         //
         // If the exit block is unreachable, it may not have the correct arguments, so we would
         // generate a return instruction that doesn't match the signature.
-        if state.reachable {
+        if state.reachable() {
             debug_assert!(builder.is_pristine());
             if !builder.is_unreachable() {
                 match return_mode {
@@ -1176,6 +1250,8 @@ impl FunctionCodeGenerator<CodegenError> for CraneliftFunctionCodeGenerator {
             }
         }
 
+        builder.finalize();
+
         // Discard any remaining values on the stack. Either we just returned them,
         // or the end of the function is unreachable.
         state.stack.clear();
@@ -1235,13 +1311,16 @@ fn generate_signature(
 }
 
 fn pointer_type(mcg: &CraneliftModuleCodeGenerator) -> ir::Type {
-    ir::Type::int(u16::from(mcg.isa.frontend_config().pointer_bits())).unwrap()
+    ir::Type::int(u16::from(
+        mcg.isa.as_ref().unwrap().frontend_config().pointer_bits(),
+    ))
+    .unwrap()
 }
 
 /// Declare local variables for the signature parameters that correspond to WebAssembly locals.
 ///
 /// Return the number of local variables declared.
-fn declare_wasm_parameters(builder: &mut FunctionBuilder, entry_block: Ebb) -> usize {
+fn declare_wasm_parameters(builder: &mut FunctionBuilder, entry_block: Block) -> usize {
     let sig_len = builder.func.signature.params.len();
     let mut next_local = 0;
     for i in 0..sig_len {
@@ -1254,11 +1333,11 @@ fn declare_wasm_parameters(builder: &mut FunctionBuilder, entry_block: Ebb) -> u
             builder.declare_var(local, param_type.value_type);
             next_local += 1;
 
-            let param_value = builder.ebb_params(entry_block)[i];
+            let param_value = builder.block_params(entry_block)[i];
             builder.def_var(local, param_value);
         }
         if param_type.purpose == ir::ArgumentPurpose::VMContext {
-            let param_value = builder.ebb_params(entry_block)[i];
+            let param_value = builder.block_params(entry_block)[i];
             builder.set_val_label(param_value, get_vmctx_value_label());
         }
     }

lib/clif-backend/src/lib.rs

@@ -1,4 +1,19 @@
-#![deny(unused_imports, unused_variables, unused_unsafe, unreachable_patterns)]
+//! The Wasmer Cranelift Backend crate is used to compile wasm binary code via parse events from the
+//! Wasmer runtime common parser code into machine code.
+//!
+
+#![deny(
+    dead_code,
+    missing_docs,
+    nonstandard_style,
+    unused_imports,
+    unused_mut,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+#![doc(html_favicon_url = "https://wasmer.io/static/icons/favicon.ico")]
+#![doc(html_logo_url = "https://avatars3.githubusercontent.com/u/44205449?s=200&v=4")]
 
 mod cache;
 mod code;
@@ -14,6 +29,7 @@ use cranelift_codegen::{
     settings::{self, Configurable},
 };
 use target_lexicon::Triple;
+use wasmer_runtime_core::{backend::CompilerConfig, codegen::SimpleStreamingCompilerGen};
 
 #[macro_use]
 extern crate serde_derive;
@@ -21,18 +37,35 @@ extern crate serde_derive;
 extern crate rayon;
 extern crate serde;
 
-fn get_isa() -> Box<isa::TargetIsa> {
+fn get_isa(config: Option<&CompilerConfig>) -> Box<dyn isa::TargetIsa> {
     let flags = {
         let mut builder = settings::builder();
-        builder.set("opt_level", "best").unwrap();
-        builder.set("jump_tables_enabled", "false").unwrap();
+        builder.set("opt_level", "speed_and_size").unwrap();
+        builder.set("enable_jump_tables", "false").unwrap();
 
-        if cfg!(not(test)) {
-            builder.set("enable_verifier", "false").unwrap();
+        let enable_verifier: bool;
+
+        if let Some(config) = config {
+            if config.nan_canonicalization {
+                builder.set("enable_nan_canonicalization", "true").unwrap();
+            }
+            enable_verifier = config.enable_verification;
+        } else {
+            // Set defaults if no config found.
+            // NOTE: cfg(test) probably does nothing when not running `cargo test`
+            //       on this crate
+            enable_verifier = cfg!(test) || cfg!(debug_assertions);
         }
 
+        builder
+            .set(
+                "enable_verifier",
+                if enable_verifier { "true" } else { "false" },
+            )
+            .unwrap();
+
         let flags = settings::Flags::new(builder);
-        debug_assert_eq!(flags.opt_level(), settings::OptLevel::Best);
+        debug_assert_eq!(flags.opt_level(), settings::OptLevel::SpeedAndSize);
         flags
     };
     isa::lookup(Triple::host()).unwrap().finish(flags)
@@ -41,8 +74,8 @@ fn get_isa() -> Box<isa::TargetIsa> {
 /// The current version of this crate
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
-use wasmer_runtime_core::codegen::SimpleStreamingCompilerGen;
-
+/// Streaming compiler implementation for the Cranelift backed. Compiles web assembly binary into
+/// machine code.
 pub type CraneliftCompiler = SimpleStreamingCompilerGen<
     code::CraneliftModuleCodeGenerator,
     code::CraneliftFunctionCodeGenerator,

lib/clif-backend/src/libcalls.rs

@@ -76,8 +76,10 @@ pub extern "C" fn nearbyintf64(x: f64) -> f64 {
     }
 }
 
-/// A declaration for the stack probe function in Rust's standard library, for
-/// catching callstack overflow.
-extern "C" {
-    pub fn __rust_probestack();
-}
+// FIXME: Is there a replacement on AArch64?
+#[cfg(all(
+    any(target_os = "freebsd", target_os = "linux", target_os = "android"),
+    target_arch = "aarch64"
+))]
+#[no_mangle]
+pub extern "C" fn __rust_probestack() {}

lib/clif-backend/src/module.rs

@@ -42,9 +42,8 @@ impl Module {
         let runnable_module = Caller::new(handler_data, trampolines, func_resolver);
 
         Ok(ModuleInner {
-            runnable_module: Box::new(runnable_module),
+            runnable_module: Arc::new(Box::new(runnable_module)),
             cache_gen,
-
             info,
         })
     }
@@ -56,7 +55,7 @@ macro_rules! convert_clif_to_runtime_index {
     ($clif_index:ident, $runtime_index:ident) => {
         impl From<Converter<cranelift_wasm::$clif_index>> for $runtime_index {
             fn from(clif_index: Converter<cranelift_wasm::$clif_index>) -> Self {
-                $runtime_index::new(clif_index.0.index())
+                <$runtime_index as TypedIndex>::new(clif_index.0.index())
             }
         }
 
@@ -107,7 +106,8 @@ impl From<Converter<ir::Type>> for Type {
             ir::types::I64 => Type::I64,
             ir::types::F32 => Type::F32,
             ir::types::F64 => Type::F64,
-            _ => panic!("unsupported wasm type"),
+            ir::types::I32X4 => Type::V128,
+            _ => unimplemented!("unsupported wasm type"),
         }
     }
 }
@@ -119,6 +119,7 @@ impl From<Converter<Type>> for ir::Type {
             Type::I64 => ir::types::I64,
             Type::F32 => ir::types::F32,
             Type::F64 => ir::types::F64,
+            Type::V128 => ir::types::I32X4,
         }
     }
 }
@@ -130,6 +131,7 @@ impl From<Converter<Type>> for ir::AbiParam {
             Type::I64 => ir::AbiParam::new(ir::types::I64),
             Type::F32 => ir::AbiParam::new(ir::types::F32),
             Type::F64 => ir::AbiParam::new(ir::types::F64),
+            Type::V128 => ir::AbiParam::new(ir::types::I32X4),
         }
     }
 }

lib/clif-backend/src/relocation.rs

@@ -98,14 +98,14 @@ pub struct RelocSink {
 }
 
 impl binemit::RelocSink for RelocSink {
-    fn reloc_ebb(
+    fn reloc_block(
         &mut self,
         _offset: binemit::CodeOffset,
         _reloc: binemit::Reloc,
         _ebb_offset: binemit::CodeOffset,
     ) {
         // This should use the `offsets` field of `ir::Function`.
-        unimplemented!();
+        unimplemented!("RelocSink::reloc_ebb");
     }
     fn reloc_external(
         &mut self,
@@ -146,7 +146,7 @@ impl binemit::RelocSink for RelocSink {
 
                         DYNAMIC_MEM_GROW => VmCallKind::DynamicMemoryGrow,
                         DYNAMIC_MEM_SIZE => VmCallKind::DynamicMemorySize,
-                        _ => unimplemented!(),
+                        _ => unimplemented!("reloc_external VmCall::Local {}", index),
                     })),
                     IMPORT_NAMESPACE => RelocationType::VmCall(VmCall::Import(match index {
                         STATIC_MEM_GROW => VmCallKind::StaticMemoryGrow,
@@ -157,10 +157,10 @@ impl binemit::RelocSink for RelocSink {
 
                         DYNAMIC_MEM_GROW => VmCallKind::DynamicMemoryGrow,
                         DYNAMIC_MEM_SIZE => VmCallKind::DynamicMemorySize,
-                        _ => unimplemented!(),
+                        _ => unimplemented!("reloc_external VmCall::Import {}", index),
                     })),
                     SIG_NAMESPACE => RelocationType::Signature(SigIndex::new(index as usize)),
-                    _ => unimplemented!(),
+                    _ => unimplemented!("reloc_external SigIndex {}", index),
                 };
                 self.external_relocs.push(ExternalRelocation {
                     reloc,
@@ -202,13 +202,18 @@ impl binemit::RelocSink for RelocSink {
             }
         }
     }
+
+    fn reloc_constant(&mut self, _: u32, _: cranelift_codegen::binemit::Reloc, _: u32) {
+        unimplemented!("RelocSink::reloc_constant")
+    }
+
     fn reloc_jt(
         &mut self,
         _offset: binemit::CodeOffset,
         _reloc: binemit::Reloc,
         _jt: ir::JumpTable,
     ) {
-        unimplemented!();
+        unimplemented!("RelocSink::reloc_jt");
     }
 }
 

lib/clif-backend/src/resolver.rs

@@ -1,29 +1,32 @@
-use crate::{cache::BackendCache, trampoline::Trampolines};
 use crate::{
+    cache::BackendCache,
     libcalls,
     relocation::{
         ExternalRelocation, LibCall, LocalRelocation, LocalTrapSink, Reloc, RelocSink,
         RelocationType, TrapSink, VmCall, VmCallKind,
     },
     signal::HandlerData,
+    trampoline::Trampolines,
+};
+use byteorder::{ByteOrder, LittleEndian};
+use cranelift_codegen::{
+    binemit::{Stackmap, StackmapSink},
+    ir, isa, CodegenError, Context, ValueLabelsRanges,
 };
 use rayon::prelude::*;
-
-use byteorder::{ByteOrder, LittleEndian};
-use cranelift_codegen::{ir, isa, Context};
 use std::{
     mem,
     ptr::{write_unaligned, NonNull},
     sync::Arc,
 };
-
-use wasmer_runtime_core::cache::Error as CacheError;
 use wasmer_runtime_core::{
     self,
     backend::{
         sys::{Memory, Protect},
         SigRegistry,
     },
+    cache::Error as CacheError,
+    codegen::WasmSpan,
     error::{CompileError, CompileResult},
     module::ModuleInfo,
     structures::{Map, SliceMap, TypedIndex},
@@ -58,6 +61,11 @@ pub struct FuncResolverBuilder {
     import_len: usize,
 }
 
+pub struct NoopStackmapSink {}
+impl StackmapSink for NoopStackmapSink {
+    fn add_stackmap(&mut self, _: u32, _: Stackmap) {}
+}
+
 impl FuncResolverBuilder {
     pub fn new_from_backend_cache(
         backend_cache: BackendCache,
@@ -88,54 +96,184 @@ impl FuncResolverBuilder {
     }
 
     pub fn new(
-        isa: &isa::TargetIsa,
-        function_bodies: Map<LocalFuncIndex, ir::Function>,
+        isa: &dyn isa::TargetIsa,
+        function_bodies: Map<LocalFuncIndex, (ir::Function, WasmSpan)>,
         info: &ModuleInfo,
-    ) -> CompileResult<(Self, HandlerData)> {
+    ) -> CompileResult<(
+        Self,
+        Option<wasmer_runtime_core::codegen::DebugMetadata>,
+        HandlerData,
+    )> {
         let num_func_bodies = function_bodies.len();
         let mut local_relocs = Map::with_capacity(num_func_bodies);
         let mut external_relocs = Map::with_capacity(num_func_bodies);
 
         let mut trap_sink = TrapSink::new();
 
-        let compiled_functions: Result<Vec<(Vec<u8>, (RelocSink, LocalTrapSink))>, CompileError> =
-            function_bodies
-                .into_vec()
-                .par_iter()
-                .map_init(
-                    || Context::new(),
-                    |ctx, func| {
-                        let mut code_buf = Vec::new();
-                        ctx.func = func.to_owned();
-                        let mut reloc_sink = RelocSink::new();
-                        let mut local_trap_sink = LocalTrapSink::new();
+        let generate_debug_info = info.generate_debug_info;
+        let fb = function_bodies.iter().collect::<Vec<(_, _)>>();
 
-                        ctx.compile_and_emit(
-                            isa,
-                            &mut code_buf,
-                            &mut reloc_sink,
-                            &mut local_trap_sink,
-                        )
-                        .map_err(|e| CompileError::InternalError { msg: e.to_string() })?;
-                        ctx.clear();
-                        Ok((code_buf, (reloc_sink, local_trap_sink)))
-                    },
-                )
-                .collect();
+        #[cfg(feature = "generate-debug-information")]
+        use wasm_debug::types::CompiledFunctionData;
 
-        let compiled_functions = compiled_functions?;
+        #[cfg(not(feature = "generate-debug-information"))]
+        type CompiledFunctionData = ();
+
+        /// Data about the the compiled machine code.
+        type CompileMetadata = (
+            LocalFuncIndex,
+            Option<(CompiledFunctionData, ValueLabelsRanges, Vec<Option<i32>>)>,
+            RelocSink,
+            LocalTrapSink,
+        );
+
+        /// Compiled machine code and information about it
+        type CompileData = (Vec<u8>, CompileMetadata);
+
+        let compiled_functions: Result<Vec<CompileData>, CompileError> = fb
+            .par_iter()
+            .map_init(
+                || Context::new(),
+                |ctx, (lfi, (func, _loc))| {
+                    let mut code_buf = Vec::new();
+                    ctx.func = func.to_owned();
+                    let mut reloc_sink = RelocSink::new();
+                    let mut local_trap_sink = LocalTrapSink::new();
+                    let mut stackmap_sink = NoopStackmapSink {};
+
+                    ctx.compile_and_emit(
+                        isa,
+                        &mut code_buf,
+                        &mut reloc_sink,
+                        &mut local_trap_sink,
+                        &mut stackmap_sink,
+                    )
+                    .map_err(|e| match e {
+                        CodegenError::Verifier(v) => CompileError::InternalError {
+                            msg: format!("Verifier error: {}", v),
+                        },
+                        _ => CompileError::InternalError { msg: e.to_string() },
+                    })?;
+
+                    #[cfg(feature = "generate-debug-information")]
+                    let debug_entry = if generate_debug_info {
+                        let func = &ctx.func;
+                        let encinfo = isa.encoding_info();
+                        let mut blocks = func.layout.blocks().collect::<Vec<_>>();
+                        blocks.sort_by_key(|block| func.offsets[*block]);
+                        let instructions = blocks
+                            .into_iter()
+                            .flat_map(|block| {
+                                func.inst_offsets(block, &encinfo)
+                                    .map(|(offset, inst, length)| {
+                                        let srcloc = func.srclocs[inst];
+                                        let val = srcloc.bits();
+                                        wasm_debug::types::CompiledInstructionData {
+                                            srcloc: wasm_debug::types::SourceLoc::new(val),
+                                            code_offset: offset as usize,
+                                            code_len: length as usize,
+                                        }
+                                    })
+                            })
+                            .collect::<Vec<_>>();
+
+                        let stack_slots = ctx
+                            .func
+                            .stack_slots
+                            .iter()
+                            .map(|(_, ssd)| ssd.offset)
+                            .collect::<Vec<Option<i32>>>();
+                        let labels_ranges = ctx.build_value_labels_ranges(isa).unwrap_or_default();
+
+                        let entry = CompiledFunctionData {
+                            instructions,
+                            start_srcloc: wasm_debug::types::SourceLoc::new(_loc.start()),
+                            end_srcloc: wasm_debug::types::SourceLoc::new(_loc.end()),
+                            // this not being 0 breaks inst-level debugging
+                            body_offset: 0,
+                            body_len: code_buf.len(),
+                        };
+                        Some((entry, labels_ranges, stack_slots))
+                    } else {
+                        None
+                    };
+
+                    #[cfg(not(feature = "generate-debug-information"))]
+                    let debug_entry = None;
+
+                    ctx.clear();
+                    Ok((code_buf, (*lfi, debug_entry, reloc_sink, local_trap_sink)))
+                },
+            )
+            .collect();
+
+        let mut debug_metadata = if generate_debug_info {
+            Some(wasmer_runtime_core::codegen::DebugMetadata {
+                func_info: Map::new(),
+                inst_info: Map::new(),
+                pointers: vec![],
+                stack_slot_offsets: Map::new(),
+            })
+        } else {
+            None
+        };
+
+        let mut compiled_functions = compiled_functions?;
+        compiled_functions.sort_by(|a, b| (a.1).0.cmp(&(b.1).0));
+        let compiled_functions = compiled_functions;
         let mut total_size = 0;
         // We separate into two iterators, one iterable and one into iterable
-        let (code_bufs, sinks): (Vec<Vec<u8>>, Vec<(RelocSink, LocalTrapSink)>) =
+        let (code_bufs, sinks): (Vec<Vec<u8>>, Vec<CompileMetadata>) =
             compiled_functions.into_iter().unzip();
-        for (code_buf, (reloc_sink, mut local_trap_sink)) in code_bufs.iter().zip(sinks.into_iter())
+        for (code_buf, (_, _debug_info, reloc_sink, mut local_trap_sink)) in
+            code_bufs.iter().zip(sinks.into_iter())
         {
+            let rounded_size = round_up(code_buf.len(), mem::size_of::<usize>());
+            #[cfg(feature = "generate-debug-information")]
+            {
+                if let Some(ref mut dbg_metadata) = debug_metadata {
+                    let (entry, vlr, stackslots) = _debug_info.unwrap();
+                    dbg_metadata.func_info.push(entry);
+                    let new_vlr = vlr
+                        .into_iter()
+                        .map(|(k, v)| {
+                            (
+                                wasm_debug::types::ValueLabel::from_u32(k.as_u32()),
+                                v.into_iter()
+                                    .map(|item| wasm_debug::types::ValueLocRange {
+                                        start: item.start,
+                                        end: item.end,
+                                        loc: match item.loc {
+                                            cranelift_codegen::ir::ValueLoc::Unassigned => {
+                                                wasm_debug::types::ValueLoc::Unassigned
+                                            }
+                                            cranelift_codegen::ir::ValueLoc::Reg(ru) => {
+                                                wasm_debug::types::ValueLoc::Reg(ru)
+                                            }
+                                            cranelift_codegen::ir::ValueLoc::Stack(st) => {
+                                                wasm_debug::types::ValueLoc::Stack(
+                                                    wasm_debug::types::StackSlot::from_u32(
+                                                        st.as_u32(),
+                                                    ),
+                                                )
+                                            }
+                                        },
+                                    })
+                                    .collect::<Vec<wasm_debug::types::ValueLocRange>>(),
+                            )
+                        })
+                        .collect::<wasm_debug::types::ValueLabelsRangesInner>();
+                    dbg_metadata.inst_info.push(new_vlr);
+                    dbg_metadata.stack_slot_offsets.push(stackslots);
+                }
+            }
+
             // Clear the local trap sink and consolidate all trap info
             // into a single location.
             trap_sink.drain_local(total_size, &mut local_trap_sink);
 
             // Round up each function's size to pointer alignment.
-            total_size += round_up(code_buf.len(), mem::size_of::<usize>());
+            total_size += rounded_size;
 
             local_relocs.push(reloc_sink.local_relocs.into_boxed_slice());
             external_relocs.push(reloc_sink.external_relocs.into_boxed_slice());
@@ -167,7 +305,14 @@ impl FuncResolverBuilder {
 
         let mut previous_end = 0;
         for compiled in code_bufs.iter() {
-            let new_end = previous_end + round_up(compiled.len(), mem::size_of::<usize>());
+            let length = round_up(compiled.len(), mem::size_of::<usize>());
+            if let Some(ref mut dbg_metadata) = debug_metadata {
+                dbg_metadata.pointers.push((
+                    (memory.as_ptr() as usize + previous_end) as *const u8,
+                    length,
+                ));
+            }
+            let new_end = previous_end + length;
             unsafe {
                 memory.as_slice_mut()[previous_end..previous_end + compiled.len()]
                     .copy_from_slice(&compiled[..]);
@@ -189,7 +334,7 @@ impl FuncResolverBuilder {
 
         func_resolver_builder.relocate_locals();
 
-        Ok((func_resolver_builder, handler_data))
+        Ok((func_resolver_builder, debug_metadata, handler_data))
     }
 
     fn relocate_locals(&mut self) {
@@ -241,25 +386,17 @@ impl FuncResolverBuilder {
                         #[cfg(not(target_os = "windows"))]
                         LibCall::Probestack => __rust_probestack as isize,
                     },
-                    RelocationType::Intrinsic(ref name) => match name.as_str() {
-                        "i32print" => i32_print as isize,
-                        "i64print" => i64_print as isize,
-                        "f32print" => f32_print as isize,
-                        "f64print" => f64_print as isize,
-                        "strtdbug" => start_debug as isize,
-                        "enddbug" => end_debug as isize,
-                        _ => Err(CompileError::InternalError {
-                            msg: format!("unexpected intrinsic: {}", name),
-                        })?,
-                    },
+                    RelocationType::Intrinsic(ref name) => Err(CompileError::InternalError {
+                        msg: format!("unexpected intrinsic: {}", name),
+                    })?,
                     RelocationType::VmCall(vmcall) => match vmcall {
                         VmCall::Local(kind) => match kind {
-                            VmCallKind::StaticMemoryGrow => vmcalls::local_static_memory_grow as _,
-                            VmCallKind::StaticMemorySize => vmcalls::local_static_memory_size as _,
-
-                            VmCallKind::SharedStaticMemoryGrow => unimplemented!(),
-                            VmCallKind::SharedStaticMemorySize => unimplemented!(),
-
+                            VmCallKind::StaticMemoryGrow | VmCallKind::SharedStaticMemoryGrow => {
+                                vmcalls::local_static_memory_grow as _
+                            }
+                            VmCallKind::StaticMemorySize | VmCallKind::SharedStaticMemorySize => {
+                                vmcalls::local_static_memory_size as _
+                            }
                             VmCallKind::DynamicMemoryGrow => {
                                 vmcalls::local_dynamic_memory_grow as _
                             }
@@ -268,16 +405,12 @@ impl FuncResolverBuilder {
                             }
                         },
                         VmCall::Import(kind) => match kind {
-                            VmCallKind::StaticMemoryGrow => {
+                            VmCallKind::StaticMemoryGrow | VmCallKind::SharedStaticMemoryGrow => {
                                 vmcalls::imported_static_memory_grow as _
                             }
-                            VmCallKind::StaticMemorySize => {
+                            VmCallKind::StaticMemorySize | VmCallKind::SharedStaticMemorySize => {
                                 vmcalls::imported_static_memory_size as _
                             }
-
-                            VmCallKind::SharedStaticMemoryGrow => unimplemented!(),
-                            VmCallKind::SharedStaticMemorySize => unimplemented!(),
-
                             VmCallKind::DynamicMemoryGrow => {
                                 vmcalls::imported_dynamic_memory_grow as _
                             }
@@ -366,28 +499,3 @@ impl FuncResolver {
 fn round_up(n: usize, multiple: usize) -> usize {
     (n + multiple - 1) & !(multiple - 1)
 }
-
-extern "C" fn i32_print(_ctx: &mut vm::Ctx, n: i32) {
-    eprint!(" i32: {},", n);
-}
-extern "C" fn i64_print(_ctx: &mut vm::Ctx, n: i64) {
-    eprint!(" i64: {},", n);
-}
-extern "C" fn f32_print(_ctx: &mut vm::Ctx, n: f32) {
-    eprint!(" f32: {},", n);
-}
-extern "C" fn f64_print(_ctx: &mut vm::Ctx, n: f64) {
-    eprint!(" f64: {},", n);
-}
-extern "C" fn start_debug(ctx: &mut vm::Ctx, func_index: u32) {
-    if let Some(symbol_map) = unsafe { ctx.borrow_symbol_map() } {
-        if let Some(fn_name) = symbol_map.get(&func_index) {
-            eprint!("func ({} ({})), args: [", fn_name, func_index);
-            return;
-        }
-    }
-    eprint!("func ({}), args: [", func_index);
-}
-extern "C" fn end_debug(_ctx: &mut vm::Ctx) {
-    eprintln!(" ]");
-}

lib/clif-backend/src/signal/mod.rs

@@ -1,12 +1,15 @@
-use crate::relocation::{TrapData, TrapSink};
-use crate::resolver::FuncResolver;
-use crate::trampoline::Trampolines;
+use crate::{
+    relocation::{TrapData, TrapSink},
+    resolver::FuncResolver,
+    trampoline::Trampolines,
+};
 use libc::c_void;
-use std::{any::Any, cell::Cell, ptr::NonNull, sync::Arc};
+use std::{cell::Cell, ptr::NonNull, sync::Arc};
 use wasmer_runtime_core::{
     backend::RunnableModule,
+    error::RuntimeError,
     module::ModuleInfo,
-    typed_func::{Wasm, WasmTrapInfo},
+    typed_func::{Trampoline, Wasm},
     types::{LocalFuncIndex, SigIndex},
     vm,
 };
@@ -24,12 +27,7 @@ pub use self::unix::*;
 pub use self::windows::*;
 
 thread_local! {
-    pub static TRAP_EARLY_DATA: Cell<Option<Box<dyn Any>>> = Cell::new(None);
-}
-
-pub enum CallProtError {
-    Trap(WasmTrapInfo),
-    Error(Box<dyn Any>),
+    pub static TRAP_EARLY_DATA: Cell<Option<RuntimeError>> = Cell::new(None);
 }
 
 pub struct Caller {
@@ -59,13 +57,12 @@ impl RunnableModule for Caller {
 
     fn get_trampoline(&self, _: &ModuleInfo, sig_index: SigIndex) -> Option<Wasm> {
         unsafe extern "C" fn invoke(
-            trampoline: unsafe extern "C" fn(*mut vm::Ctx, NonNull<vm::Func>, *const u64, *mut u64),
+            trampoline: Trampoline,
             ctx: *mut vm::Ctx,
             func: NonNull<vm::Func>,
             args: *const u64,
             rets: *mut u64,
-            trap_info: *mut WasmTrapInfo,
-            user_error: *mut Option<Box<dyn Any>>,
+            error_out: *mut Option<RuntimeError>,
             invoke_env: Option<NonNull<c_void>>,
         ) -> bool {
             let handler_data = &*invoke_env.unwrap().cast().as_ptr();
@@ -82,10 +79,7 @@ impl RunnableModule for Caller {
 
             match res {
                 Err(err) => {
-                    match err {
-                        CallProtError::Trap(info) => *trap_info = info,
-                        CallProtError::Error(data) => *user_error = Some(data),
-                    }
+                    *error_out = Some(err.into());
                     false
                 }
                 Ok(()) => true,
@@ -106,7 +100,7 @@ impl RunnableModule for Caller {
         })
     }
 
-    unsafe fn do_early_trap(&self, data: Box<dyn Any>) -> ! {
+    unsafe fn do_early_trap(&self, data: RuntimeError) -> ! {
         TRAP_EARLY_DATA.with(|cell| cell.set(Some(data)));
         trigger_trap()
     }

lib/clif-backend/src/signal/unix.rs

@@ -10,7 +10,7 @@
 //! unless you have memory unsafety elsewhere in your code.
 //!
 use crate::relocation::{TrapCode, TrapData};
-use crate::signal::{CallProtError, HandlerData};
+use crate::signal::HandlerData;
 use libc::{c_int, c_void, siginfo_t};
 use nix::sys::signal::{
     sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal, SIGBUS, SIGFPE, SIGILL, SIGSEGV,
@@ -18,7 +18,8 @@ use nix::sys::signal::{
 use std::cell::{Cell, UnsafeCell};
 use std::ptr;
 use std::sync::Once;
-use wasmer_runtime_core::typed_func::WasmTrapInfo;
+use wasmer_runtime_core::backend::ExceptionCode;
+use wasmer_runtime_core::error::InvokeError;
 
 extern "C" fn signal_trap_handler(
     signum: ::nix::libc::c_int,
@@ -65,7 +66,7 @@ pub unsafe fn trigger_trap() -> ! {
 pub fn call_protected<T>(
     handler_data: &HandlerData,
     f: impl FnOnce() -> T,
-) -> Result<T, CallProtError> {
+) -> Result<T, InvokeError> {
     unsafe {
         let jmp_buf = SETJMP_BUFFER.with(|buf| buf.get());
         let prev_jmp_buf = *jmp_buf;
@@ -79,27 +80,38 @@ pub fn call_protected<T>(
             *jmp_buf = prev_jmp_buf;
 
             if let Some(data) = super::TRAP_EARLY_DATA.with(|cell| cell.replace(None)) {
-                Err(CallProtError::Error(data))
+                Err(InvokeError::EarlyTrap(Box::new(data)))
             } else {
                 let (faulting_addr, inst_ptr) = CAUGHT_ADDRESSES.with(|cell| cell.get());
 
-                if let Some(TrapData {
-                    trapcode,
-                    srcloc: _,
-                }) = handler_data.lookup(inst_ptr)
-                {
-                    Err(CallProtError::Trap(match Signal::from_c_int(signum) {
+                if let Some(TrapData { trapcode, srcloc }) = handler_data.lookup(inst_ptr) {
+                    let code = match Signal::from_c_int(signum) {
                         Ok(SIGILL) => match trapcode {
-                            TrapCode::BadSignature => WasmTrapInfo::IncorrectCallIndirectSignature,
-                            TrapCode::IndirectCallToNull => WasmTrapInfo::CallIndirectOOB,
-                            TrapCode::HeapOutOfBounds => WasmTrapInfo::MemoryOutOfBounds,
-                            TrapCode::TableOutOfBounds => WasmTrapInfo::CallIndirectOOB,
-                            _ => WasmTrapInfo::Unknown,
+                            TrapCode::StackOverflow => ExceptionCode::MemoryOutOfBounds,
+                            TrapCode::HeapOutOfBounds => ExceptionCode::MemoryOutOfBounds,
+                            TrapCode::TableOutOfBounds => ExceptionCode::CallIndirectOOB,
+                            TrapCode::OutOfBounds => ExceptionCode::MemoryOutOfBounds,
+                            TrapCode::IndirectCallToNull => ExceptionCode::CallIndirectOOB,
+                            TrapCode::BadSignature => ExceptionCode::IncorrectCallIndirectSignature,
+                            TrapCode::IntegerOverflow => ExceptionCode::IllegalArithmetic,
+                            TrapCode::IntegerDivisionByZero => ExceptionCode::IllegalArithmetic,
+                            TrapCode::BadConversionToInteger => ExceptionCode::IllegalArithmetic,
+                            TrapCode::UnreachableCodeReached => ExceptionCode::Unreachable,
+                            _ => {
+                                return Err(InvokeError::UnknownTrapCode {
+                                    trap_code: format!("{:?}", trapcode),
+                                    srcloc,
+                                })
+                            }
                         },
-                        Ok(SIGSEGV) | Ok(SIGBUS) => WasmTrapInfo::MemoryOutOfBounds,
-                        Ok(SIGFPE) => WasmTrapInfo::IllegalArithmetic,
-                        _ => unimplemented!(),
-                    }))
+                        Ok(SIGSEGV) | Ok(SIGBUS) => ExceptionCode::MemoryOutOfBounds,
+                        Ok(SIGFPE) => ExceptionCode::IllegalArithmetic,
+                        _ => unimplemented!(
+                            "ExceptionCode::Unknown signal:{:?}",
+                            Signal::from_c_int(signum)
+                        ),
+                    };
+                    Err(InvokeError::TrapCode { srcloc, code })
                 } else {
                     let signal = match Signal::from_c_int(signum) {
                         Ok(SIGFPE) => "floating-point exception",
@@ -110,8 +122,10 @@ pub fn call_protected<T>(
                         _ => "unknown trapped signal",
                     };
                     // When the trap-handler is fully implemented, this will return more information.
-                    let s = format!("unknown trap at {:p} - {}", faulting_addr, signal);
-                    Err(CallProtError::Error(Box::new(s)))
+                    Err(InvokeError::UnknownTrap {
+                        address: faulting_addr as usize,
+                        signal,
+                    })
                 }
             }
         } else {
@@ -138,7 +152,99 @@ pub unsafe fn do_unwind(signum: i32, siginfo: *const c_void, ucontext: *const c_
     longjmp(jmp_buf as *mut ::nix::libc::c_void, signum)
 }
 
-#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
+#[cfg(all(target_os = "freebsd", target_arch = "aarch64"))]
+unsafe fn get_faulting_addr_and_ip(
+    _siginfo: *const c_void,
+    _ucontext: *const c_void,
+) -> (*const c_void, *const c_void) {
+    (::std::ptr::null(), ::std::ptr::null())
+}
+
+#[cfg(all(target_os = "freebsd", target_arch = "x86_64"))]
+unsafe fn get_faulting_addr_and_ip(
+    siginfo: *const c_void,
+    ucontext: *const c_void,
+) -> (*const c_void, *const c_void) {
+    #[repr(C)]
+    pub struct ucontext_t {
+        uc_sigmask: libc::sigset_t,
+        uc_mcontext: mcontext_t,
+        uc_link: *mut ucontext_t,
+        uc_stack: libc::stack_t,
+        uc_flags: i32,
+        __spare__: [i32; 4],
+    }
+
+    #[repr(C)]
+    pub struct mcontext_t {
+        mc_onstack: u64,
+        mc_rdi: u64,
+        mc_rsi: u64,
+        mc_rdx: u64,
+        mc_rcx: u64,
+        mc_r8: u64,
+        mc_r9: u64,
+        mc_rax: u64,
+        mc_rbx: u64,
+        mc_rbp: u64,
+        mc_r10: u64,
+        mc_r11: u64,
+        mc_r12: u64,
+        mc_r13: u64,
+        mc_r14: u64,
+        mc_r15: u64,
+        mc_trapno: u32,
+        mc_fs: u16,
+        mc_gs: u16,
+        mc_addr: u64,
+        mc_flags: u32,
+        mc_es: u16,
+        mc_ds: u16,
+        mc_err: u64,
+        mc_rip: u64,
+        mc_cs: u64,
+        mc_rflags: u64,
+        mc_rsp: u64,
+        mc_ss: u64,
+        mc_len: i64,
+
+        mc_fpformat: i64,
+        mc_ownedfp: i64,
+        mc_fpstate: [i64; 64], // mc_fpstate[0] is a pointer to savefpu
+
+        mc_fsbase: u64,
+        mc_gsbase: u64,
+
+        mc_xfpustate: u64,
+        mc_xfpustate_len: u64,
+
+        mc_spare: [i64; 4],
+    }
+
+    let siginfo = siginfo as *const siginfo_t;
+    let si_addr = (*siginfo).si_addr;
+
+    let ucontext = ucontext as *const ucontext_t;
+    let rip = (*ucontext).uc_mcontext.mc_rip;
+
+    (si_addr, rip as _)
+}
+
+#[cfg(all(
+    any(target_os = "linux", target_os = "android"),
+    target_arch = "aarch64"
+))]
+unsafe fn get_faulting_addr_and_ip(
+    _siginfo: *const c_void,
+    _ucontext: *const c_void,
+) -> (*const c_void, *const c_void) {
+    (::std::ptr::null(), ::std::ptr::null())
+}
+
+#[cfg(all(
+    any(target_os = "linux", target_os = "android"),
+    target_arch = "x86_64"
+))]
 unsafe fn get_faulting_addr_and_ip(
     siginfo: *const c_void,
     ucontext: *const c_void,
@@ -228,7 +334,12 @@ unsafe fn get_faulting_addr_and_ip(
 }
 
 #[cfg(not(any(
+    all(target_os = "freebsd", target_arch = "aarch64"),
+    all(target_os = "freebsd", target_arch = "x86_64"),
     all(target_os = "macos", target_arch = "x86_64"),
     all(target_os = "linux", target_arch = "x86_64"),
+    all(target_os = "linux", target_arch = "aarch64"),
+    all(target_os = "android", target_arch = "x86_64"),
+    all(target_os = "android", target_arch = "aarch64"),
 )))]
 compile_error!("This crate doesn't yet support compiling on operating systems other than linux and macos and architectures other than x86_64");