wac

wac - WebAssembly en C

Un intérprete mínimo de WebAssembly escrito en C. Admite la versión WebAssembly MVP (producto mínimo viable) de la especificación WebAssembly.

Hay tres versiones diferentes de wac:

• wac : (WebAssembly en C) Cliente mínimo con un modo REPL interactivo. Diseñado para ejecutar archivos wasm independientes compilados con wat2wasm o wasm-as . Pasa la mayoría de las pruebas de especificaciones, excepto algunas pruebas de importación/exportación de varios módulos.
• cera : (WebAssembly en C con WASI) Cliente con API de interfaz del sistema WebAssembly (WASI).
• wace : (WebAssembly en C con Emscripten) Cliente con integración de memoria/biblioteca host. Diseñado para ejecutar código wasm creado con Emscripten (usando -s SIDE_MODULE=1 -s LEGALIZE_JS_FFI=0 ).

Requisitos previos

Para compilar wac/wax/wace necesita una versión de 32 bits de gcc y versiones de 32 bits de SDL2 y libedit. En Ubuntu/Debian de 64 bits, se pueden instalar así:

 dpkg --add-architecture i386
apt-get update
apt-get install lib32gcc-4.9-dev libSDL2-dev:i386 libedit-dev:i386

Para compilar archivos fuente wat en módulos binarios wasm, necesitará el programa wasm-as de Binaryen. Para compilar programas C en módulos wasm necesitará Binaryen y emscripten.

Como alternativa a descargar y crear las herramientas anteriores, la imagen de la ventana acoplable kanaka/wac (1,7 GB) tiene un compilador/bibliotecas gcc de 32 bits, emscripten y binario preinstalados. La imagen de la ventana acoplable se puede iniciar con montajes de archivos apropiados como este:

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

Todos los comandos de compilación siguientes se pueden ejecutar dentro del contenedor acoplable.

uso de wac

Construir wac:

$ make wac

Utilice wasm-as para compilar un programa wat simple en wasm:

$ make examples_wat/arith.wasm

Ahora cargue el archivo wasm compilado e invoque algunas funciones:

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

wac también admite un modo REPL (read-eval-print-loop) muy simple que ejecuta comandos en forma de FUNC ARG... :

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

uso de cera

Construir cera:

$ make wax

Utilice wasm-as para compilar un programa wat que utilice la interfaz WASI:

$ make examples_wat/echo.wasm

Ahora ejecute el archivo wasm compilado. El programa lee el texto de la entrada estándar y lo repite en la salida estándar hasta que se envía un EOF (Ctrl-D).

$ ./wax examples_wat/echo.wasm
> foo
foo
> bar
bar
> < Ctrl-D > 

uso de wace

Construir wace:

$ make wace

Utilice emscripten/binaryen para compilar algunos programas C simples y ejecutarlos usando wace:

$ make examples_c/hello1.wasm
$ ./wace examples_c/hello1.wasm
hello world

$ make examples_c/hello2.wasm
$ ./wace examples_c/hello2.wasm
hello malloc people

Utilice emscripten/binaryen para compilar algunos programas C SDL y ejecutarlos usando wace:

$ make examples_c/hello_sdl.wasm
$ ./wace examples_c/hello_sdl.wasm
INFO: OpenGL shaders: ENABLED
INFO: Created renderer: opengl
# Blue Window displayed for 2 seconds
Done.

$ make examples_c/triangle.wasm
$ ./wace examples_c/triangle.wasm
# A colorfully shaded triangle is rendered 

Ejecución de pruebas de especificaciones de WebAssembly

wac incluye un controlador de prueba runtest.py que se puede utilizar para ejecutar pruebas desde la especificación WebAssembly.

Mira las especificaciones:

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

Necesitará wat2wasm para compilar las pruebas de especificaciones. Pagar y construir wabt (wabbit):

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

Ejecute el archivo de prueba func.wast (para probar llamadas a funciones) desde la especificación:

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

Ejecute todas las pruebas de especificaciones, excepto algunas que actualmente fallan (principalmente debido a que runtest.py no admite algunas sintaxis utilizadas en esos archivos de prueba):

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

Compilaciones independientes usando Fooboot

wac y wace se pueden crear para ejecutarse como programas de arranque independientes usando fooboot:

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

El script fooboot/runfoo se puede utilizar para iniciar wac/wace con QEMU. fooboot/runfoo también crea una conexión en un puerto serie (COM2) que permite leer archivos desde el sistema host:

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

Las compilaciones wac/wace independientes también se pueden integrar en una imagen ISO que puede arrancar directamente en hardware real. Necesitará Grub 2 y los archivos binarios de Grub PC/BIOS (grub-pc-bin) y el programa xorriso para poder hacer esto. Además, los módulos wasm que desea ejecutar deben estar integrados en el binario para que formen parte de un sistema de archivos simple en memoria:

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

Ahora puedes iniciar la ISO con QEMU de esta manera:

 qemu-system-i386 -cdrom boot.iso

O puede grabar el ISO en un dispositivo USB y arrancar desde él en hardware real. ¡Esto destruirá todos los datos del dispositivo USB! Además, asegúrese completamente de que /dev/MY_USB_DEVICE sea realmente el dispositivo USB que desea sobrescribir y no su disco duro. ¡Has sido advertido!

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

Licencia

MPL-2.0 (ver LICENCIA).