IOT>> wac>> 返回
项目作者: kanaka

项目描述 :
WebAssembly interpreter in C
高级语言: C
项目地址: git://github.com/kanaka/wac.git
创建时间: 2017-04-13T17:11:59Z
项目社区:https://github.com/kanaka/wac

开源协议:Other

下载


wac - WebAssembly in C

A Minimal WebAssembly interpreter written in C. Supports the
WebAssembly MVP (minimum viable product) version of the WebAssembly
specification.

There are three different builds of wac:

  • wac: (WebAssembly in C) Minimal client with an interactive REPL
    mode. Designed to run standalone wasm files compiled with
    wat2wasm or wasm-as. Passes most spec tests apart from some
    multi-module import/export tests.
  • wax: (WebAssembly in C with WASI) Client with WebAssembly System
    Interface APIs (WASI).
  • wace: (WebAssembly in C with Emscripten) Client with host
    library/memory integration. Designed to run wasm code that has been
    built with Emscripten (using -s SIDE_MODULE=1 -s LEGALIZE_JS_FFI=0).

Prerequisites

To build wac/wax/wace you need a 32-bit version of gcc and 32-bit
versions of SDL2 and libedit. On 64-bit Ubuntu/Debian these can be
installed like this:

  1. dpkg --add-architecture i386
  2. apt-get update
  3. apt-get install lib32gcc-4.9-dev libSDL2-dev:i386 libedit-dev:i386

To compile wat source files to binary wasm modules you will need the
wasm-as program from Binaryen.
To compile C programs to wasm modules you will need Binaryen and
emscripten.

As an alternative to downloading and building the above tools, the
kanaka/wac docker image (1.7GB) has 32-bit gcc compiler/libraries,
emscripten, and binaryen preinstalled. The docker image can be started
with appropriate file mounts like this:

  1. docker run -v `pwd`:/wac -w /wac -it kanaka/wac bash

All the build commands below can be run within the docker container.

wac usage

Build wac:

  1. $ make wac

Use wasm-as to compile a simple wat program to a wasm:

  1. $ make examples_wat/arith.wasm

Now load the compiled wasm file and invoke some functions:

  1. $ ./wac examples_wat/arith.wasm add 2 3
  2. 0x5:i32
  3. $ ./wac examples_wat/arith.wasm mul 7 8
  4. 0x38:i32

wac also supports a very simple REPL (read-eval-print-loop) mode that
runs commands in the form of FUNC ARG...:

  1. $ ./wac --repl examples_wat/arith.wasm
  2. > sub 10 5
  3. 0x5:i32
  4. > div 13 4
  5. 0x3:i32

wax usage

Build wax:

  1. $ make wax

Use wasm-as to compile a wat program that uses the WASI interface:

  1. $ make examples_wat/echo.wasm

Now run the compiled wasm file. The program reads text from stdin and
echos it to stdout until an EOF (Ctrl-D) is sent.

  1. $ ./wax examples_wat/echo.wasm
  2. > foo
  3. foo
  4. > bar
  5. bar
  6. > <Ctrl-D>

wace usage

Build wace:

  1. $ make wace

Use emscripten/binaryen to compile some simple C programs and run them
using wace:

  1. $ make examples_c/hello1.wasm
  2. $ ./wace examples_c/hello1.wasm
  3. hello world
  4. $ make examples_c/hello2.wasm
  5. $ ./wace examples_c/hello2.wasm
  6. hello malloc people

Use emscripten/binaryen to compile some C SDL programs and run them
using wace:

  1. $ make examples_c/hello_sdl.wasm
  2. $ ./wace examples_c/hello_sdl.wasm
  3. INFO: OpenGL shaders: ENABLED
  4. INFO: Created renderer: opengl
  5. # Blue Window displayed for 2 seconds
  6. Done.
  7. $ make examples_c/triangle.wasm
  8. $ ./wace examples_c/triangle.wasm
  9. # A colorfully shaded triangle is rendered

Running WebAssembly spec tests

wac includes a runtest.py test driver which can be used for running
tests from the WebAssembly specification.

Check out the spec:

  1. git clone https://github.com/WebAssembly/spec

You will need wat2wasm to compile the spec tests. Check-out and
build wabt (wabbit):

  1. git clone --recursive https://github.com/WebAssembly/wabt
  2. make -C wabt gcc-release

Run the func.wast test file (to test function calls) from the spec:

  1. ./runtest.py --wat2wasm ./wabt/out/gcc/Release/wat2wasm --interpreter ./wac spec/test/core/func.wast

Run all the spec tests apart from a few that currently fail (mostly due to
runtest.py missing support for some syntax used in those test files):

  1. BROKE_TESTS="comments exports imports linking names data elem inline-module"
  2. for t in $(ls spec/test/core/*.wast | grep -Fv "${BROKE_TESTS// /$'\n'}"); do
  3. echo -e "\nTESTING ${t}"
  4. ./runtest.py ${t} || break
  5. done

Standalone Builds using Fooboot

wac and wace can be built to run as standalone bootable programs
using fooboot:

  1. cd wac
  2. git clone https://github.com/kanaka/fooboot
  3. make PLATFORM=fooboot clean
  4. make PLATFORM=fooboot wac wace examples_wat/addTwo.wasm

The fooboot/runfoo script can be used to boot wac/wace with QEMU.
fooboot/runfoo also creates a connection on a serial port (COM2)
that allows files to be read from the host system:

  1. fooboot/runfoo wac --repl examples_wat/addTwo.wasm
  2. QEMU waiting for connection on: disconnected:tcp:localhost:21118,server
  3. webassembly> addTwo 2 3
  4. 0x5:i32

The standalone wac/wace builds can also be built into an ISO image
that can boot directly on real hardware. You will need Grub 2 and the
Grub PC/BIOS binary files (grub-pc-bin) and the xorriso program to be
able to do this. Also, the wasm modules that you wish to run must be
built into the binary to become part of a simple in-memory
file-system:

  1. echo "examples_wat/addTwo.wasm" > mem_fs_files
  2. make PLATFORM=fooboot \
  3. FOO_TARGETS="wac" \
  4. FOO_CMDLINE="examples_wat/addTwo.wasm addTwo 3 4" \
  5. boot.iso

You can now boot the ISO with QEMU like this:

  1. qemu-system-i386 -cdrom boot.iso

Or you can burn the ISO to a USB device and boot from it on real
hardware. This will destroy any data on the USB device! Also, make
completely sure that /dev/MY_USB_DEVICE is really the USB device you
want to overwrite and not your hard drive. You have been warned!

  1. sudo dd if=boot.iso of=/dev/MY_USB_DEVICE && sync
  2. # Now boot you can boot from the USB device

License

MPL-2.0 (see LICENSE).