wac

wac - WebAssembly em C

Um interpretador Minimal WebAssembly escrito em C. Suporta a versão WebAssembly MVP (produto mínimo viável) da especificação WebAssembly.

Existem três versões diferentes de wac:

• wac : (WebAssembly em C) Cliente mínimo com modo REPL interativo. Projetado para executar arquivos wasm independentes compilados com wat2wasm ou wasm-as . Passa na maioria dos testes de especificações, exceto alguns testes de importação/exportação de vários módulos.
• cera : (WebAssembly em C com WASI) Cliente com APIs de interface de sistema WebAssembly (WASI).
• wace : (WebAssembly em C com Emscripten) Cliente com integração de biblioteca/memória host. Projetado para executar código wasm que foi construído com Emscripten (usando -s SIDE_MODULE=1 -s LEGALIZE_JS_FFI=0 ).

Pré-requisitos

Para construir wac/wax/wace você precisa de uma versão de 32 bits do gcc e versões de 32 bits do SDL2 e libedit. No Ubuntu/Debian de 64 bits, eles podem ser instalados assim:

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

Para compilar arquivos fonte wat para módulos wasm binários, você precisará do programa wasm-as da Binaryen. Para compilar programas C para módulos wasm você precisará de Binaryen e emscripten.

Como alternativa ao download e construção das ferramentas acima, a imagem docker kanaka/wac (1,7 GB) possui compilador/bibliotecas gcc de 32 bits, emscripten e binaryen pré-instalados. A imagem do Docker pode ser iniciada com montagens de arquivo apropriadas como esta:

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

Todos os comandos de construção abaixo podem ser executados no contêiner docker.

uso de wac

Construir wac:

$ make wac

Use wasm-as para compilar um programa wat simples para um wasm:

$ make examples_wat/arith.wasm

Agora carregue o arquivo wasm compilado e invoque algumas funções:

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

wac também suporta um modo REPL (read-eval-print-loop) muito simples que executa comandos na 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

Use wasm-as para compilar um programa wat que usa a interface WASI:

$ make examples_wat/echo.wasm

Agora execute o arquivo wasm compilado. O programa lê o texto de stdin e faz eco para stdout até que um EOF (Ctrl-D) seja enviado.

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

uso de wace

Construir wace:

$ make wace

Use emscripten/binaryen para compilar alguns programas C simples e executá-los 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

Use emscripten/binaryen para compilar alguns programas C SDL e executá-los 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 

Executando testes de especificações do WebAssembly

wac inclui um driver de teste runtest.py que pode ser usado para executar testes da especificação WebAssembly.

Confira as especificações:

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

Você precisará wat2wasm para compilar os testes de especificações. Confira e construa wabt (wabbit):

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

Execute o arquivo de teste func.wast (para testar chamadas de função) da especificação:

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

Execute todos os testes de especificações, exceto alguns que falham atualmente (principalmente devido à falta de suporte runtest.py para alguma sintaxe usada nesses arquivos de teste):

 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

Construções autônomas usando Fooboot

wac e wace podem ser criados para rodar como programas inicializáveis ​​independentes usando fooboot:

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

O script fooboot/runfoo pode ser usado para inicializar wac/wace com QEMU. fooboot/runfoo também cria uma conexão em uma porta serial (COM2) que permite a leitura de arquivos do 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

As compilações wac/wace independentes também podem ser incorporadas em uma imagem ISO que pode inicializar diretamente em hardware real. Você precisará do Grub 2 e dos arquivos binários Grub PC/BIOS (grub-pc-bin) e do programa xorriso para poder fazer isso. Além disso, os módulos wasm que você deseja executar devem ser incorporados ao binário para se tornarem parte de um sistema de arquivos simples na memória:

 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

Agora você pode inicializar o ISO com QEMU assim:

 qemu-system-i386 -cdrom boot.iso

Ou você pode gravar o ISO em um dispositivo USB e inicializá-lo em hardware real. Isso destruirá todos os dados do dispositivo USB! Além disso, certifique-se de que /dev/MY_USB_DEVICE é realmente o dispositivo USB que você deseja substituir e não o seu disco rígido. Você foi avisado!

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

Licença

MPL-2.0 (ver LICENÇA).