summaryrefslogtreecommitdiff
path: root/src/interp/binary-reader-interp.cc
Commit message (Collapse)AuthorAgeFilesLines
* wasm-interp: Fix catch handlers correctly (#2483)Soni L.2024-10-071-13/+19
| | | local decl count != local count
* wasm-interp: Fix catch handlers' value stack sizes (#2478)Soni L.2024-10-011-8/+14
| | | | | | | | | | | | | | | | | Fixes the value stack size of the catch handler. There were two (related) issues here: - The previous code used `func_->locals.size()` as soon as the function was available, but it hadn't processed the function's locals yet, so it was always empty. (This might not matter in practice, as it's only used by the "function-wide catch handler", which just rethrows.) - The previous code didn't take the function's locals into account when computing the value stack height (relative to the function frame) for a try-catch block. So, it would drop the locals when catching an exception. Closes #2476 (Split from #2470 )
* Update testsuite and implement table64 (#2418)Sam Clegg2024-05-151-9/+19
| | | | | See https://github.com/WebAssembly/memory64/issues/51 Includes workaround for #2422
* Flip order of memory indexes on memory.copy (#2294)Keith Winstein2023-09-111-5/+5
| | | | Reflects change in the multi-memory proposal: https://github.com/WebAssembly/multi-memory/pull/29
* Share reading/validation code between elem exprs & other const exprs (#2288)Keith Winstein2023-09-061-15/+10
| | | | | | This continues the work from #1783 and reduces special handling of elem exprs, by treating them the same as other const expressions (init expressions).
* memory64: when enabled, check offset range at validation-time (#2253)Keith Winstein2023-06-121-16/+16
| | | | | | | | | | | | | | | | * memory64: when enabled, offset range check is at validation-time Before memory64, the "offset" in a load/store expression was a u32, and we enforced this in the WastParser and BinaryReader. After memory64, the "offset" becomes a u64 syntactically, and the validator checks that it's <= UINT32_MAX for i32 memories. We hadn't been correctly allowing these very large offsets in the text format (even when memory64 was enabled and the memory was i64). (This change also eliminates the "memories" member in the BinaryReader. The BinaryReader no longer needs to keep track of the memories and their types to check well-formedness.)
* Update testsuite (#2054)Sam Clegg2022-11-131-2/+1
| | | | | | | | | | | | | | | As well as the testsuite update there are two notable changes that come with it here. These can both be split out an landed first if it makes sense. 1. wasm2c now supports element sections containing externref. Currently only the null reference is supported. 2. element segments no longer use funcref as the default element type but instead, unless explicitly included in the binary, the element type defaults to the type of the table in which the segment is active. Fixes: #1612 #2022
* Move headers to include/wabt/ (#1998)Alex Reinking2022-09-281-6/+6
| | | This makes things easier for users and packagers of libwabt.
* Fix several issues found by fuzzing (#1931)20192022-09-171-0/+7
| | | | | Fixes #1922, fixes #1924, fixes #1929 Co-authored-by: Keith Winstein <keithw@cs.stanford.edu>
* Support multi-memory in all memory ops and in apply/resolve-names (#1962)Keith Winstein2022-08-151-19/+44
|
* Track locations of Vars in BinaryReaderIR and BinaryReaderInterp (#1963)Keith Winstein2022-08-151-52/+86
| | | | - Rebase test output to match new location tracking on Vars - Eliminate single-argument Var() constructor.
* Initial implementation of extended-const proposal. (#1824)Sam Clegg2022-02-151-80/+29
| | | | | | | | | | The primary changes here are to the interpreter and how it handles initializer expressions. With this change we model these are normal function that we run during module initialization. I imagine we could optimize this further by creating one long function and encoding the `global.set`/`memory.init`/`table.init` into the function itself, but this change seems like a good first step to make the current tests pass.
* Use C++17 string_view (#1826)Sam Clegg2022-02-111-32/+32
| | | | | Now that we have C++17 we don't need our own string_view class anymore. Depends on #1825
* Update testsuite (#1795)Sam Clegg2022-01-101-2/+6
| | | | Remove test/binary/bad-function-missing-end.txt which is now covered upstream: https://github.com/WebAssembly/spec/pull/1405
* Clang-format codebase (#1684)Heejin Ahn2021-12-201-3/+3
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This applies clang-format to the whole codebase. I noticed we have .clang-format in wabt but the codebase is not very well formatted. This kind of mass-formatting PR has fans and skeptics because it can mess with `git blame`, but we did a similar thing in Binaryen a few years ago (WebAssembly/binaryen#2048, which was merged in WebAssembly/binaryen#2059) and it was not very confusing after all. If we are ever going to format the codebase, I think it is easier to do it in a single big PR than dozens of smaller PRs. This is using the existing .clang-format file in this repo, which follows the style of Chromium. If we think this does not suit the current formatting style, we can potentially tweak .clang-format too. For example, I noticed the current codebase puts many `case` statements within a single line when they are short, but the current .clang-format does not allow that. This does not include files in src/prebuilt, because they are generated. This also manually fixes some comment lines, because mechanically applying clang-format to long inline comments can look weird. I also added a clang-format check hook in the Github CI in #1683, which I think can be less controversial, given that it only checks the diff. --- After discussions, we ended up reverting many changes, especially one-liner functions and switch-cases, which are too many to wrap in `// clang-format off` and `// clang-format on`. I also considered fixing `.clang-format` to allow those one-liners but it caused a larger churn in other parts. So currently the codebase does not conform to `.clang-format` 100%, but we decided it's fine.
* interpreter: Fix infinite looping on `return_call` (#1762)Asumu Takikawa2021-12-151-2/+5
| | | | | | | | | The code offset fixup for the target of a `return_call` was not being done properly due to invalid initialization of the offset value, and due to the fixup location being put at the wrong offset in the instruction stream. Fixes issue #1761
* Remove check from binary-reader-interp.cc that the validator already ↵Sam Clegg2021-12-131-18/+0
| | | | | | | | | | catches. NFC (#1784) If you leave stuff on the stack at the end of an initializer expression use the same mechanims to report the error as we do for functions etc. In addition, improve such errors so its more obvious what is going on.
* Share validation code between constant expressions and function bodies. NFC ↵Sam Clegg2021-12-101-107/+12
| | | | | | | | | | | | (#1783) Previously we has special cases for initializer expressions (constant expressions). This change paves the way for adding support for extended constant expressions that support a wider range of instructions. This change removes twice as many lines as it adds which shows that this simplification is probably worthwhile even without the pending extensions.
* Add error locations to BinaryReaderInterp (#1780)Sam Clegg2021-12-091-127/+155
| | | | I think it was always intended to work this way but was left as a TODO.
* Remove unused checks from #1770. NFC (#1772)Sam Clegg2021-12-041-10/+0
| | | | In #1770 I introduced these (duplicate) checks but it turns out neither were necessary in the final version of the patch.
* Perform init expression validation outside of the binary reader. NFC (#1770)Sam Clegg2021-12-021-62/+120
| | | | | | | | | | | | | | | | Rather than spocial casing them in the reader we now use the same instruction callbacks for instruction that appear in init expressions as instructions that appear in normal functions. The result of this change is the validation of init expressions is pushed further up the stack. For example, objdump will now quite happily dump modules that use arbitrary instructions in thier init expressions even though they are not valid. To me, this makes sense since objdump does not do instruction validation elsewhere. The change is pre-cursor to allowing a wider variety of instruction to be present in init expressions. See https://github.com/WebAssembly/extended-const
* OnRefFuncExpr takes a func index. NFC (#1768)Sam Clegg2021-12-021-3/+3
| | | | | | | | | | | | | | | | | | | | | | | | | | | | The name of this argument was recently changed from func_index to type_index, but I think that might have been incorrect. The immediate that read in the binary reader is (IIRC) a function index: ``` case Opcode::RefFunc: { Index func; CHECK_RESULT(ReadIndex(&func, "func index")); CALLBACK(OnRefFuncExpr, func); CALLBACK(OnOpcodeUint32, func); break; } ``` and not a type index. Indeed the interpreter seems to treat it as a function index too: ``` Result BinaryReaderInterp::OnRefFuncExpr(Index func_index) { CHECK_RESULT(validator_.OnRefFunc(loc, Var(func_index))); istream_.Emit(Opcode::RefFunc, func_index); return Result::Ok; } ```
* Add multi-memory feature support (#1751)Yuhan Deng2021-11-301-25/+31
|
* Add interpreter support for the exception handling proposal (#1749)Asumu Takikawa2021-11-171-22/+233
| | | | | | | | | | | | | | | | | | | | | Details about the implementation approach: * Try blocks generate metadata tracking the instruction ranges for the handlers and which exception tags are handled (or if a `catch_all` is present). The metadata is stored in a function's `FuncDesc`, and is transferred into the `Frame` when a function call is executed. * The stack is unwound when a `throw` is executed. This unwinding also handles tag dispatch to the appropriate catch. The metadata to find the matching handler is looked up in the call `Frame` stack. * If a `try-delegate` is present, it is used in the stack unwinding process to skip over to the relevant handler. * A separate `exceptions_` stack in call frames tracks caught exceptions that can be accessed via a `rethrow`. The stack is popped on exit from a try block or when exiting via control instructions like `br`. * Because stack unwinding relies on finding metadata in the call frame, `return_call` needs to be modified slightly to adjust the current frame when executing the call, rather than re-using the frame completely as-is.
* Support function references in parameters and results of functions and ↵Dmitry Bezhetskov2021-11-161-5/+5
| | | | blocks. (#1695)
* Remove separate OnEndFunc vs OnEndExpr. (#1756)Sam Clegg2021-11-051-0/+3
| | | | We already have EndFunctionBody, and this extra distinction doesn't seem like it is needed.
* [EH] Replace event with tag (#1678)Heejin Ahn2021-06-221-2/+2
| | | | | | | | | | | We recently decided to change 'event' to 'tag', and 'event section' to 'tag section', out of the rationale that the section contains a generalized tag that references a type, which may be used for something other than exceptions, and the name 'event' can be confusing in the web context. See - https://github.com/WebAssembly/exception-handling/issues/159#issuecomment-857910130 - https://github.com/WebAssembly/exception-handling/pull/161
* Memory64: support 64-bit data init-expr (#1656)Wouter van Oortmerssen2021-04-051-0/+4
|
* [simd] Implement store lane (#1647)Ng Zhi An2021-03-221-0/+14
|
* [simd] Implement load lane (#1646)Ng Zhi An2021-03-221-4/+17
| | | | | | | | | This is a new kind of ir/ast node/instruction. It has 3 immediates: memarg align, memarg offset, and lane index. This required new visitor functions in all the places. Drive-by cleanup to share the simd lane parsing logic between shuffle, lane op and this new load lane instructions. This requires rebasing some tests because the error messages are slightly different now.
* [simd] Implement v128.load{32,64}_zero (#1644)Ng Zhi An2021-03-171-0/+11
| | | | This requires a new ir type, and the relevant implementation of virtual mthods in the various visitors.
* Select instr. with multiple results is invalid (#1582)Ben Smith2020-12-031-3/+4
| | | | | | The reference-types proposal adds a select instruction with a type vector, but any number greater than 1 is invalid. Fixes #1577.
* Added initial "memory64" proposal support (#1500)Wouter van Oortmerssen2020-08-071-19/+19
|
* Remove ref.is_null type parameter (#1474)Ben Smith2020-07-151-3/+3
| | | | | | | | | See https://github.com/WebAssembly/reference-types/issues/99. This change also updates the testsuite, so the spec tests pass too. In addition, the behavior of `br_table` is no longer different from MVP, and has a text to confirm this. That is now fixed in `type-checker.cc` too.
* Reference types changes to remove subtyping (#1407)Ben Smith2020-05-281-12/+14
| | | | | | | | Main changes: * Rename `anyref` -> `externref` * Remove `nullref` * Rename `hostref` -> `externref` * `ref.null` and `ref.is_null` now have "ref kind" parameter * Add ref kind keywords: `func`, `extern`, `exn`
* Add support for atomic.fence from the threads proposal (#1231)Andy Wingo2020-04-201-0/+7
| | | | | See https://github.com/WebAssembly/threads/pull/141 for the binary encoding. This patch does add a field to AtomicFenceExpr for the consistency model, though without a type for the time being.
* Initial pass parsing/reading struct (#1352)Ben Smith2020-03-091-12/+12
| | | | | | | | | | | | | | | | | | This parses just the format `(struct)` as a new type. I added a test for this using `wat2wasm`, but that requires a rudimentary binary format. The test runner automatically attempts to rountrip all wat2wasm tests, so this required implementing the wat writing and binary reading too. Here's a summary of the changes: * binary-reader:h: Rename `BinaryReader::OnType` callbacks to `OnFuncType` * binary-reader.h: Add `BinaryReader::OnStructType` * binary-reader.cc: Use a switch after reading the type form to determine whether we're reading a function or struct. * tokens.def: Add new `TokenType::Struct` * lexer-keywords.txt: Add new `struct` keyword * type.h: Add `Type::Struct` type form * wast-parser.cc: Parse `(struct)` in text format * wat-writer.cc: Write Func or Struct type forms
* [NFC] Fix a few TODOsBen Smith2020-02-291-481/+465
| | | | | * Remove wabt:: prefix from binary-reader-interp * Rename InterpCallHost -> InterpCallImport
* Update testsuite (w/ reference-types changes) (#1351)Ben Smith2020-02-281-6/+13
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The new table-sub test, checks whether the subtyping is handled properly w/ table.init and table.copy instructions. The BeginElemSegment callback can't pass the element type anymore, since it's not known yet. The callback also can't be deferred, since the BeginElemSegmentInitExpr callback has to happen after the BeginElemSegment callback, but the reference type is not always known until after the initializer expression is read. To work around this, I added a new OnElemSegmentElemType callback. Other element segment changes: * The element type must be tracked in the SharedValidator * A subtle fix: when writing out the segment flags, we need to take into account whether the element type of the segment is not funcref, even if there are no element expressions. In that case, we have to use flag bit 0x4 (SegUseElemExprs). In addition, the TableCopy and TableInit instructions weren't handling table indexes fully. * TableCopy variables are read in the parser (both optional) * TableCopy names are now resolved + applied * TableCopy indexes are now validated * TableInit table variables are read in the parser; this is subtle, since the text format has order $table $segment, but the $table is optional.
* Share validator between IR + binary-reader-interp (#1346)Ben Smith2020-02-271-373/+198
| | | | | | | | | | | | | | | | | | | | | | | | | | | The TypeChecker was already shared, but the rest of the other validation logic was duplicated. This change creates a SharedValidator which is used by both the Validator and the BinaryReaderInterp classes. The validator is structured similarly to TypeChecker as a collection of functions. It's assumed that the functions will be called in the same order as sections occur in the binary format. The IR valiator does this too, even though it's possible to validate components out-of-order in that case. This change also splits Module validation and Script validation into two different classes. It should have been written this way in the first place, and it's nice to do as part of this change since the module validator logic is mostly moved into the SharedValidator anyway. Next steps: * Remove all validation from BinaryReader and move it into the SharedValidator. * Move the TypeChecker into the SharedValidator (maybe not necessary) * Ensure that validation occurs before creating IR from binary (use SharedValidator in BinaryReaderIR? or maybe create BinaryReaderValidator passthru that both BinaryReaderIR and BinaryReaderInterp use?) * Rename Validator -> IRValidator, SharedValidator -> Validator
* New interpreter (#1330)Ben Smith2020-02-211-937/+464
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | It's modeled closely on the wasm-c-api. All runtime objects are garbage-collected. The GC'd objects are subclasses of `Object` and all stored in the `Store`. GC roots can be created using a RefPtr<T> struct. The `Module` stores no runtime objects, only description structs (named `*Desc`, e.g. `FuncDesc`). Instantiation takes these descriptors and turns them into runtime objects (e.g. `FuncDesc` is used to create a `Func`). Only import-matching occurs during instantiation; all other validation is assumed to have occurred during Module compilation. As with the previous interpreter, the wasm instructions are not executed directly, and instead compiled to an instruction stream that is easier to interpret (e.g. all branches become gotos). It's still a stack machine, though. The previous interpreter would always compile and instantiate in one step, which means that it was always known whether an imported function is a host function or wasm function. As a result, calls between modules that stayed in wasm could be very cheap (just update PC). Now that the module is compiled before instantiation, an imported function call always has to check first, which may be a slight performance hit. One major difference to the structure of the interpreter is that floating-point values are passed directly, instead of using their equivalent bit pattern. This is more convenient in general, but requires annotating all functions with WABT_VECTORCALL so Visual Studio x86 works properly (otherwise floats are passed in the x87 FP stack). Instruction stream decoding/tracing/disassembling is now all handled in the `Istream` class. This reduces a lot of duplication between the three, which makes the logging-all-opcodes and tracing-all-opcodes less valuable, so I've removed them. Here are the changes to files: binary-reader-metadata.{h,cc} -> [removed] interp-{disassemble.trace}.cc -> istream.{h,cc} There are new helper files: interp-util.{h,cc}: Primarily print debugging functions interp-math.h: Templates used for handling wasm math
* Update testsuite (#1327)Sam Clegg2020-02-051-5/+41
| | | | | The main change here is the addition of declared elem sections.
* Initial WASM C API implementation. (#1250)Sam Clegg2020-01-161-43/+59
| | | | All tests except `threads` pass.
* Update testsuite (#1275)Sam Clegg2020-01-091-11/+5
| | | | | | | | | | | | | | | | | The two primary changes involved are: 1. Removal of `assert_return_canonical_nan`/`arithetic nan` in favor of special `nan:canonical`/`nan:arithmetic` constants that can only be used in test expectations. See: https://github.com/WebAssembly/spec/pull/1104 2. New trapping behaviour for bulk memory operations. Range checks are now performed up front for opterations such as memory.fill and memory.copy. See: https://github.com/webassembly/bulk-memory-operations/issues/111 And: https://github.com/webassembly/bulk-memory-operations/pull/123 The old behaviour is still kept around to support table.fill which is defined in reference-types proposal and has yet to be updated.
* reference-types: add final test: br_table (#1264)Sam Clegg2019-12-131-0/+1
| | | | | | | | | | | | | | This requires some slightly different validation rules for MVP vs interface-types. There is a test in unreachable-invalid.wast that was removed in the reference-types repo: type-br_table-label-num-vs-label-num-after-unreachable This test depends on the old validation rules and still exists in the master testsuite so we need to continue to support both sets of rules for now.
* reference-types: add support for typed select (#1253)Sam Clegg2019-11-261-3/+3
|
* reference-types: add table.fill instruction (#1252)Sam Clegg2019-11-251-0/+9
|
* reference-types: Add reference-types spec tests (#1225)Sam Clegg2019-11-251-13/+64
| | | | | | | This change adds most of the tests from the reference-types proposal. There are two tests that require new instructions (`table.fill` and `select_t`) which will be followup changes. See: #1223
* Update spec testsuite (#1237)Sam Clegg2019-11-221-106/+14
| | | | | | | The only major change to the interpreter is to move segment initialization out `ReadBinaryInterp` (in the binary reader) and into interp.cc. This is because the test suite now expects out of bound semgments to be reported during initialization rather than reported as validation errors.
* Switch to treating segment flags as a bitfield. NFC (#1232)Sam Clegg2019-11-181-12/+12
| | | | | | | | | | | This is in preparation for updating to latest version reference-types proposal where there is an additional flag and they can be combined. See: https://github.com/WebAssembly/bulk-memory-operations/issues/98 Also, add ERROR_IF to binary-reader.cc as logical corollary to the existing ERROR_UNLESS.
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-06 08:04:09 +0000