mirror of
https://github.com/wazero/wazero
synced 2026-06-21 14:12:37 +00:00
Edoardo Vacchi
bfb20e0ba7
Add experimental support to the Exception Handling spec. Exception handling adds structured error propagation to WebAssembly through `tags` (typed exception signatures), `throw/throw_ref` (raising exceptions), and `try_table` (catching exceptions with typed `catch` clauses). A new value type, `exnref`, represents a reference to a caught exception. Excluding tests and spec suites, the entire feature amounts to a little less than 2000 lines of code. Feature flag: `experimental.CoreFeaturesExceptionHandling` ## What's the use for this? In the spirit of always having a real use case for the specs we implement, I did check this implementation against the one large Wasm C++ codebase I am aware about, i.e. https://github.com/klippa-app/go-pdfium, and I verified that the entire suite, compiled with `emcc+wasm-opt` does work; incidentally, much of the existing support code, based on Emscripten's longjmp/setjmp, can be dropped (thx @jerbob92 for the help!) Broadly speaking, I don't know how much EH-enabled Wasm code you will find in the wild. For instance, code compiled using Clang's C++ backend does not really throw new-style exceptions, unless you compile WASI-SDK with some flags, or you build with `emcc` and translate old-style exceptions using `wasm-opt` (see exceptions_test.go) In short, this spec should be really seen as a step towards supporting the GC spec. The design decisions (esp. regarding the test suite) follow from this reasoning. ## Spec Suite `wast2json` **does not** support the EH suite, but `wasm-tools` does, albeit with a tiny quirk in the way negative numbers are rendered. In this PR _I am not_ moving the other suites to `wasm-tools` though. The spec test suite passes entirely, except for two tests that are intentionally skipped. These tests assume **a very small subset** of typed references is implemented; specifically, the distinction between nullable and non-nullable function references (`(ref null $t)` vs `(ref $t)`). I have decided to just flatten all non-nullable refs to nullable refs at decode time, so we cannot detect the type mismatch the spec expects in these cases. Passing the **full suite is actually straightforward** because it only requires introducing a non-nullable variant for each ref type: strictly speaking the 2 failing tests are only for related nullable vs non-nullable **func refs** -- so I can special-case these and/or add non-nullable types for each known value; however, we will **need** to rethink the representation of Values for the GC proposal anyway (because this will introduce custom type indices, and these won't fit our currently byte-sized `ValueType` enum). The subtype-checking functions (`isRefSubtypeOf`, `isStrictRefSubtypeOf`) are kept as abstraction points but currently they are just equalities. Nevertheless, as proven by the CPP example and https://github.com/klippa-app/go-pdfium this PR provides a starting point that is already useful (even if it is for limited cases). ## Interpreter Exception handling in the interpreter: **Within a frame**, `try_table` blocks are compiled into a static exception table with PC ranges. When `throw` or `throw_ref` executes, `searchExceptionTable` scans backwards (inner handlers first) for a catch clause whose PC range covers the current instruction. If a match is found, `applyExceptionHandler` adjusts the operand stack depth and jumps to the catch target PC directly. **Across frames**, if no handler is found in the current frame, `panic(&thrownException{...})` propagates up the Go call stack. Each cross-function call goes through `callWithUnwind()`, which uses `defer/recover` to intercept the panic. Its `canRestore` method unwinds `ce.frames` to the caller's depth and searches that frame's exception table. If a handler is found, `doRestore` applies it and `callWithUnwind` returns `true` (frame unwound -- caller refreshes locals and continues). If not, the panic re-propagates to the next outer `callWithUnwind`. Note on the implementation: this mechanism is unified with the existing `snapshot/restore` API through the `restorable` interface: both `*thrownException` and `*snapshot` implement `canRestore`/`doRestore`, so `callWithUnwind` handles both with a single defer/recover path. The short-circuit check (`len(exceptionTable) == 0 && no snapshotter`) skips the defer/recover overhead entirely for frames that don't need it. ## Compiler The compiler could not reuse the snapshot/restore mechanism directly, but it follows a similar pattern. One cool thing is that exception handling could be implemented entirely as an SSA-level lowering with new exit codes; there is no backend-specific code. Throwing uses a two-phase ABI: 1. `ExitCodeThrowAlloc`: exits to the Go runtime to allocate an `Exception` struct on the heap and writes a pointer to its params array into the execution context. Then we return control to compiled code, which stores the tag parameters directly into the struct. 2. `ExitCodeThrow`: exits to the Go runtime again to search for a matching handler, restore the stack checkpoint, and branch to the catch target. The idea is that we NEED to allocate the parameter slice dynamically, so we delegate to the Go runtime. Incidentally, this also allows us to unify `throw` and `throwRef`; in the latter case, we skip the `alloc` phase, and we exit straight to `ExitCodeThrow`. ### Trampolines The compiler uses four trampolines to return to host to manage exception state: | Trampoline | Exit Code | Purpose | |---|---|---| | **ThrowAlloc** | `ExitCodeThrowAlloc` | Allocates an `Exception` struct on the Go heap, writes `&exn.Params[0]` into `execCtx` so compiled code can store tag parameters directly. | | **Throw** | `ExitCodeThrow` | Searches `tryHandlers` for a matching catch clause, restores the stack checkpoint on match, sets `caughtExceptionClauseIdx` for the compiled dispatch. Used for both `throw` (after ThrowAlloc) and `throw_ref` (directly). | | **TryTableEnter** | `ExitCodeTryTableEnter` | Clones the current stack as a checkpoint, pushes a `tryHandler` with the catch clause table and saved module instance. Sets `caughtExceptionClauseIdx = -1` (no exception). | | **TryTableLeave** | `ExitCodeTryTableLeave` | Pops the most recent `tryHandler`. Emitted at `try_table` block ends, and before any branch or return that exits a `try_table` scope. | ### Lowering As mentioned earlier, this entirely resolved at the SSA-level. In particular: - **Entry**: when a `try_table` is encountered, the compiler emits a call to the TryTableEnter trampoline. Control returns to compiled code, which reads `caughtExceptionClauseIdx` from the execution context — if it's -1 (no exception), execution continues into the `try_table` body. - **Normal exit**: when execution reaches the `End` opcode of the `try_table` block, a TryTableLeave trampoline call is emitted. However, every TryTableEnter must have a matching TryTableLeave on every control flow path that doesn't throw; so we also "TryTableLeaves" also for the following: - **Early exit (branch)**: a `br`, `br_if`, or `br_table` can jump to a label outside the `try_table`, skipping its `End`. `emitTryTableLeaves(depth)` walks the control frame stack and emits one TryTableLeave for each `try_table` frame the branch crosses. For `br_if`, this happens in a trampoline basic block that only executes on the taken path. - **Early exit (return)**: `return`, `return_call`, and `return_call_indirect` call `emitTryTableLeaves` with the full control stack depth, popping all active handlers before leaving the frame. - **Throw**: on `throw`/`throw_ref`, compiled code exits to the dispatch loop via ExitCodeThrow. `doHandleException` searches `tryHandlers` innermost-to-outermost. On match, it restores the cloned stack checkpoint, sets `caughtExceptionClauseIdx`, and re-enters compiled code at the handler's return address. The compiled dispatch branches to the matching catch clause's handler block. ### Caveats - As described above, we are skipping 2 spec tests (will be addressed when we implement typed references) - Because of that, I am _not_ enabling by default the fuzzer: I would have to special-case for typed references and/or TODOs I have left behind; I did run the fuzzer with some special-casing while debugging the issue with pdfium (#2488) and did not find issues (the fuzzer did go frequently OOM though); in fact, the pdfium issue was actually unrelated (!) --------- Signed-off-by: Edoardo Vacchi <evacchi@users.noreply.github.com>
363 lines
18 KiB
Makefile
363 lines
18 KiB
Makefile
|
|
gofumpt := mvdan.cc/gofumpt@v0.6.0
|
|
gosimports := github.com/rinchsan/gosimports/cmd/gosimports@v0.3.8
|
|
golangci_lint := github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.5
|
|
asmfmt := github.com/klauspost/asmfmt/cmd/asmfmt@v1.3.2
|
|
# sync this with netlify.toml!
|
|
hugo := github.com/gohugoio/hugo@v0.115.2
|
|
|
|
# Make 3.81 doesn't support '**' globbing: Set explicitly instead of recursion.
|
|
all_sources := $(wildcard *.go */*.go */*/*.go */*/*/*.go */*/*/*.go */*/*/*/*.go)
|
|
all_testdata := $(wildcard testdata/* */testdata/* */*/testdata/* */*/testdata/*/* */*/*/testdata/*)
|
|
all_testing := $(wildcard internal/testing/* internal/testing/*/* internal/testing/*/*/*)
|
|
all_examples := $(wildcard examples/* examples/*/* examples/*/*/* */*/example/* */*/example/*/* */*/example/*/*/*)
|
|
all_it := $(wildcard internal/integration_test/* internal/integration_test/*/* internal/integration_test/*/*/*)
|
|
# main_sources exclude any test or example related code
|
|
main_sources := $(wildcard $(filter-out %_test.go $(all_testdata) $(all_testing) $(all_examples) $(all_it), $(all_sources)))
|
|
# main_packages collect the unique main source directories (sort will dedupe).
|
|
# Paths need to all start with ./, so we do that manually vs foreach which strips it.
|
|
main_packages := $(sort $(foreach f,$(dir $(main_sources)),$(if $(findstring ./,$(f)),./,./$(f))))
|
|
|
|
go_test_options ?= -timeout 300s
|
|
|
|
.PHONY: test.examples
|
|
test.examples:
|
|
@go test $(go_test_options) ./examples/... ./imports/assemblyscript/example/... ./imports/emscripten/... ./imports/wasi_snapshot_preview1/example/...
|
|
|
|
.PHONY: build.examples.as
|
|
build.examples.as:
|
|
@cd ./imports/assemblyscript/example/testdata && npm install && npm run build
|
|
|
|
%.wasm: %.zig
|
|
@(cd $(@D); zig build -Doptimize=ReleaseSmall)
|
|
@mv $(@D)/zig-out/*/$(@F) $(@D)
|
|
|
|
.PHONY: build.examples.zig
|
|
build.examples.zig: examples/allocation/zig/testdata/greet.wasm imports/wasi_snapshot_preview1/example/testdata/zig/cat.wasm imports/wasi_snapshot_preview1/testdata/zig/wasi.wasm
|
|
@cd internal/testing/dwarftestdata/testdata/zig; zig build; mv zig-out/*/main.wasm ./ # Need DWARF custom sections.
|
|
|
|
tinygo_reactor_sources_reactor := examples/basic/testdata/add.go examples/allocation/tinygo/testdata/greet.go
|
|
.PHONY: build.examples.tinygo_reactor
|
|
build.examples.tinygo_reactor: $(tinygo_sources_reactor)
|
|
@for f in $^; do \
|
|
tinygo build -o $$(echo $$f | sed -e 's/\.go/\.wasm/') -scheduler=none --no-debug --target=wasip1 -buildmode=c-shared $$f; \
|
|
done
|
|
|
|
tinygo_sources_clis := examples/cli/testdata/cli.go imports/wasi_snapshot_preview1/example/testdata/tinygo/cat.go imports/wasi_snapshot_preview1/testdata/tinygo/wasi.go cmd/wazero/testdata/cat/cat.go
|
|
.PHONY: build.examples.tinygo_clis
|
|
build.examples.tinygo_clis: $(tinygo_sources_clis)
|
|
@for f in $^; do \
|
|
tinygo build -o $$(echo $$f | sed -e 's/\.go/\.wasm/') -scheduler=none --no-debug --target=wasip1 $$f; \
|
|
done
|
|
@mv cmd/wazero/testdata/cat/cat.wasm cmd/wazero/testdata/cat/cat-tinygo.wasm
|
|
|
|
.PHONY: build.examples.tinygo
|
|
build.examples.tinygo: build.examples.tinygo_reactor build.examples.tinygo_clis
|
|
|
|
# We use zig to build C as it is easy to install and embeds a copy of zig-cc.
|
|
# Note: Don't use "-Oz" as that breaks our wasi sock example.
|
|
c_sources := imports/wasi_snapshot_preview1/example/testdata/zig-cc/cat.c imports/wasi_snapshot_preview1/testdata/zig-cc/wasi.c internal/testing/dwarftestdata/testdata/zig-cc/main.c
|
|
.PHONY: build.examples.zig-cc
|
|
build.examples.zig-cc: $(c_sources)
|
|
@for f in $^; do \
|
|
zig cc --target=wasm32-wasi -o $$(echo $$f | sed -e 's/\.c/\.wasm/') $$f; \
|
|
done
|
|
|
|
# Here are the emcc args we use:
|
|
#
|
|
# * `-Oz` - most optimization for code size.
|
|
# * `--profiling` - adds the name section.
|
|
# * `-s STANDALONE_WASM` - ensures wasm is built for a non-js runtime.
|
|
# * `-s EXPORTED_FUNCTIONS=_malloc,_free` - export allocation functions so that
|
|
# they can be used externally as "malloc" and "free".
|
|
# * `-s WARN_ON_UNDEFINED_SYMBOLS=0` - imports not defined in JavaScript error
|
|
# otherwise. See https://github.com/emscripten-core/emscripten/issues/13641
|
|
# * `-s TOTAL_STACK=8KB -s TOTAL_MEMORY=64KB` - reduce memory default from 16MB
|
|
# to one page (64KB). To do this, we have to reduce the stack size.
|
|
# * `-s ALLOW_MEMORY_GROWTH` - allows "memory.grow" instructions to succeed, but
|
|
# requires a function import "emscripten_notify_memory_growth".
|
|
emscripten_sources := $(wildcard imports/emscripten/testdata/*.cc)
|
|
.PHONY: build.examples.emscripten
|
|
build.examples.emscripten: $(emscripten_sources)
|
|
@for f in $^; do \
|
|
em++ -Oz --profiling \
|
|
-s STANDALONE_WASM \
|
|
-s EXPORTED_FUNCTIONS=_malloc,_free \
|
|
-s WARN_ON_UNDEFINED_SYMBOLS=0 \
|
|
-s TOTAL_STACK=8KB -s TOTAL_MEMORY=64KB \
|
|
-s ALLOW_MEMORY_GROWTH \
|
|
--std=c++17 -o $$(echo $$f | sed -e 's/\.cc/\.wasm/') $$f; \
|
|
done
|
|
|
|
%/greet.wasm : cargo_target := wasm32-unknown-unknown
|
|
%/cat.wasm : cargo_target := wasm32-wasip1
|
|
%/wasi.wasm : cargo_target := wasm32-wasip1
|
|
|
|
.PHONY: build.examples.rust
|
|
build.examples.rust: examples/allocation/rust/testdata/greet.wasm imports/wasi_snapshot_preview1/example/testdata/cargo-wasi/cat.wasm imports/wasi_snapshot_preview1/testdata/cargo-wasi/wasi.wasm internal/testing/dwarftestdata/testdata/rust/main.wasm.xz
|
|
|
|
# Normally, we build release because it is smaller. Testing dwarf requires the debug build.
|
|
internal/testing/dwarftestdata/testdata/rust/main.wasm.xz:
|
|
cd $(@D) && cargo build --target wasm32-wasip1
|
|
mv $(@D)/target/wasm32-wasip1/debug/main.wasm $(@D)
|
|
cd $(@D) && xz -k -f ./main.wasm # Rust's DWARF section is huge, so compress it.
|
|
|
|
# Builds rust using cargo normally
|
|
%.wasm: %.rs
|
|
@(cd $(@D); cargo build --target $(cargo_target) --release)
|
|
@mv $(@D)/target/$(cargo_target)/release/$(@F) $(@D)
|
|
|
|
spectest_base_dir := internal/integration_test/spectest
|
|
|
|
spectest_v1_dir := $(spectest_base_dir)/v1
|
|
spectest_v1_testdata_dir := $(spectest_v1_dir)/testdata
|
|
spec_version_v1 := wg-1.0
|
|
|
|
spectest_v2_dir := $(spectest_base_dir)/v2
|
|
spectest_v2_testdata_dir := $(spectest_v2_dir)/testdata
|
|
spec_version_v2 := wg-2.0
|
|
|
|
spectest_threads_dir := $(spectest_base_dir)/threads
|
|
spectest_threads_testdata_dir := $(spectest_threads_dir)/testdata
|
|
spec_version_threads := ff17701446d8e2086142423ef77ae947a025e26f
|
|
|
|
spectest_tail_call_dir := $(spectest_base_dir)/tail-call
|
|
spectest_tail_call_testdata_dir := $(spectest_tail_call_dir)/testdata
|
|
spec_version_tail_call := 88e97b0f742f4c3ee01fea683da130f344dd7b02
|
|
|
|
spectest_extended_const_dir := $(spectest_base_dir)/extended-const
|
|
spectest_extended_const_testdata_dir := $(spectest_extended_const_dir)/testdata
|
|
|
|
spectest_exception_handling_dir := $(spectest_base_dir)/exception-handling
|
|
spectest_exception_handling_testdata_dir := $(spectest_exception_handling_dir)/testdata
|
|
spec_version_exception_handling := 13734f8fb871a5dab939070f893adbd90bffe28c
|
|
|
|
.PHONY: build.spectest
|
|
build.spectest:
|
|
@$(MAKE) build.spectest.v1
|
|
@$(MAKE) build.spectest.v2
|
|
@$(MAKE) build.spectest.threads
|
|
@$(MAKE) build.spectest.tail_call
|
|
@$(MAKE) build.spectest.extended_const
|
|
@$(MAKE) build.spectest.exception_handling
|
|
|
|
.PHONY: build.spectest.v1
|
|
build.spectest.v1: # Note: wabt by default uses >1.0 features, so wast2json flags might drift as they include more. See WebAssembly/wabt#1878
|
|
@rm -rf $(spectest_v1_testdata_dir)
|
|
@mkdir -p $(spectest_v1_testdata_dir)
|
|
@cd $(spectest_v1_testdata_dir) \
|
|
&& curl -sSL 'https://api.github.com/repos/WebAssembly/spec/contents/test/core?ref=$(spec_version_v1)' | jq -r '.[]| .download_url' | grep -E ".wast" | xargs -Iurl curl -sJL url -O
|
|
@cd $(spectest_v1_testdata_dir) && for f in `find . -name '*.wast'`; do \
|
|
perl -pi -e 's/\(assert_return_canonical_nan\s(\(invoke\s"f32.demote_f64"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \(f32.const nan:canonical\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_arithmetic_nan\s(\(invoke\s"f32.demote_f64"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \(f32.const nan:arithmetic\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_canonical_nan\s(\(invoke\s"f64\.promote_f32"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \(f64.const nan:canonical\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_arithmetic_nan\s(\(invoke\s"f64\.promote_f32"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \(f64.const nan:arithmetic\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_canonical_nan\s(\(invoke\s"[a-z._0-9]+"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \($$2.const nan:canonical\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_arithmetic_nan\s(\(invoke\s"[a-z._0-9]+"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \($$2.const nan:arithmetic\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_canonical_nan\s(\(invoke\s"[a-z._0-9]+"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\s\([a-z0-9.\s+-:]+\)\))\)/\(assert_return $$1 \($$2.const nan:canonical\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_arithmetic_nan\s(\(invoke\s"[a-z._0-9]+"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\s\([a-z0-9.\s+-:]+\)\))\)/\(assert_return $$1 \($$2.const nan:arithmetic\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_canonical_nan\s(\(invoke\s"[a-z._0-9]+"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \($$2.const nan:canonical\)\)/g' $$f; \
|
|
perl -pi -e 's/\(assert_return_arithmetic_nan\s(\(invoke\s"[a-z._0-9]+"\s\((f[0-9]{2})\.const\s[a-z0-9.+:-]+\)\))\)/\(assert_return $$1 \($$2.const nan:arithmetic\)\)/g' $$f; \
|
|
wast2json \
|
|
--disable-saturating-float-to-int \
|
|
--disable-sign-extension \
|
|
--disable-simd \
|
|
--disable-multi-value \
|
|
--disable-bulk-memory \
|
|
--disable-reference-types \
|
|
--debug-names $$f; \
|
|
done
|
|
|
|
.PHONY: build.spectest.v2
|
|
build.spectest.v2: # Note: SIMD cases are placed in the "simd" subdirectory.
|
|
@rm -rf $(spectest_v2_testdata_dir)
|
|
@mkdir -p $(spectest_v2_testdata_dir)
|
|
@cd $(spectest_v2_testdata_dir) \
|
|
&& curl -sSL 'https://api.github.com/repos/WebAssembly/spec/contents/test/core?ref=$(spec_version_v2)' | jq -r '.[]| .download_url' | grep -E ".wast" | xargs -Iurl curl -sJL url -O
|
|
@cd $(spectest_v2_testdata_dir) \
|
|
&& curl -sSL 'https://api.github.com/repos/WebAssembly/spec/contents/test/core/simd?ref=$(spec_version_v2)' | jq -r '.[]| .download_url' | grep -E ".wast" | xargs -Iurl curl -sJL url -O
|
|
@cd $(spectest_v2_testdata_dir) && for f in `find . -name '*.wast'`; do \
|
|
wast2json --debug-names --no-check $$f || true; \
|
|
done # Ignore the error here as some tests (e.g. comments.wast right now) are not supported by wast2json yet.
|
|
|
|
# Note: We currently cannot build the "threads" subdirectory that spawns threads due to missing support in wast2json.
|
|
# https://github.com/WebAssembly/wabt/issues/2348#issuecomment-1878003959
|
|
.PHONY: build.spectest.threads
|
|
build.spectest.threads:
|
|
@rm -rf $(spectest_threads_testdata_dir)
|
|
@mkdir -p $(spectest_threads_testdata_dir)
|
|
@cd $(spectest_threads_testdata_dir) \
|
|
&& curl -sSL 'https://api.github.com/repos/WebAssembly/threads/contents/test/core/threads?ref=$(spec_version_threads)' | jq -r '.[]| .download_url' | grep -E "/atomic.wast" | xargs -Iurl curl -sJL url -O
|
|
@cd $(spectest_threads_testdata_dir) && for f in `find . -name '*.wast'`; do \
|
|
wast2json --enable-threads --debug-names $$f; \
|
|
done
|
|
|
|
.PHONY: build.spectest.extended_const
|
|
build.spectest.extended_const:
|
|
@cd $(spectest_extended_const_testdata_dir) && for f in `find . -name '*.wast'`; do \
|
|
wast2json --enable-extended-const --debug-names $$f; \
|
|
done
|
|
|
|
.PHONY: build.spectest.tail_call
|
|
build.spectest.tail_call:
|
|
@rm -rf $(spectest_tail_call_testdata_dir)
|
|
@mkdir -p $(spectest_tail_call_testdata_dir)
|
|
@cd $(spectest_tail_call_testdata_dir) \
|
|
&& curl -sSL 'https://api.github.com/repos/WebAssembly/testsuite/contents/proposals/tail-call?ref=$(spec_version_tail_call)' | jq -r '.[]| .download_url' | grep -E ".wast" | xargs -Iurl curl -sJL url -O
|
|
@cd $(spectest_tail_call_testdata_dir) && for f in `find . -name '*.wast'`; do \
|
|
wast2json --enable-tail-call --debug-names $$f; \
|
|
done
|
|
|
|
.PHONY: build.spectest.exception_handling
|
|
build.spectest.exception_handling:
|
|
@rm -rf $(spectest_exception_handling_testdata_dir)
|
|
@mkdir -p $(spectest_exception_handling_testdata_dir)
|
|
@cd $(spectest_exception_handling_testdata_dir) \
|
|
&& curl -sSL 'https://api.github.com/repos/WebAssembly/spec/contents/test/core/exceptions?ref=$(spec_version_exception_handling)' \
|
|
| jq -r '.[]| .download_url' | grep -E ".wast" | xargs -Iurl curl -sJL url -O
|
|
@cd $(spectest_exception_handling_testdata_dir) && for f in `find . -name '*.wast'`; do \
|
|
wasm-tools json-from-wast --wasm-dir . -o $$(basename $$f .wast).json $$f || true; \
|
|
done
|
|
|
|
.PHONY: test
|
|
test:
|
|
@go test $(go_test_options) ./...
|
|
@cd internal/version/testdata && go test $(go_test_options) ./...
|
|
@cd internal/integration_test/fuzz/wazerolib && CGO_ENABLED=0 WASM_BINARY_PATH=testdata/test.wasm go test ./...
|
|
|
|
.PHONY: coverage
|
|
# replace spaces with commas
|
|
coverpkg = $(shell echo $(main_packages) | tr ' ' ',')
|
|
coverage: ## Generate test coverage
|
|
@go test -coverprofile=coverage.txt -covermode=atomic --coverpkg=$(coverpkg) $(main_packages)
|
|
@go tool cover -func coverage.txt
|
|
|
|
golangci_lint_path := $(shell go env GOPATH)/bin/golangci-lint
|
|
|
|
$(golangci_lint_path):
|
|
@go install $(golangci_lint)
|
|
|
|
golangci_lint_goarch ?= $(shell go env GOARCH)
|
|
|
|
.PHONY: lint
|
|
lint: $(golangci_lint_path)
|
|
@GOARCH=$(golangci_lint_goarch) CGO_ENABLED=0 $(golangci_lint_path) run --timeout 5m -E testableexamples
|
|
|
|
.PHONY: format
|
|
format:
|
|
@go run $(gofumpt) -l -w .
|
|
@go run $(gosimports) -local github.com/tetratelabs/ -w $(shell find . -name '*.go' -type f)
|
|
@go run $(asmfmt) -w $(shell find . -name '*.s' -type f)
|
|
|
|
.PHONY: check # Pre-flight check for pull requests
|
|
check:
|
|
# The following checks help ensure our platform-specific code used for system
|
|
# calls safely falls back on a platform unsupported by the compiler engine.
|
|
# This makes sure the intepreter can be used. Most often the package that can
|
|
# drift here is "platform" or "sysfs":
|
|
#
|
|
# Ensure we build on plan9. See #1578
|
|
@GOARCH=amd64 GOOS=plan9 go build ./...
|
|
# Ensure we build on gojs. See #1526.
|
|
@GOARCH=wasm GOOS=js go build ./...
|
|
# Ensure we build on wasip1. See #1526.
|
|
@GOARCH=wasm GOOS=wasip1 go build ./...
|
|
# Ensure we build on aix. See #1723
|
|
@GOARCH=ppc64 GOOS=aix go build ./...
|
|
# Ensure we build on linux s390x. See #2412
|
|
@GOARCH=s390x GOOS=linux go build ./...
|
|
# Ensure we build on linux ppc64le. See #2412
|
|
@GOARCH=ppc64le GOOS=linux go build ./...
|
|
# Ensure we build on linux arm for Dapr:
|
|
# gh release view -R dapr/dapr --json assets --jq 'first(.assets[] | select(.name = "daprd_linux_arm.tar.gz") | {url, downloadCount})'
|
|
@GOARCH=arm GOOS=linux go build ./...
|
|
# Ensure we build on linux 386 for Trivy:
|
|
# gh release view -R aquasecurity/trivy --json assets --jq 'first(.assets[] | select(.name| test("Linux-32bit.*tar.gz")) | {url, downloadCount})'
|
|
@GOARCH=386 GOOS=linux go build ./...
|
|
# Ensure we build on FreeBSD amd64 for Trivy:
|
|
# gh release view -R aquasecurity/trivy --json assets --jq 'first(.assets[] | select(.name| test("FreeBSD-64bit.*tar.gz")) | {url, downloadCount})'
|
|
@GOARCH=amd64 GOOS=freebsd go build ./...
|
|
@$(MAKE) lint golangci_lint_goarch=arm64
|
|
@$(MAKE) lint golangci_lint_goarch=amd64
|
|
@$(MAKE) format
|
|
@go mod tidy
|
|
@if [ ! -z "`git status -s`" ]; then \
|
|
echo "The following differences will fail CI until committed:"; \
|
|
git diff --exit-code; \
|
|
fi
|
|
|
|
.PHONY: site
|
|
site: ## Serve website content
|
|
@git submodule update --init
|
|
@cd site && go run $(hugo) server --minify --disableFastRender --baseURL localhost:1313 --cleanDestinationDir -D
|
|
|
|
.PHONY: clean
|
|
clean: ## Ensure a clean build
|
|
@rm -rf dist build coverage.txt
|
|
@go clean -testcache
|
|
|
|
fuzz_default_flags := --no-trace-compares --sanitizer=none -- -rss_limit_mb=8192
|
|
|
|
fuzz_timeout_seconds ?= 10
|
|
.PHONY: fuzz
|
|
fuzz:
|
|
@cd internal/integration_test/fuzz && cargo test
|
|
@cd internal/integration_test/fuzz && cargo fuzz run logging_no_diff $(fuzz_default_flags) -max_total_time=$(fuzz_timeout_seconds)
|
|
@cd internal/integration_test/fuzz && cargo fuzz run no_diff $(fuzz_default_flags) -max_total_time=$(fuzz_timeout_seconds)
|
|
@cd internal/integration_test/fuzz && cargo fuzz run memory_no_diff $(fuzz_default_flags) -max_total_time=$(fuzz_timeout_seconds)
|
|
@cd internal/integration_test/fuzz && cargo fuzz run validation $(fuzz_default_flags) -max_total_time=$(fuzz_timeout_seconds)
|
|
|
|
libsodium:
|
|
cd ./internal/integration_test/libsodium/testdata && \
|
|
curl -s "https://api.github.com/repos/jedisct1/webassembly-benchmarks/contents/2022-12/wasm?ref=7e86d68e99e60130899fbe3b3ab6e9dce9187a7c" \
|
|
| jq -r '.[] | .download_url' | xargs -n 1 curl -LO
|
|
|
|
#### CLI release related ####
|
|
|
|
VERSION ?= dev
|
|
non_windows_platforms := darwin_amd64 darwin_arm64 linux_amd64 linux_arm64
|
|
non_windows_archives := $(non_windows_platforms:%=dist/wazero_$(VERSION)_%.tar.gz)
|
|
windows_platforms := windows_amd64 # TODO: add arm64 windows once we start testing on it.
|
|
windows_archives := $(windows_platforms:%=dist/wazero_$(VERSION)_%.zip)
|
|
checksum_txt := dist/wazero_$(VERSION)_checksums.txt
|
|
|
|
# define macros for multi-platform builds. these parse the filename being built
|
|
go-arch = $(if $(findstring amd64,$1),amd64,arm64)
|
|
go-os = $(if $(findstring .exe,$1),windows,$(if $(findstring linux,$1),linux,darwin))
|
|
|
|
build/wazero_%/wazero:
|
|
$(call go-build,$@,$<)
|
|
|
|
build/wazero_%/wazero.exe:
|
|
$(call go-build,$@,$<)
|
|
|
|
dist/wazero_$(VERSION)_%.tar.gz: build/wazero_%/wazero
|
|
@echo tar.gz "tarring $@"
|
|
@mkdir -p $(@D)
|
|
# On Windows, we pass the special flag `--mode='+rx' to ensure that we set the executable flag.
|
|
# This is only supported by GNU Tar, so we set it conditionally.
|
|
@tar -C $(<D) -cpzf $@ $(if $(findstring Windows_NT,$(OS)),--mode='+rx',) $(<F)
|
|
@echo tar.gz "ok"
|
|
|
|
define go-build
|
|
@echo "building $1"
|
|
@# $(go:go=) removes the trailing 'go', so we can insert cross-build variables
|
|
@$(go:go=) CGO_ENABLED=0 GOOS=$(call go-os,$1) GOARCH=$(call go-arch,$1) go build \
|
|
-ldflags "-s -w -X github.com/tetratelabs/wazero/internal/version.version=$(VERSION)" \
|
|
-o $1 $2 ./cmd/wazero
|
|
@echo build "ok"
|
|
endef
|
|
|
|
dist/wazero_$(VERSION)_%.zip: build/wazero_%/wazero.exe
|
|
@echo zip "zipping $@"
|
|
@mkdir -p $(@D)
|
|
@zip -qj $@ $<
|
|
@echo zip "ok"
|
|
|
|
# Darwin doesn't have sha256sum. See https://github.com/actions/virtual-environments/issues/90
|
|
sha256sum := $(if $(findstring darwin,$(shell go env GOOS)),shasum -a 256,sha256sum)
|
|
$(checksum_txt): $(non_windows_archives) $(windows_archives)
|
|
@cd $(@D); touch $(@F); $(sha256sum) * > $(@F)
|
|
|
|
dist: $(non_windows_archives) $(windows_archives) $(checksum_txt)
|