Add `bulk_memory` to wast configuration (#12883)Allows enabling/disabling this wasm proposal on a per-test basis.
Refactor how wasm features are calculated for `*.wast` tests (#9560)* Refactor how wasm features are calculated for `*.wast` testsThis commit refactors the `tests/wast.rs` test suite which runs a
Refactor how wasm features are calculated for `*.wast` tests (#9560)* Refactor how wasm features are calculated for `*.wast` testsThis commit refactors the `tests/wast.rs` test suite which runs all ofthe upstream spec tests as `*.wast` files as well as our own`misc_testsuite` which has its own suite of `*.wast` files. Previouslythe set of wasm features active for each test was a sort of randommishmash and convoluted set of conditionals which was updated and editedover time as upstream proposal test suites evolved. This was thenmirrored into our own conventions for `misc_testsuite` as well. Overallthough this has a number of downsides I'm trying to fix here:* The calculation of what features are enabled is quite complicated and effectively a random mishmash of `||` conditionals with hierarchies that don't make any sense beyond "this is just required to get things to pass".* There is no means of per-test configuration. For example `canonicalize-nans.wast` had hardcoded logic in `tests/wast.rs` that it needed a different setting turned on in `Config`.* There was no easy means to write tests for Wasmtime which take a union of a number of proposals together without having lots of sub-folders that may not make sense.* Tests that require a particular proposal had to have duplicate logic for Winch as it doesn't support the full suite of features of all proposals that Cranelift does.The new system implemented in this commit takes a leaf out of the`disas` tests. There is a new `TestConfig` structure in the`tests/wast.rs` harness which is decoded from each test (leading `;;!`comments) which enables specifying, in each test, what's required. Thisencompasses many wasm proposals but additionally captures other behaviorlike nan-canonicalization. This means that all test files in`misc_testsuite/**/*.wast` are now manually annotated with what wasmfeatures they require and what's needed to run. This makes per-testconfiguration much easier, per-config-setting much easier, and blanketignore-by-proposal for Winch much easier as well.For spec tests we can't modify the contents of the upstream `*.wast`files. To handle this they're handled specially where `TestConfig` ismanually created and manipulated for each spec proposal and the maintest suite itself. This enables per-proposal configuration that doesn'tleak into any others and makes it more obvious what proposals are doingwhat.* Hack around Winch support for aarch64
show more ...
Implement new `*.wast` directives in `wasmtime-wast` (#9223)* Implement new `*.wast` directives in `wasmtime-wast`This is a follow-up from #9219 to add support for a few more directivesin `*.was
Implement new `*.wast` directives in `wasmtime-wast` (#9223)* Implement new `*.wast` directives in `wasmtime-wast`This is a follow-up from #9219 to add support for a few more directivesin `*.wast` tests to notably compile a module and possibly instantiateit multiple times.This copies the upstream spec test using these new directives and editsit to remove the unsupported exception-handling bits.* Fix tests to test the right thing* Fix a test to use `assert_unlinkable`* Add a component/instance test for components too
Skip type checks on tables that don't need it (#8172)* Enhance `typed-funcrefs.wast` test with more casesHave the same function with slightly different variations to comparecodegen between the
Skip type checks on tables that don't need it (#8172)* Enhance `typed-funcrefs.wast` test with more casesHave the same function with slightly different variations to comparecodegen between the possible strategies.* Skip type checks on tables that don't need itThis commit implements an optimization to skip type checks in`call_indirect` for tables that don't require it. With thefunction-references proposal it's possible to have tables of a singletype of function as opposed to today's default `funcref` which is aheterogenous set of functions. In this situation it's possible that a`call_indirect`'s type tag matches the type tag of a`table`-of-typed-`funcref`-values, meaning that it's impossible for thetype check to fail.The type check of a function pointer in `call_indirect` is refactoredhere to take the table's type into account. Various things are shuffledaround to ensure that the right traps still show up in the right placesbut the important part is that, when possible, the type check is omittedentirely.* Update crates/cranelift/src/func_environ.rsCo-authored-by: Jamey Sharp <[email protected]>---------Co-authored-by: Jamey Sharp <[email protected]>
Function references (#5288)* Make wasmtime-types type check* Make wasmtime-environ type check.* Make wasmtime-runtime type check* Make cranelift-wasm type check* Make wasmtime-cranelift typ
Function references (#5288)* Make wasmtime-types type check* Make wasmtime-environ type check.* Make wasmtime-runtime type check* Make cranelift-wasm type check* Make wasmtime-cranelift type check* Make wasmtime type check* Make wasmtime-wast type check* Make testsuite compile* Address Luna's comments* Restore compatibility with effect-handlers/wasm-tools#func-ref-2* Add function refs feature flag; support testing* Provide function references support in helpers- Always support Index in blocktypes- Support Index as table type by pretending to be Func- Etc* Implement ref.as_non_null* Add br_on_null* Update Cargo.lock to use wasm-tools with peekThis will ultimately be reverted when we refer towasm-tools#function-references, which doesn't have peek, but does have typeannotations on CallRef* Add call_ref* Support typed function references in ref.null* Implement br_on_non_null* Remove extraneous flag; default func refs false* Use IndirectCallToNull trap code for call_ref* Factor common call_indirect / call_ref into a fn* Remove copypasta clippy attribute / format* Add a some more tests for typed table instructionsThere certainly need to be many more, but this at least catches the bugs fixedin the next commit* Fix missing typed cases for table_grow, table_fill* Document trap code; remove answered question* Mark wasm-tools to wasmtime reftype infallible* Fix reversed conditional* Scope externref/funcref shorthands within WasmRefType* Merge with upstream* Make wasmtime compile again* Fix warnings* Remove Bot from the type algebra* Fix table tests.`wast::Cranelift::spec::function_references::table``wast::Cranelift::spec::function_references::table_pooling`* Fix table{get,set} tests.```wast::Cranelift::misc::function_references::table_getwast::Cranelift::misc::function_references::table_get_poolingwast::Cranelift::misc::function_references::table_setwast::Cranelift::misc::function_references::table_set_pooling```* Insert subtype check to fix local_get tests.```wast::Cranelift::spec::function_references::local_getwast::Cranelift::spec::function_references::local_get_pooling```* Fix compilation of `br_on_non_null`.The branch destinations were the other way round... :-)Fixes the following test failures:```wast::Cranelift::spec::function_references::br_on_non_nullwast::Cranelift::spec::function_references::br_on_non_null_pooling```* Fix ref_as_non_null tests.The test was failing due to the wrong error message being printed. Asper upstream folks' suggest we were using the trap code`IndirectCallToNull`, but it produces an unexpected error message.This commit reinstates the `NullReference` trap code. It produces theexpected error message. We will have to chat with the maintainersupstream about how to handle these "test failures".Fixes the following test failures:```wast::Cranelift::spec::function_references::ref_as_non_nullwast::Cranelift::spec::function_references::ref_as_non_null_pooling```* Fix a call_ref regression.* Fix global tests.Extend `is_matching_assert_invalid_error_message` to circumvent the textual error message failure.Fixes the following test failures:```wast::Cranelift::spec::function_references::globalwast::Cranelift::spec::function_references::global_pooling```* Cargo update* Update* Spell out some cases in match_val* Disgusting hack to subvert limitations of type reconstruction.In the function `wasmtime::values::Val::ty()` attempts to reconstructthe type of its underlying value purely based on the shape of thevalue. With function references proposal this sort of reconstructionis no longer complete as a source reference type may have beennullable. Nullability is not inferrable by looking at the shape of theruntime object alone.Consequently, the runtime cannot reconstruct the type for`Val::FuncRef` and `Val::ExternRef` by looking at their respectiveshapes.* Address workflows comments.* null reference => null_reference for CLIF parsing compliance.* Delete duplicate-loads-dynamic-memory-egraph (again)* Idiomatic code change.* Nullability subtyping + fix non-null storage check.This commit removes the `hacky_eq` check in `func.rs`. Instead it isreplaced by a subtype check. This subtype check occurs in`externals.rs` too.This commit also fixes a bug. Previously, it was possible to store anull reference into a non-null table cell. I have added to new testcases for this bug: one for funcrefs and another for externrefs.* Trigger unimplemented for typed function references. Format values.rs* run cargo fmt* Explicitly match on HeapType::Extern.* Address cranelift-related feedback* Remove PartialEq,Eq from ValType, RefType, HeapType.* Pin wasmparser to a fairly recent commit.* Run cargo fmt* Ignore tail call tests.* Remove garbage* Revert changes to wasmtime public API.* Run cargo fmt* Get more CI passing (#19)* Undo Cargo.lock changes * Fix build of cranelift tests* Implement link-time matches relation. Disable tests failing due to lack of public API support.* Run cargo fmt* Run cargo fmt* Initial implementation of eager table initialization* Tidy up eager table initialisation* Cargo fmt* Ignore type-equivalence test* Replace TODOs with descriptive comments.* Various changes found during review (#21)* Clarify a comment This isn't only used for null references * Resolve a TODO in local init Don't initialize non-nullable locals to null, instead skip initialization entirely and wasm validation will ensure it's always initialized in the scope where it's used. * Clarify a comment and skipping the null check. * Remove a stray comment * Change representation of `WasmHeapType` Use a `SignatureIndex` instead of a `u32` which while not 100% correct should be more correct. This additionally renames the `Index` variant to `TypedFunc` to leave space for future types which aren't functions to not all go into an `Index` variant. This required updates to Winch because `wasmtime_environ` types can no longer be converted back to their `wasmparser` equivalents. Additionally this means that all type translation needs to go through some form of context to resolve indices which is now encapsulated in a `TypeConvert` trait implemented in various locations. * Refactor table initialization Reduce some duplication and simplify some data structures to have a more direct form of table initialization and a bit more graceful handling of element-initialized tables. Additionally element-initialize tables are now treated the same as if there's a large element segment initializing them. * Clean up some unrelated chagnes * Simplify Table bindings slightly * Remove a no-longer-needed TODO * Add a FIXME for `SignatureIndex` in `WasmHeapType` * Add a FIXME for panicking on exposing function-references types * Fix a warning on nightly * Fix tests for winch and cranelift* Cargo fmt* Fix arity mismatch in aarch64/abi---------Co-authored-by: Daniel Hillerström <[email protected]>Co-authored-by: Daniel Hillerström <[email protected]>Co-authored-by: Alex Crichton <[email protected]>