issue_owner_repo
listlengths 2
2
| issue_body
stringlengths 0
261k
⌀ | issue_title
stringlengths 1
925
| issue_comments_url
stringlengths 56
81
| issue_comments_count
int64 0
2.5k
| issue_created_at
stringlengths 20
20
| issue_updated_at
stringlengths 20
20
| issue_html_url
stringlengths 37
62
| issue_github_id
int64 387k
2.46B
| issue_number
int64 1
127k
|
|---|---|---|---|---|---|---|---|---|---|
[
"WebAssembly",
"wabt"
] |
The following code fails to compile by wat2wasm (v1.12) if relocatable binary (-r) is requested.
Is it expected? (exit code 0xC0000005)
Non-relocatable binary compiles just fine.
```
(module
;; (type (func (param i32)(param i32)(result i32))) ;; fails, even if present
(func $add (param i32)(param i32)(result i32)
get_local 0
get_local 1
i32.add
return
)
(table 1 anyfunc)
(elem (i32.const 0) $add)
(func $run
i32.const 4444
i32.const 5555
i32.const 0
;;call_indirect (type 0) ;; fails
call_indirect (param i32)(param i32)(result i32) ;; fails
drop
)
(export "run" (func $run))
)
```
|
wat2wasm fails with call_indirect and relocation
|
https://api.github.com/repos/WebAssembly/wabt/issues/1199/comments
| 29 |
2019-10-24T15:42:30Z
|
2023-03-15T05:59:45Z
|
https://github.com/WebAssembly/wabt/issues/1199
| 512,028,558 | 1,199 |
[
"WebAssembly",
"wabt"
] |
Hi, I'm new to WASM.
I've installed emscripten using the [installation instructions](https://emscripten.org/docs/getting_started/downloads.html) and tried it out on a simple program:
```
#include <cstdlib>
#include <cstring>
char *
malloc_demo()
{
char *p = (char *)malloc(20);
strcpy(p, "Hello, World\n");
return p;
}
```
this is with
```
$ emcc -v
emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 1.39.0
clang version 10.0.0 (/b/s/w/ir/cache/git/chromium.googlesource.com-external-github.com-llvm-llvm--project e44524736c4a97ae4fb37193e58647f838f6d36a)
```
when I run wabt on it (the current build), I see:
```
$ wasm2wat malloc.wasm
000009d: error: invalid section code: 12
```
I googled the [specification](https://webassembly.github.io/spec/core/bikeshed/index.html#sections%E2%91%A0) - indeed, section numbers don't extend past 11.
However, I also found an issue in the [LLVM Phabricator](https://reviews.llvm.org/D60623) that introduced a `DataCount` section, which tools such as binaryen [apparently support](https://github.com/WebAssembly/binaryen/blob/master/src/wasm/wasm-binary.cpp#L859).
The Phabricator issue notes that:
_Engines that don't support bulk memory operations will not recognize the DataCount section and will report validation errors, but that's ok because object files aren't supposed to be run directly anyway._
I suppose my confusion is why I tapped into something that's apparently in development. Does wabt tracked 'tagged releases' of emscripten? Should wabt be able to convert files containing such "linking sections" to the .wat format, and this particular feature just has not been implemented? Or am I mistaken in the idea to be able to convert files written by emscripten using wabt?
Thank you.
|
[wasm2wat] Nicer error for known but disabled feature
|
https://api.github.com/repos/WebAssembly/wabt/issues/1197/comments
| 2 |
2019-10-24T00:46:23Z
|
2020-03-20T20:26:37Z
|
https://github.com/WebAssembly/wabt/issues/1197
| 511,642,127 | 1,197 |
[
"WebAssembly",
"wabt"
] |
When I ask `wat2wasm` (pulled about 4 days ago from master and built under windows) to compile the following:
`(data (i32.const 6) "Hello")`
I get a nice, well specified data segment which has a count of 1, an index of 0, and an `init_expr` with my `i32.const 6)` instruction followed by `end` (0xb) followed by a count and 6 bytes of data for my string.
However, when I write:
`(data "Hello")`
I get a count of 1, followed by an index of 1, and then a count of 6 and my data- there is no `init_expr`.
I am struggling to see where the specification defines the latter behaviour. My disassembler currently botches this by treating memory indices that are not 0 (which are not defined in MVP) as not containing an init-expr, and assume that the data segment will be loaded at 0x0000 but this format seems undefined, and I am not happy guessing what to do here.
The [spec](https://webassembly.github.io/spec/core/binary/modules.html#data-section) seems to assume i will always have an expression, yet clearly I do not when I elide this from my data definition.
Personally I would have expected `wat2wasm` to have inserted "`(i32.const 0) (end)`" where the specification _appears to require_ an `init_expr` in the case I do not provide a const instruction myself, but I am still working through the spec so perhaps I am confused.
Certainly `wasm2wat` happily disassembles this module, and even more importantly, this module loads with no issues on all wasm platforms I have tried.
Can someone help clarify this behaviour?
|
Clarification of data segment compilation in wat2wasm
|
https://api.github.com/repos/WebAssembly/wabt/issues/1194/comments
| 1 |
2019-10-20T21:17:32Z
|
2020-03-11T17:31:39Z
|
https://github.com/WebAssembly/wabt/issues/1194
| 509,654,069 | 1,194 |
[
"WebAssembly",
"wabt"
] |
Currently `wat2wasm` will [unconditionally emit the data count section](https://github.com/WebAssembly/wabt/blob/f157909d791ea8f32248657062e8fdb3ed435eb5/src/binary-writer.cc#L1061-L1065) if the bulk memory feature is enabled, but I was wondering if a better heuristic might be to omit the section unless there are instructions that require the data count section? Otherwise as bulk memory gets enabled by default wabt will switch to by default producing non-MVP compatible wasm modules, and it could take some time for all runtimes/consumers/etc to update to the post-MVP world.
|
Omitting the data count section to remain MVP-compatible?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1189/comments
| 10 |
2019-10-15T22:34:41Z
|
2020-01-21T19:30:49Z
|
https://github.com/WebAssembly/wabt/issues/1189
| 507,516,550 | 1,189 |
[
"WebAssembly",
"wabt"
] |
Given a wat file like:
```wat
(module
(func (param i32))
(table anyfunc (elem 0))
(table anyfunc (elem 0)))
```
when encoded this yields:
```
$ wat2wasm --enable-reference-types foo.wat -o foo.wasm
$ wasm-objdump -x foo.wasm [alex@alex-HP-Z4-G4-Workstation]
foo.wasm: file format wasm 0x1
Section Details:
Type[1]:
- type[0] (i32) -> nil
Function[1]:
- func[0] sig=0
Table[2]:
- table[0] type=funcref initial=1 max=1
- table[1] type=funcref initial=1 max=1
Elem[2]:
- segment[0] table=0 count=1 - init i32=0
- elem[0] = func[0]
- segment[1] table=0 count=1 - init i32=0
- elem[0] = func[0]
Code[1]:
- func[0] size=2
```
Here `segment[1]` is listed as belonging to `table=0`, but I think that segment should belong to `table=1`?
|
Expansion of inline elements is incorrect with multi-table
|
https://api.github.com/repos/WebAssembly/wabt/issues/1188/comments
| 2 |
2019-10-15T22:26:56Z
|
2019-10-17T14:21:16Z
|
https://github.com/WebAssembly/wabt/issues/1188
| 507,513,974 | 1,188 |
[
"WebAssembly",
"wabt"
] |
I've been playing around with a custom wat parser and was using wabt as a reference test suite, and I think I came across some curious behavior!
The `tests/wabt/test/parse/expr/bulk-memory-named.txt` test ends up encoding differently on Linux and macOS. I think the Linux encoding is correct, and on macOS I've reduced the test case and am seeing:
```wat
(module
(table 1 anyfunc)
(elem $elem funcref (ref.func 0))
(elem $elem funcref 0)
(func
i32.const 0 i32.const 0 i32.const 0 table.init $elem
)
)
```
```
$ wat2wasm foo.wat -o foo.wasm --enable-bulk-memory
$ wasm-objdump foo.wasm -d | grep table.init
000035: fc 0c 00 00 | table.init 0 0
```
whereas on linux that prints:
```
$ wat2wasm foo.wat -o foo.wasm --enable-bulk-memory
$ wasm-objdump foo.wasm -d | grep table.init
000035: fc 0c 01 00 | table.init 1 0
```
I think the test is a bit odd, but it looks like the second `$elem` is shadowing the first, but that seems to only work on Linux whereas on macOS the shadowing isn't working?
|
Shadowing elem segment names encodes incorrectly on macOS
|
https://api.github.com/repos/WebAssembly/wabt/issues/1187/comments
| 3 |
2019-10-15T21:29:02Z
|
2019-10-21T16:20:12Z
|
https://github.com/WebAssembly/wabt/issues/1187
| 507,492,761 | 1,187 |
[
"WebAssembly",
"wabt"
] |
Please increase the timeout in [`test/run-tests.py:39`](https://github.com/WebAssembly/wabt/blob/master/test/run-tests.py#L39). `test/wasm2c/spec/const.txt` and `test/wasm2c/spec/float_exprs.txt` tests take more than 20 seconds to complete on ARMv7 (32bit).
|
tests time out on ARMv7 (32bit)
|
https://api.github.com/repos/WebAssembly/wabt/issues/1183/comments
| 2 |
2019-10-09T11:23:53Z
|
2024-07-26T10:23:08Z
|
https://github.com/WebAssembly/wabt/issues/1183
| 504,586,165 | 1,183 |
[
"WebAssembly",
"wabt"
] |
In 1.0.12, after removing test/regress/regress-30.txt to work around #1180 , 73 tests fail with this traceback:
```
- test/wasm2c/spec/address.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,12 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.12/test/run-spec-wasm2c.py", line 418, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.12/test/run-spec-wasm2c.py", line 383, in main
+ cwriter.Write()
+ File "/builddir/build/BUILD/wabt-1.0.12/test/run-spec-wasm2c.py", line 127, in Write
+ self._CacheModulePrefixes()
+ File "/builddir/build/BUILD/wabt-1.0.12/test/run-spec-wasm2c.py", line 150, in _CacheModulePrefixes
+ name = MangleName(name)
+ File "/builddir/build/BUILD/wabt-1.0.12/test/run-spec-wasm2c.py", line 101, in MangleName
+ if c in '_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXY0123456789':
+TypeError: 'in <string>' requires string as left operand, not int
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +0,0 @@
-238/238 tests passed.
```
Failing tests:
```
- test/wasm2c/spec/address.txt
- test/wasm2c/spec/align.txt
- test/wasm2c/spec/binary.txt
- test/wasm2c/spec/block.txt
- test/wasm2c/spec/br.txt
- test/wasm2c/spec/br_if.txt
- test/wasm2c/spec/br_table.txt
- test/wasm2c/spec/break-drop.txt
- test/wasm2c/spec/call.txt
- test/wasm2c/spec/call_indirect.txt
- test/wasm2c/spec/comments.txt
- test/wasm2c/spec/const.txt
- test/wasm2c/spec/conversions.txt
- test/wasm2c/spec/custom.txt
- test/wasm2c/spec/data.txt
- test/wasm2c/spec/elem.txt
- test/wasm2c/spec/endianness.txt
- test/wasm2c/spec/exports.txt
- test/wasm2c/spec/f32.txt
- test/wasm2c/spec/f32_bitwise.txt
- test/wasm2c/spec/f32_cmp.txt
- test/wasm2c/spec/f64.txt
- test/wasm2c/spec/f64_bitwise.txt
- test/wasm2c/spec/f64_cmp.txt
- test/wasm2c/spec/fac.txt
- test/wasm2c/spec/float_exprs.txt
- test/wasm2c/spec/float_literals.txt
- test/wasm2c/spec/float_memory.txt
- test/wasm2c/spec/float_misc.txt
- test/wasm2c/spec/forward.txt
- test/wasm2c/spec/func.txt
- test/wasm2c/spec/func_ptrs.txt
- test/wasm2c/spec/globals.txt
- test/wasm2c/spec/i32.txt
- test/wasm2c/spec/i64.txt
- test/wasm2c/spec/if.txt
- test/wasm2c/spec/imports.txt
- test/wasm2c/spec/inline-module.txt
- test/wasm2c/spec/int_exprs.txt
- test/wasm2c/spec/int_literals.txt
- test/wasm2c/spec/labels.txt
- test/wasm2c/spec/left-to-right.txt
- test/wasm2c/spec/linking.txt
- test/wasm2c/spec/load.txt
- test/wasm2c/spec/local_get.txt
- test/wasm2c/spec/local_set.txt
- test/wasm2c/spec/local_tee.txt
- test/wasm2c/spec/loop.txt
- test/wasm2c/spec/memory.txt
- test/wasm2c/spec/memory_grow.txt
- test/wasm2c/spec/memory_redundancy.txt
- test/wasm2c/spec/memory_size.txt
- test/wasm2c/spec/memory_trap.txt
- test/wasm2c/spec/names.txt
- test/wasm2c/spec/nop.txt
- test/wasm2c/spec/return.txt
- test/wasm2c/spec/select.txt
- test/wasm2c/spec/skip-stack-guard-page.txt
- test/wasm2c/spec/stack.txt
- test/wasm2c/spec/start.txt
- test/wasm2c/spec/store.txt
- test/wasm2c/spec/switch.txt
- test/wasm2c/spec/token.txt
- test/wasm2c/spec/traps.txt
- test/wasm2c/spec/type.txt
- test/wasm2c/spec/typecheck.txt
- test/wasm2c/spec/unreachable.txt
- test/wasm2c/spec/unwind.txt
- test/wasm2c/spec/unreached-invalid.txt
- test/wasm2c/spec/utf8-custom-section-id.txt
- test/wasm2c/spec/utf8-import-field.txt
- test/wasm2c/spec/utf8-import-module.txt
- test/wasm2c/spec/utf8-invalid-encoding.txt
```
|
73 tests fail with TypeError in test/run-spec-wasm2c.py:101
|
https://api.github.com/repos/WebAssembly/wabt/issues/1181/comments
| 4 |
2019-10-04T12:01:41Z
|
2020-01-10T19:39:00Z
|
https://github.com/WebAssembly/wabt/issues/1181
| 502,597,156 | 1,181 |
[
"WebAssembly",
"wabt"
] |
When running the testsuite of 1.0.12, I'm getting this exception when `run_tests.py` is processing `test/regress/regress-30.txt`:
```
$ python3 -V
Python 3.7.4
$ test/run-tests.py --timeout=20
Traceback (most recent call last):
File "test/run-tests.py", line 952, in <module>
sys.exit(main(sys.argv[1:]))
File "test/run-tests.py", line 909, in main
infos = GetAllTestInfo(test_names, status)
File "test/run-tests.py", line 664, in GetAllTestInfo
info.Parse(test_name)
File "test/run-tests.py", line 484, in Parse
for line in f.readlines():
File "/usr/lib64/python3.7/codecs.py", line 322, in decode
(result, consumed) = self._buffer_decode(data, self.errors, final)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 225: invalid start byte
```
|
UnicodeDecodeError when parsing test/regress/regress-30.txt
|
https://api.github.com/repos/WebAssembly/wabt/issues/1180/comments
| 2 |
2019-10-04T11:55:16Z
|
2020-01-09T03:33:41Z
|
https://github.com/WebAssembly/wabt/issues/1180
| 502,594,444 | 1,180 |
[
"WebAssembly",
"wabt"
] |
When a wasm file doesn't have a DataCount section I think validation of memory.init should fail. I have a wasm file that validates in wabt but in v8 reports:
`CompileError: WebAssembly.Module(): Compiling function #5840 failed: invalid data segment index: 2 @+2798285
`
|
spec-interp validation differs from wasm-validate
|
https://api.github.com/repos/WebAssembly/wabt/issues/1176/comments
| 6 |
2019-09-27T16:52:39Z
|
2020-03-11T17:32:48Z
|
https://github.com/WebAssembly/wabt/issues/1176
| 499,547,812 | 1,176 |
[
"WebAssembly",
"wabt"
] |
I see many commits for a tool `wasm-decompile` in the last time. I have try it and the output look very nice. But I can't find any documentation or spec. That my questions:
- Which language/syntax do you want reproduce with the output? This seems me important to see what is a bug and what is the target language.
- What is the use case for the tool? The development is too expensive only for a nice tool.
|
wasm-decompile
|
https://api.github.com/repos/WebAssembly/wabt/issues/1174/comments
| 3 |
2019-09-26T15:38:47Z
|
2020-01-16T17:51:49Z
|
https://github.com/WebAssembly/wabt/issues/1174
| 498,965,891 | 1,174 |
[
"WebAssembly",
"wabt"
] |
circleci has proved very in emscripten and emsdk accross mac, linux and windows.
|
Should we switch from travis + appveyor to circleci
|
https://api.github.com/repos/WebAssembly/wabt/issues/1168/comments
| 7 |
2019-09-25T16:34:22Z
|
2020-05-25T05:15:07Z
|
https://github.com/WebAssembly/wabt/issues/1168
| 498,397,780 | 1,168 |
[
"WebAssembly",
"wabt"
] |
wabt currently knows how to parse some custom sections, such as the linking section which are outside of the core spec.
I'd like to add some amount of validation there but its not clear where best to do this. Presumably not in ReadBinaryIr? Would it make sense to add this to ValidateModule? (disabled with the existing `--ignore-custom-section-errors` option)
|
Adding some validation of custom sections (e.g. linking section)
|
https://api.github.com/repos/WebAssembly/wabt/issues/1166/comments
| 3 |
2019-09-24T22:37:37Z
|
2020-03-20T20:38:23Z
|
https://github.com/WebAssembly/wabt/issues/1166
| 497,957,126 | 1,166 |
[
"WebAssembly",
"wabt"
] |
Are there any plans to create a new release? The last release is 4 months old currently.
I use the latest binary release for running my unit tests on Travis. Today I am missing ref.null which is already fixed in WABT.
|
New Release
|
https://api.github.com/repos/WebAssembly/wabt/issues/1160/comments
| 5 |
2019-09-15T08:11:33Z
|
2019-09-26T15:26:04Z
|
https://github.com/WebAssembly/wabt/issues/1160
| 493,708,822 | 1,160 |
[
"WebAssembly",
"wabt"
] |
https://github.com/WebAssembly/wabt/commit/3e938b7a10cc6738037dce5f18675cc5d267992d#r35063299
|
Incorrect test in commit
|
https://api.github.com/repos/WebAssembly/wabt/issues/1159/comments
| 0 |
2019-09-12T21:20:03Z
|
2019-09-25T21:04:23Z
|
https://github.com/WebAssembly/wabt/issues/1159
| 493,035,281 | 1,159 |
[
"WebAssembly",
"wabt"
] |
See https://github.com/WebAssembly/wasm-c-api
|
Implement the standard wasm C++ API in wabt interpreter
|
https://api.github.com/repos/WebAssembly/wabt/issues/1158/comments
| 3 |
2019-09-12T16:47:27Z
|
2020-06-10T19:14:40Z
|
https://github.com/WebAssembly/wabt/issues/1158
| 492,918,133 | 1,158 |
[
"WebAssembly",
"wabt"
] |
There is inconsistency between [supported features table](https://github.com/WebAssembly/wabt#supported-proposals) and [available options list](https://webassembly.github.io/wabt/doc/wasm-interp.1.html). I suppose that threads and exceptions should be added to the table and `--enable-mutable-globals` should be `--disable-mutable-globals`. I can create PR if someone can confirm that table is out of date.
|
wasm-interp supported features list
|
https://api.github.com/repos/WebAssembly/wabt/issues/1154/comments
| 3 |
2019-09-08T18:55:14Z
|
2019-09-25T20:36:33Z
|
https://github.com/WebAssembly/wabt/issues/1154
| 490,789,898 | 1,154 |
[
"WebAssembly",
"wabt"
] |
### Test Case
```wat
(module
(data passive "hi"))
```
### Steps to Reproduce
```
wat2wasm path/to/test-case.wat --enable-bulk-memory -o output.wasm
```
### Expected Results
A wasm module with a passive data segment is generated.
### Actual Results
```
/path/to/test-case.wat:2:8: error: unexpected token passive, expected ).
(data passive "hi"))
^^^^^^^
```
----------------------------
This test case is reduced from the output of running `wasm-opt -ttf --enable-bulk-memory --emit-text`. I think this is supposed to be valid wat with bulk memory, but if that is actually invalid wat, then I suppose this should be a bug report against `wasm-opt`.
cc @kripken @tlively
|
wat2wasm: "error: unexpected token passive" even with --enable-bulk-memory
|
https://api.github.com/repos/WebAssembly/wabt/issues/1152/comments
| 3 |
2019-09-04T21:53:40Z
|
2019-09-12T15:03:52Z
|
https://github.com/WebAssembly/wabt/issues/1152
| 489,417,989 | 1,152 |
[
"WebAssembly",
"wabt"
] |
I'm writing wat code where I have a long list (192) functions that I'm declaring in a table and an element sections so that I can call them with call_indirect. Like this:
```
(table 192 funcref)
(elem (offset (i32.const 0))
$func1 $func2........ $func192)
```
All those function take three i32 input parameters but the return value can be either none or an i32 value.
I'm having trouble when call_indirect actually calls the functions with an i32 return value and I'm not sure how to mix functions with different signatures in the same (elem...) section. Shall I use (type ) delcaration but then where do I use them ?
Thank you for your help.
|
Function signatures in call_indirect
|
https://api.github.com/repos/WebAssembly/wabt/issues/1150/comments
| 6 |
2019-09-03T14:14:33Z
|
2022-05-19T01:20:54Z
|
https://github.com/WebAssembly/wabt/issues/1150
| 488,632,300 | 1,150 |
[
"WebAssembly",
"wabt"
] |
```
% gmake test
gmake --no-print-directory -C out/clang/Debug/ run-tests
[ 62%] Built target wabt
[ 65%] Built target wast2json
[ 68%] Built target wasm-validate
[ 71%] Built target wasm-interp
[ 74%] Built target wasm-strip
[ 77%] Built target wat-desugar
[ 80%] Built target spectest-interp
[ 83%] Built target wat2wasm
[ 87%] Built target wasm-opcodecnt
[ 92%] Built target wasm2c
[ 96%] Built target wasm-objdump
[100%] Built target wasm2wat
/bin/sh: /home/ben/git-work/wabt/out/clang/Debug/wabt-unittests: not found
gmake[4]: *** [CMakeFiles/run-tests.dir/build.make:67: CMakeFiles/run-tests] Error 127
gmake[3]: *** [CMakeFiles/Makefile2:344: CMakeFiles/run-tests.dir/all] Error 2
gmake[2]: *** [CMakeFiles/Makefile2:351: CMakeFiles/run-tests.dir/rule] Error 2
gmake[1]: *** [Makefile:255: run-tests] Error 2
gmake: *** [Makefile:178: test-clang-debug] Error 2
```
Running ```cd out/clang/Debug/ && gmake wabt-unittests``` fixes it.
This is using 97bd353df98dfea72f1d7d06b4d087b508a4c37a.
|
Build fails on FreeBSD
|
https://api.github.com/repos/WebAssembly/wabt/issues/1149/comments
| 5 |
2019-08-29T10:08:10Z
|
2019-09-25T20:25:32Z
|
https://github.com/WebAssembly/wabt/issues/1149
| 486,864,757 | 1,149 |
[
"WebAssembly",
"wabt"
] |
in "wasm-rt-impl.c":
uint32_t wasm_rt_register_func_type(uint32_t param_count,
uint32_t result_count,
...) {
FuncType func_type;
......
uint32_t idx = g_func_type_count++;
g_func_types = **realloc**(g_func_types, g_func_type_count * sizeof(FuncType));
g_func_types[idx] = func_type;
return idx + 1;
}
call "realloc" fails,it will cause a crash or memleak(Especially on WINDOWS),. I think we should check the return value.
FuncType* new_ptr = **realloc**(g_func_types, g_func_type_count * sizeof(FuncType));
if (new_ptr == NULL)
{
......
}
g_func_types = new_ptr;
|
Realloc is unsuccessful and will cause a crash
|
https://api.github.com/repos/WebAssembly/wabt/issues/1147/comments
| 3 |
2019-08-27T06:52:42Z
|
2023-03-15T06:05:49Z
|
https://github.com/WebAssembly/wabt/issues/1147
| 485,619,599 | 1,147 |
[
"WebAssembly",
"wabt"
] |
in "expr-visitor.cc":
HandleDefaultState use a lot of "case":
Result ExprVisitor::HandleDefaultState(Expr* expr) {
switch (expr->type()) {
case ExprType::AtomicLoad:
CHECK_RESULT(delegate_->OnAtomicLoadExpr(cast<AtomicLoadExpr>(expr)));
break;
case ExprType::AtomicStore:
CHECK_RESULT(delegate_->OnAtomicStoreExpr(cast<AtomicStoreExpr>(expr)));
break;
......
I recommend using std::map + std::functional replace it.EX:
.....
map_.insert(ExprType::AtomicStore,OnAtomicStoreExpr)
......
when using it :
map[abc] (pars)
thanks.
|
use map and function pointer replace "case"
|
https://api.github.com/repos/WebAssembly/wabt/issues/1143/comments
| 5 |
2019-08-14T09:43:55Z
|
2019-08-28T03:17:24Z
|
https://github.com/WebAssembly/wabt/issues/1143
| 480,582,393 | 1,143 |
[
"WebAssembly",
"wabt"
] |
While attempting to test the SIMD `v128.const` instruction, I ran into failures parsing certain wast files. The following commands fail:
```
wget https://raw.githubusercontent.com/WAVM/WAVM/master/Test/spec/simd/simd_const.wast
wast2json --enable-simd simd_const.wast -o simd_const.json
```
The returned errors are:
```
simd_const.wast:19:34: error: unexpected token "340282356779733623858607532500980858880", expected a Float literal (e.g. 42.0).
...v128.const f32x4 340282356779733623858607532500980858880 3402823567797336...
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
simd_const.wast:21:33: error: unexpected token "-340282356779733623858607532500980858880", expected a Float literal (e.g. 42.0).
...v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733...
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
simd_const.wast:175:60: error: unexpected token "+0x4000004000000", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x40000040...
^^^^^^^^^^^^^^^^
simd_const.wast:177:60: error: unexpected token "-0x4000004000000", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x40000040...
^^^^^^^^^^^^^^^^
simd_const.wast:179:60: error: unexpected token "+0x400000c000000", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c0...
^^^^^^^^^^^^^^^^
simd_const.wast:181:60: error: unexpected token "-0x400000c000000", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c0...
^^^^^^^^^^^^^^^^
simd_const.wast:184:60: error: unexpected token "+1125899973951488", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +11258999...
^^^^^^^^^^^^^^^^^
simd_const.wast:186:60: error: unexpected token "-1125899973951488", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -11258999...
^^^^^^^^^^^^^^^^^
simd_const.wast:188:60: error: unexpected token "+1125900108169216", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +11259001...
^^^^^^^^^^^^^^^^^
simd_const.wast:190:60: error: unexpected token "-1125900108169216", expected a Float literal (e.g. 42.0).
...sult v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -11259001...
^^^^^^^^^^^^^^^^^
simd_const.wast:428:65: error: unexpected token "1_000_000", expected a Float literal (e.g. 42.0).
...1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000))
```
In talking to @Honry he mentioned that these are double rounding edge cases introduced by https://github.com/WebAssembly/spec/pull/1025. What would need to change in wabt to support these?
|
wast2json fails on float literals
|
https://api.github.com/repos/WebAssembly/wabt/issues/1139/comments
| 2 |
2019-08-08T16:34:31Z
|
2019-08-12T19:35:01Z
|
https://github.com/WebAssembly/wabt/issues/1139
| 478,576,266 | 1,139 |
[
"WebAssembly",
"wabt"
] |
It seems to cause some confusion because it doesn't, for example, write out a symbols table.
See:
https://stackoverflow.com/questions/57294541/error-linking-wasm-object-files-with-wasm-ld/57367477#57367477
We could improve it but I'm not who this would benefit exactly. Do we have users for such a feature?
|
Improve `wat2wasm --relocatable` support (or remove it completely).
|
https://api.github.com/repos/WebAssembly/wabt/issues/1137/comments
| 7 |
2019-08-06T00:30:45Z
|
2022-05-19T01:50:21Z
|
https://github.com/WebAssembly/wabt/issues/1137
| 477,112,589 | 1,137 |
[
"WebAssembly",
"wabt"
] |
I am not sure it is a bug, here is it:
```scheme
$ cat in.scm
(module
(func $start (result i32)
(i32.const 42)))
$ wat2wasm in.scm -o out.wasm
$ wasm2wat out.wasm -f --generate-names
(module
(type $t0 (func (result i32)))
(func $f0 (type $t0) (result i32)
(i32.const 42)))
```
The `start` function loose its `$start` symbol and get the type information two times: `(type $t0) (result i32)`.
Feel free to close the issue if it is expected behaviour.
|
spurious type in wat2wasm then wasm2wat and loosing `$start`
|
https://api.github.com/repos/WebAssembly/wabt/issues/1135/comments
| 1 |
2019-08-04T13:06:45Z
|
2019-08-05T08:19:31Z
|
https://github.com/WebAssembly/wabt/issues/1135
| 476,551,660 | 1,135 |
[
"WebAssembly",
"wabt"
] |
I was hoping to use `wasm2c` on some WebAssembly modules that use the multi-value extension, but I get
```
wasm2c currently support only default feature flags.
```
I know that you know about this, just opening this issue to track any possible implementation.
|
wasm2c --enable-multi-value
|
https://api.github.com/repos/WebAssembly/wabt/issues/1134/comments
| 8 |
2019-08-02T09:30:59Z
|
2022-04-01T06:56:58Z
|
https://github.com/WebAssembly/wabt/issues/1134
| 476,087,574 | 1,134 |
[
"WebAssembly",
"wabt"
] |
As far as i can see, wat2wasm can only take a single WAT file as input. Are you aware of any tool that would take several wasm file as input (each of them being a module) and assemble them into a single wasm file ?
Or would concatenating all the wat files together before invoking wat2wasm do the trick ?
|
Wat to Asm linker ?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1133/comments
| 8 |
2019-07-30T18:20:33Z
|
2020-09-10T17:21:22Z
|
https://github.com/WebAssembly/wabt/issues/1133
| 474,736,895 | 1,133 |
[
"WebAssembly",
"wabt"
] |
In the JavaScript, you can use the `WebAssembly.instantiate` function to load a WASM file and use the various methods provided by the WASM file. I want to know if there is such a way in C++ that I can use WASM files directly.
|
How to call a native webassembly file in c/c++ source code?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1130/comments
| 5 |
2019-07-25T09:39:21Z
|
2019-09-25T20:23:41Z
|
https://github.com/WebAssembly/wabt/issues/1130
| 472,765,699 | 1,130 |
[
"WebAssembly",
"wabt"
] |
HI all,
I'm currently writing wat code and using wat2wasm to compile wat source code to wasm binary format. I was wondering if there is a way to tell wasm-interp to use the original source names when tracing the execution (--trace option). I initially though the --debug-names option in wat2 wasm would serve that purpose but apparently not.
Is there any way to achieve this ?
Thank you for your help.
Laurent
|
Source names in wasm-interp --trace
|
https://api.github.com/repos/WebAssembly/wabt/issues/1127/comments
| 1 |
2019-07-23T18:58:33Z
|
2022-05-19T01:43:50Z
|
https://github.com/WebAssembly/wabt/issues/1127
| 471,875,188 | 1,127 |
[
"WebAssembly",
"wabt"
] |
I am working on a branch of https://github.com/google/schism that uses reference types. To check that my .wasm is fine, I used wasm2wat from today; however it crashes:
```
wingo@milano:~/src/schism$ ~/src/wabt/out/gcc/Debug/wasm2wat --enable-reference-types schism-stage0.wasm
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted
```
File attached. I'll have a poke at working up a patch.
[schism.zip](https://github.com/WebAssembly/wabt/files/3417609/schism.zip)
|
Crash disassembling file built with reference types
|
https://api.github.com/repos/WebAssembly/wabt/issues/1124/comments
| 3 |
2019-07-22T13:30:39Z
|
2019-07-22T19:00:03Z
|
https://github.com/WebAssembly/wabt/issues/1124
| 471,096,789 | 1,124 |
[
"WebAssembly",
"wabt"
] |
### Vulnerability/issue
A crash takes place at `error-formatter.cc` which is not caught.
### Steps to reproduce the behavior
PoC: [poc.zip](https://github.com/WebAssembly/wabt/files/3409440/poc.zip)
Run: `wat2wasm poc`
Crash:
```
terminate called after throwing an instance of 'std::length_error'
what(): basic_string::_M_replace_aux
Aborted
```
|
Exception handling issue in error-formatter.cc
|
https://api.github.com/repos/WebAssembly/wabt/issues/1120/comments
| 0 |
2019-07-19T04:38:05Z
|
2019-07-19T18:21:48Z
|
https://github.com/WebAssembly/wabt/issues/1120
| 470,133,688 | 1,120 |
[
"WebAssembly",
"wabt"
] |
### Vulnerability/issue
Assertion failed in wabt::WastLexer::IsCharClass()
### Steps to reproduce the behavior
PoC: [poc.zip](https://github.com/WebAssembly/wabt/files/3408735/poc.zip)
Run: ```wat2wasm poc ```
### Crash
```
wat2wasm: wabt/src/wast-lexer.cc:390: static bool wabt::WastLexer::IsCharClass(int, wabt::WastLexer::CharClass): Assertion `c >= -1 && c < 256' failed.
[1] 23771 abort (core dumped)
```
|
Assertion failed in wabt::WastLexer::IsCharClass() in wast-lexer.cc
|
https://api.github.com/repos/WebAssembly/wabt/issues/1117/comments
| 1 |
2019-07-18T23:36:03Z
|
2019-07-19T03:16:37Z
|
https://github.com/WebAssembly/wabt/issues/1117
| 470,045,451 | 1,117 |
[
"WebAssembly",
"wabt"
] |
See https://github.com/WebAssembly/wabt/pull/1111#issuecomment-511921663. It's not clear to me why, but 32-bit MSVC still doesn't produce the right values for two of the tests in `conversions.wast`:
```
(assert_return (invoke "f32.convert_i64_u" (i64.const 0x8000008000000001)) (f32.const 0x1.000002p+63))
(assert_return (invoke "f32.convert_i64_u" (i64.const 0xfffffe8000000001)) (f32.const 0x1.fffffep+63))
```
The Windows 32-bit build is probably not commonly used, so I've disabled it in appveyor, but it would be nice to fix the bug and re-enable if possible.
|
f32.convert_i64_u on MSVC 32-bit
|
https://api.github.com/repos/WebAssembly/wabt/issues/1113/comments
| 1 |
2019-07-16T22:01:15Z
|
2019-07-19T01:08:40Z
|
https://github.com/WebAssembly/wabt/issues/1113
| 468,886,298 | 1,113 |
[
"WebAssembly",
"wabt"
] |
### Environment
| Questions | Answers
|----------------------|--------------------
| Related Binary | wasm-interp
| Commit | commit 41adcbfb106e035f90de93d472c10461bf4f3f9c
### Vulnerability/issue
Assertion failed in wabt::interp::Executor::CopyResults() in interp.cc
### Steps to reproduce the behavior
- Download: [assert_interp_executor.zip](https://github.com/WebAssembly/wabt/files/3381096/assert_interp_executor.zip)
- Run: `wasm-interp --enable-tail-call --run-all-exports assert_interp_executor.wasm`
### Additional Informations
Crash
```
wasm-interp: /XYZ/wabt/src/interp/interp.cc:3593: void wabt::interp::Executor::CopyResults(const wabt::interp::FuncSignature *, TypedValues *): Assertion `expected_results == thread_.NumValues()' failed.
```
Valgrind
```
==23359== Memcheck, a memory error detector
==23359== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==23359== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==23359== Command: ./wasm-interp --enable-tail-call --run-all-exports assert_interp_executor.wasm
==23359==
wasm-interp: /XYZ/wabt/src/interp/interp.cc:3593: void wabt::interp::Executor::CopyResults(const wabt::interp::FuncSignature *, TypedValues *): Assertion `expected_results == thread_.NumValues()' failed.
==23359==
==23359== Process terminating with default action of signal 6 (SIGABRT)
==23359== at 0x57B9E97: raise (raise.c:51)
==23359== by 0x57BB800: abort (abort.c:79)
==23359== by 0x57AB399: __assert_fail_base (assert.c:92)
==23359== by 0x57AB411: __assert_fail (assert.c:101)
==23359== by 0x46B198: wabt::interp::Executor::CopyResults(wabt::interp::FuncSignature const*, std::vector<wabt::interp::TypedValue, std::allocator<wabt::interp::TypedValue> >*) (interp.cc:3593)
==23359== by 0x46AB06: wabt::interp::Executor::RunFunction(unsigned int, std::vector<wabt::interp::TypedValue, std::allocator<wabt::interp::TypedValue> > const&) (interp.cc:3506)
==23359== by 0x46B436: wabt::interp::Executor::RunExport(wabt::interp::Export const*, std::vector<wabt::interp::TypedValue, std::allocator<wabt::interp::TypedValue> > const&) (interp.cc:3535)
==23359== by 0x41D414: RunAllExports (wasm-interp.cc:130)
==23359== by 0x41D414: ReadAndRunModule (wasm-interp.cc:219)
==23359== by 0x41D414: ProgramMain(int, char**) (wasm-interp.cc:235)
==23359== by 0x579CB96: (below main) (libc-start.c:310)
==23359==
==23359== HEAP SUMMARY:
==23359== in use at exit: 787,668 bytes in 21 blocks
==23359== total heap usage: 203 allocs, 182 frees, 880,551 bytes allocated
==23359==
==23359== LEAK SUMMARY:
==23359== definitely lost: 0 bytes in 0 blocks
==23359== indirectly lost: 0 bytes in 0 blocks
==23359== possibly lost: 0 bytes in 0 blocks
==23359== still reachable: 787,668 bytes in 21 blocks
==23359== suppressed: 0 bytes in 0 blocks
==23359== Rerun with --leak-check=full to see details of leaked memory
==23359==
==23359== For counts of detected and suppressed errors, rerun with: -v
==23359== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
```
|
[wasm-interp] Assertion failed in wabt::interp::Executor::CopyResults() in interp.cc
|
https://api.github.com/repos/WebAssembly/wabt/issues/1108/comments
| 1 |
2019-07-11T08:54:38Z
|
2019-07-15T23:26:36Z
|
https://github.com/WebAssembly/wabt/issues/1108
| 466,756,342 | 1,108 |
[
"WebAssembly",
"wabt"
] |
Hi all,
I looks like the wat2wasm tool doesn't support bytes expressed in hexadecimal as stated by the WASM 1.0 spec.
Concretely wat2wasm is fine with :
`(data 0 (i32.const 4) "\04\00\00\00")`
but throw an error with:
`(data 0 (i32.const 4) 0x04 0x00 0x00 0x00)`
Is it a known problem with wat2 wasm or am I misreading the WASM spec ?
|
data segment byte coding not following spec ?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1107/comments
| 2 |
2019-07-10T14:08:23Z
|
2019-07-10T14:23:28Z
|
https://github.com/WebAssembly/wabt/issues/1107
| 466,331,668 | 1,107 |
[
"WebAssembly",
"wabt"
] |
```
bin/wasm2c --version
unknown option '--version'
```
How can I do that? If it doesn't exist yet then:
**feature request:** allow me to ask the binary about its version number.
(obviously, `--version` for all of them: `bin/spectest-interp bin/wasm2c bin/wasm2wat bin/wasm-interp bin/wasm-objdump bin/wasm-opcodecnt bin/wasm-strip bin/wasm-validate bin/wast2json bin/wat2wasm bin/wat-desugar`)
thanks.
|
bin/wasm2c --version # how to ?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1106/comments
| 2 |
2019-07-08T22:47:37Z
|
2019-10-21T20:35:27Z
|
https://github.com/WebAssembly/wabt/issues/1106
| 465,491,916 | 1,106 |
[
"WebAssembly",
"wabt"
] |
Example test case from the spec test suite ([const.wast#L147](https://github.com/WebAssembly/testsuite/blob/master/const.wast#L147)):
```wasm
(module
(func
(f32.const nan:0x7f_ffff)
drop
)
)
```
According to the [specification](https://webassembly.github.io/spec/core/text/values.html#floating-point), the above program seems perfectly valid, however the `wat2wasm` tool reports:
```
a.wat:3:20: error: invalid literal "nan:0x7f_ffff"
(f32.const nan:0x7f_ffff)
^^^^^^^^^^^^^
```
If the underscore is removed, then compilation is successful.
The same problem exists in the `wat2wasm` [online demo](https://webassembly.github.io/wabt/demo/wat2wasm/) as well.
From what I understand, the top-level module S-expressions like the above (i.e. the ones which are not a part of an `assert_` S-expression), are supposed to be valid. How does this pass the spec test suite?
Cheers,
Ergys
|
wat2wasm: float nan hex literals with underscores are reported as invalid
|
https://api.github.com/repos/WebAssembly/wabt/issues/1104/comments
| 2 |
2019-07-03T15:03:11Z
|
2019-07-29T21:53:11Z
|
https://github.com/WebAssembly/wabt/issues/1104
| 463,805,037 | 1,104 |
[
"WebAssembly",
"wabt"
] |
`gtest` and `ply `seem to be packaged by Arch and Alpine (and presumably other distros, though perhaps not all). Is it necessary have them vendored as submodules?
It seems desirable for packaging to either not provide a vendored version, or have an option to use the system version instead.
|
Allow building with system gtest and ply
|
https://api.github.com/repos/WebAssembly/wabt/issues/1103/comments
| 2 |
2019-07-02T03:42:01Z
|
2019-07-16T00:59:07Z
|
https://github.com/WebAssembly/wabt/issues/1103
| 463,004,700 | 1,103 |
[
"WebAssembly",
"wabt"
] |
Hello,
This is more probably an error on my part than an "issue", I'm just not sure where to get help on this...
Running Ubuntu, juste after "sudo apt install cmake", then "cmake .." (in the newly created build directory, as instructed). I get this
```
-- The C compiler identification is GNU 8.3.0
-- The CXX compiler identification is unknown
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
CMake Error at CMakeLists.txt:18 (project):
No CMAKE_CXX_COMPILER could be found.
Tell CMake where to find the compiler by setting either the environment
variable "CXX" or the CMake cache entry CMAKE_CXX_COMPILER to the full path
to the compiler, or to the compiler name if it is in the PATH.
-- Configuring incomplete, errors occurred!
```
I'm guessing the cmake version I got is not exactly the one that is expected or it is not configured the same way the developers thought it would be.
In any case, I don't know what to do... I'm as clueless as the message as to where to find this missing compiler.
Any suggestion?
|
No CMAKE_CXX_COMPILER could be found
|
https://api.github.com/repos/WebAssembly/wabt/issues/1102/comments
| 2 |
2019-06-29T19:16:13Z
|
2019-07-02T23:00:51Z
|
https://github.com/WebAssembly/wabt/issues/1102
| 462,332,957 | 1,102 |
[
"WebAssembly",
"wabt"
] |
I think it's a validation error in references types validation
|
table.grow [i32, anyref] instead of [anyref, i32]
|
https://api.github.com/repos/WebAssembly/wabt/issues/1098/comments
| 9 |
2019-06-27T10:41:58Z
|
2019-07-29T21:55:39Z
|
https://github.com/WebAssembly/wabt/issues/1098
| 461,455,273 | 1,098 |
[
"WebAssembly",
"wabt"
] |
I have a wasm .so with the following sections:
```
~/wabt/bin/wasm-objdump -h /home/keno/julia-wasm/julia/build-wasm/usr/lib/libjulia.so
libjulia.so: file format wasm 0x1
023d986: warning: unable to read u32 leb128: index
Sections:
Type start=0x0000000b end=0x000001cf (size=0x000001c4) count: 63
Import start=0x000001d3 end=0x0000bc14 (size=0x0000ba41) count: 1692
Function start=0x0000bc17 end=0x0000c2a5 (size=0x0000068e) count: 1676
Elem start=0x0000c2a8 end=0x0000c5ed (size=0x00000345) count: 1
Code start=0x0000c5f1 end=0x000e35b6 (size=0x000d6fc5) count: 1676
Data start=0x000e35ba end=0x001a5de3 (size=0x000c2829) count: 2187
Custom start=0x001a5de7 end=0x001bba4c (size=0x00015c65) ".debug_info"
Custom start=0x001bba4e end=0x001bba5e (size=0x00000010) ".debug_macinfo"
Custom start=0x001bba61 end=0x001be6f5 (size=0x00002c94) ".debug_loc"
Custom start=0x001be6f8 end=0x001c1b56 (size=0x0000345e) ".debug_ranges"
Custom start=0x001c1b59 end=0x001c2184 (size=0x0000062b) ".debug_abbrev"
Custom start=0x001c2188 end=0x001d6950 (size=0x000147c8) ".debug_line"
Custom start=0x001d6953 end=0x001d9b72 (size=0x0000321f) ".debug_str"
Custom start=0x001d9b76 end=0x00201762 (size=0x00027bec) "linking"
Custom start=0x00201766 end=0x0023d986 (size=0x0003c220) "reloc.CODE"
Custom start=0x0023d989 end=0x0023e7e8 (size=0x00000e5f) "reloc.DATA"
Custom start=0x0023e7ec end=0x0024dd7d (size=0x0000f591) "reloc..debug_info"
Custom start=0x0024dd80 end=0x0024fbbf (size=0x00001e3f) "reloc..debug_loc"
Custom start=0x0024fbc3 end=0x00253e88 (size=0x000042c5) "reloc..debug_ranges"
Custom start=0x00253e8b end=0x00254673 (size=0x000007e8) "reloc..debug_line"
Custom start=0x00254677 end=0x00264554 (size=0x0000fedd) "name"
Custom start=0x00264557 end=0x002645df (size=0x00000088) "producers"
```
I was expecting this to work:
```
~/wabt/bin/wasm-objdump -x --section "reloc.CODE" /home/keno/julia-wasm/julia/build-wasm/usr/lib/libjulia.so
libjulia.so: file format wasm 0x1
023d986: warning: unable to read u32 leb128: index
Section Details:
Section not found: reloc.CODE
```
However, the SECTION argument to `--section` only refers to the built in section types. It would be nice if it could filter custom section types by name also.
|
Add filtering by custom section name to wasm-objdump
|
https://api.github.com/repos/WebAssembly/wabt/issues/1095/comments
| 4 |
2019-06-23T22:31:30Z
|
2019-06-27T17:18:06Z
|
https://github.com/WebAssembly/wabt/issues/1095
| 459,625,434 | 1,095 |
[
"WebAssembly",
"wabt"
] |
The `-ttf` option to `wasm-opt` stands for "translate to fuzz" and essentially makes wasm-opt into a test case generator for fuzzing.
However, it generates imports that `wasm-interp` doesn't know about, but are morally equivalent to `host.print` AFAICT:
```wasm
(import "fuzzing-support" "log-i32" (func $log-i32 (param i32)))
(import "fuzzing-support" "log-i64" (func $log-i64 (param i64)))
(import "fuzzing-support" "log-f32" (func $log-f32 (param f32)))
(import "fuzzing-support" "log-f64" (func $log-f64 (param f64)))
```
Because `wasm-interp` doesn't support these imports, one can't run these wasm binaries in `wasm-interp`.
Would supporting these imports in `wasm-interp` be something y'all are interested in?
|
wasm-interp: support running wasm binaries created by `wasm-opt -ttf`?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1094/comments
| 2 |
2019-06-20T23:20:42Z
|
2019-06-28T22:45:50Z
|
https://github.com/WebAssembly/wabt/issues/1094
| 458,930,644 | 1,094 |
[
"WebAssembly",
"wabt"
] |
Hello, I am writing a homemade 3rd party interpreter, and wonder how to use test suite in `/test` to test my own one, instead of copying and renaming my executable to `wasm-interp` and move to `wabt/bin`.
|
Test suite supporting 3rd party interpreters?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1093/comments
| 4 |
2019-06-18T00:53:42Z
|
2019-06-19T21:41:11Z
|
https://github.com/WebAssembly/wabt/issues/1093
| 457,209,805 | 1,093 |
[
"WebAssembly",
"wabt"
] |
### Environment
| Questions | Answers
|----------------------|--------------------
| Related Binary | wasm-interp
| Commit | commit 986f5cc8bb85ba4ecc0dd3ed82fa39565ce9c419
### Vulnerability/issue
Assertion failed in wabt::BinaryReaderInterp::EndElemSegmentInitExpr() in binary-reader-interp.cc
### Steps to reproduce the behavior
- Download: [wasm-interp_assert-failed_BinaryReaderInterp_EndElemSegmentInitExpr.zip](https://github.com/WebAssembly/wabt/files/3263280/wasm-interp_assert-failed_BinaryReaderInterp_EndElemSegmentInitExpr.zip)
- Run: `wasm-interp wasm-interp_assert-failed_BinaryReaderInterp_EndElemSegmentInitExpr`
### Additional Informations
Crash
```
wasm-interp: XYZ/wabt/src/interp/binary-reader-interp.cc:1052: virtual wabt::Result wabt::(anonymous namespace)::BinaryReaderInterp::EndElemSegmentInitExpr(Index): Assertion `init_expr_value_.type == Type::I32' failed.
```
|
[wasm-interp] Assertion failed in wabt::BinaryReaderInterp::EndElemSegmentInitExpr() in binary-reader-interp.cc
|
https://api.github.com/repos/WebAssembly/wabt/issues/1091/comments
| 0 |
2019-06-06T20:03:45Z
|
2019-06-07T22:34:54Z
|
https://github.com/WebAssembly/wabt/issues/1091
| 453,214,126 | 1,091 |
[
"WebAssembly",
"wabt"
] |
### Environment
| Questions | Answers
|----------------------|--------------------
| Related Binary | wasm-interp
| Commit | commit 986f5cc8bb85ba4ecc0dd3ed82fa39565ce9c419
### Vulnerability/issue
Assertion failed in wabt::BinaryReaderInterp::OnDataSegmentData() in binary-reader-interp.cc
### Steps to reproduce the behavior
- Download: [wasm-interp_assert-failed_BinaryReaderInterp_OnDataSegmentData.zip](https://github.com/WebAssembly/wabt/files/3263272/wasm-interp_assert-failed_BinaryReaderInterp_OnDataSegmentData.zip)
- Run: `wasm-interp wasm-interp_assert-failed_BinaryReaderInterp_OnDataSegmentData`
### Additional Informations
Crash
```
wasm-interp: XYZ/wabt/src/interp/binary-reader-interp.cc:1134: virtual wabt::Result wabt::(anonymous namespace)::BinaryReaderInterp::OnDataSegmentData(Index, const void *, Address): Assertion `init_expr_value_.type == Type::I32' failed.
```
|
[wasm-interp] Assertion failed in wabt::BinaryReaderInterp::OnDataSegmentData() in binary-reader-interp.cc
|
https://api.github.com/repos/WebAssembly/wabt/issues/1090/comments
| 0 |
2019-06-06T20:01:43Z
|
2019-06-07T22:35:00Z
|
https://github.com/WebAssembly/wabt/issues/1090
| 453,213,280 | 1,090 |
[
"WebAssembly",
"wabt"
] |
### Environment
| Questions | Answers
|----------------------|--------------------
| Related Binary | wasm-interp
| Commit | commit 986f5cc8bb85ba4ecc0dd3ed82fa39565ce9c419
### Vulnerability/issue
Assertion failed in wabt::TypeChecker::GetLabel() in type-checker.cc
### Steps to reproduce the behavior
- Download: [wasm-interp_assert-failed_type-TypeChecker_GetLabel.zip](https://github.com/WebAssembly/wabt/files/3263245/wasm-interp_assert-failed_type-TypeChecker_GetLabel.zip)
- Run: `wasm-interp wasm-interp_assert-failed_type-TypeChecker_GetLabel`
### Additional Informations
Crash:
```
wasm-interp: XYZ/wabt/src/type-checker.cc:66: wabt::Result wabt::TypeChecker::GetLabel(Index, wabt::TypeChecker::Label **): Assertion `label_stack_.size() > 0' failed.
```
|
[wasm-interp] Assertion failed in wabt::TypeChecker::GetLabel() in type-checker.cc
|
https://api.github.com/repos/WebAssembly/wabt/issues/1089/comments
| 0 |
2019-06-06T19:59:16Z
|
2019-06-07T22:34:33Z
|
https://github.com/WebAssembly/wabt/issues/1089
| 453,212,290 | 1,089 |
[
"WebAssembly",
"wabt"
] |
Unicode symbols are currently mangled by the `wast2json` tool, which I noticed when trying to write a program that consumes and runs the JSON output.
For example, The `names.wast` file from the spec includes [a test case that uses a byte-order marker as a symbol](https://github.com/WebAssembly/spec/blob/master/test/core/names.wast#L58).
When processing that with `wast2json` (tested on a3a7a93f1f417c6c258e6b5d507adb004fc8b688), we get a file containing the following line:
```json
{"type": "assert_return", "line": 623, "action": {"type": "invoke", "field": "\u00ef\u00bb\u00bf", "args": []}, "expected": [{"type": "i32", "value": "15"}]},
```
That field name is awfully suspicious, being composed of three unicode codepoints (*not* bytes) in the range 128-255. Feeding the BOM `\uFEFF` through a UTF-8 encoder shows that, indeed, the UTF-8 encoding is `\xEF\xBB\xBF`. The JSON file is pretending each of these bytes is a codepoint, effectively double-encoding the symbol.
I suspect the culprit is [this line here](https://github.com/WebAssembly/wabt/blob/master/src/binary-writer-spec.cc#L114), which is treating a C++ `string_view` (which contains an unspecified 8-bit encoding) as though it contains unicode characters -- effectively (and I suspect inadvertently) treating any symbol as ISO-8859-1, while the wast reader seems to be using UTF-8.
As a workaround, in case this bug sits around until someone else tries to run these files, I've implemented this routine in my test runner:
```rust
fn destupify_string(input: &str) -> String {
let bytes: Vec<u8> = input.chars().map(|c| {
assert!(c < '\u{0100}');
c as u8
}).collect();
String::from_utf8(bytes).expect("warning: string is not doubly-encoded UTF8")
}
```
|
wast2json double-encodes UTF-8 symbols
|
https://api.github.com/repos/WebAssembly/wabt/issues/1086/comments
| 2 |
2019-05-28T22:55:40Z
|
2019-06-07T16:53:50Z
|
https://github.com/WebAssembly/wabt/issues/1086
| 449,513,032 | 1,086 |
[
"WebAssembly",
"wabt"
] |
I'm trying to compile for Windows using MinGW. I'm getting the following:
`error: #error unknown compiler`
This is the cmake command I'm running from the build directory:
`cmake --build . --config RELEASE --target install`
I'm getting a bunch of other errors too. Here is the whole command line output:
```
D:\Assets\VisualStudios\WAT-Book\wabt\build>cmake --build . --config RELEASE --target install
[ 1%] Building CXX object CMakeFiles/wabt.dir/src/apply-names.cc.obj
In file included from D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:33:0,
from D:\Assets\VisualStudios\WAT-Book\wabt/src/apply-names.h:20,
from D:\Assets\VisualStudios\WAT-Book\wabt\src\apply-names.cc:17:
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:115:2: error: #error unknown compiler
#error unknown compiler
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:235:2: error: #error unknown compiler
#error unknown compiler
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:262:2: error: #error unknown compiler
#error unknown compiler
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:273:2: error: #error no snprintf
#error no snprintf
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:291:2: error: #error no strcasecmp
#error no strcasecmp
^~~~~
In file included from D:\Assets\VisualStudios\WAT-Book\wabt/src/apply-names.h:20:0,
from D:\Assets\VisualStudios\WAT-Book\wabt\src\apply-names.cc:17:
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:143:38: error: 'wabt::WABT_PRINTF_FORMAT' declared as an 'inline' variable
inline std::string WABT_PRINTF_FORMAT(1, 2)
^
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:144:5: error: expected ',' or ';' before 'StringPrintf'
StringPrintf(const char* format, ...) {
^~~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:314:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetKindName(ExternalKind kind) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:324:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetRelocTypeName(RelocType reloc) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:332:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetSymbolTypeName(SymbolType type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:351:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetTypeName(Type type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:380:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE bool IsTypeIndex(Type type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:384:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE Index GetTypeIndex(Type type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:389:8: error: 'WABT_INLINE' does not name a type:389:8: error: 'WABT_INLINE' does not name a type (Type type) {
static WABT_INLINE TypeVector GetInlineTypeVector(Type type) { Book\wabt/src/ir.h:31:0,
^~~~~~~~~~~ Book\wabt/src/expr-visitor.h:21,
In file included from D:\Assets\VisualStudios\WAT-Book\wabt\src\apply-names.cc:23:Book\wabt/src/ir.h:31:0, : In static member function 'static wabt::Opcode wabt::Opcode::FromCode(uint8_t, uint32_t)':
from D:\Assets\VisualStudios\WAT-:156:69: error: 'WABT_LIKELY' was not declared in this scopeBook\wabt/src/expr-visitor.h:21, abtOpcodeCodeTable))) {
from D:\Assets\VisualStudios\WAT- ^Book\wabt\src\apply-names.cc:23: et 'CMakeFiles/wabt.dir/src/apply-names.cc.obj' failed
D:\Assets\VisualStudios\WAT-Book\wabt/src/opcode.happly-names.cc.obj] Error 1: In static member function 'static wabt::Opcode wFiles/wabt.dir/all' failedabt::Opcode::FromCode(uint8_t, uint32_t)': Error 2
D:\Assets\VisualStudios\WAT-Book\wabt/src/opcode.h
D:\Assets\VisualStudios\WAT-Book\wabt\build>cmake --build .. --config RELEASE --target install
Error: could not load cache
D:\Assets\VisualStudios\WAT-Book\wabt\build>cmake --build . --config RELEASE --target install
[ 1%] Building CXX object CMakeFiles/wabt.dir/src/apply-names.cc.obj
In file included from D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:33:0,
from D:\Assets\VisualStudios\WAT-Book\wabt/src/apply-names.h:20,
from D:\Assets\VisualStudios\WAT-Book\wabt\src\apply-names.cc:17:
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:115:2: error: #error unknown compiler
#error unknown compiler
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:235:2: error: #error unknown compiler
#error unknown compiler
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:262:2: error: #error unknown compiler
#error unknown compiler
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:273:2: error: #error no snprintf
#error no snprintf
^~~~~
D:\Assets\VisualStudios\WAT-Book\wabt\build/config.h:291:2: error: #error no strcasecmp
#error no strcasecmp
^~~~~
In file included from D:\Assets\VisualStudios\WAT-Book\wabt/src/apply-names.h:20:0,
from D:\Assets\VisualStudios\WAT-Book\wabt\src\apply-names.cc:17:
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:143:38: error: 'wabt::WABT_PRINTF_FORMAT' declared as an 'inline' variable
inline std::string WABT_PRINTF_FORMAT(1, 2)
^
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:144:5: error: expected ',' or ';' before 'StringPrintf'
StringPrintf(const char* format, ...) {
^~~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:314:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetKindName(ExternalKind kind) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:324:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetRelocTypeName(RelocType reloc) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:332:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetSymbolTypeName(SymbolType type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:351:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE const char* GetTypeName(Type type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:380:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE bool IsTypeIndex(Type type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:384:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE Index GetTypeIndex(Type type) {
^~~~~~~~~~~
D:\Assets\VisualStudios\WAT-Book\wabt/src/common.h:389:8: error: 'WABT_INLINE' does not name a type
static WABT_INLINE TypeVector GetInlineTypeVector(Type type) {
^~~~~~~~~~~
In file included from D:\Assets\VisualStudios\WAT-Book\wabt/src/ir.h:31:0,
from D:\Assets\VisualStudios\WAT-Book\wabt/src/expr-visitor.h:21,
from D:\Assets\VisualStudios\WAT-Book\wabt\src\apply-names.cc:23:
D:\Assets\VisualStudios\WAT-Book\wabt/src/opcode.h: In static member function 'static wabt::Opcode wabt::Opcode::FromCode(uint8_t, uint32_t)':
D:\Assets\VisualStudios\WAT-Book\wabt/src/opcode.h:156:69: error: 'WABT_LIKELY' was not declared in this scope
if (WABT_LIKELY(prefix_code < WABT_ARRAY_SIZE(WabtOpcodeCodeTable))) {
^
CMakeFiles\wabt.dir\build.make:61: recipe for target 'CMakeFiles/wabt.dir/src/apply-names.cc.obj' failed
mingw32-make.exe[2]: *** [CMakeFiles/wabt.dir/src/apply-names.cc.obj] Error 1
CMakeFiles\Makefile2:189: recipe for target 'CMakeFiles/wabt.dir/all' failed
mingw32-make.exe[1]: *** [CMakeFiles/wabt.dir/all] Error 2
Makefile:128: recipe for target 'all' failed
mingw32-make.exe: *** [all] Error 2
```
Any suggestions?
|
Can't compile for Windows
|
https://api.github.com/repos/WebAssembly/wabt/issues/1085/comments
| 1 |
2019-05-21T02:15:44Z
|
2022-05-19T01:43:35Z
|
https://github.com/WebAssembly/wabt/issues/1085
| 446,385,236 | 1,085 |
[
"WebAssembly",
"wabt"
] |
See #1078. Example:
```
test.wast:1:17: error: invalid literal "11111111111"
(func i32.const 11111111111 drop)
^^^^^^^^^^^
```
Something like "literal out of range ..." would be a clearer message here.
|
Better error on literal overflow
|
https://api.github.com/repos/WebAssembly/wabt/issues/1080/comments
| 0 |
2019-05-15T15:44:10Z
|
2020-03-20T20:29:08Z
|
https://github.com/WebAssembly/wabt/issues/1080
| 444,512,429 | 1,080 |
[
"WebAssembly",
"wabt"
] |
Hi,
Help needed, today I test for a max value literal of the ``f64`` number, and have error reports when convert wast to wasm binary:
```
literal.wast:42:47: error: invalid literal "1.79769313486232e+308"
(global $Double.MaxValue (mut f64) (f64.const 1.79769313486232e+308))
^^^^^^^^^^^^^^^^^^^^^
```
The value of ``Double.MaxValue`` its literal value in .NET Framework is **1.79769313486232E+308**, but it seems that such literal syntax in scientific notation is not valid in WebAssembly S-Expression
I have check for the documents in repository [WebAssembly/design](https://github.com/WebAssembly/design), but didn't find something about literal a large number.
Here are some necessary information for reproduce this error:
> Demo script: [literal.txt](https://github.com/WebAssembly/wabt/files/3168646/literal.txt)
> Version of wat2wasm: [wabt-1.0.11-win64](https://github.com/WebAssembly/wabt/releases/tag/1.0.11)
|
[Help] How to literal a very large number?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1078/comments
| 4 |
2019-05-11T05:39:23Z
|
2019-05-15T15:44:32Z
|
https://github.com/WebAssembly/wabt/issues/1078
| 442,956,762 | 1,078 |
[
"WebAssembly",
"wabt"
] |
hello,
I'm doing AFL fuzzy of "wasm-interp" program of WABT, latest master branch.
The attached binary file can crash ""wasm-interp", probably due to empty function body.
Just decompress the zip file and run command "wasm-interp fuzzy.wasm" to reproduce it.
[fuzzy.zip](https://github.com/WebAssembly/wabt/files/3158085/fuzzy.zip)
```
ASAN:DEADLYSIGNAL
=================================================================
==13700==ERROR: AddressSanitizer: SEGV on unknown address 0x00009fff7fff (pc 0x000000570ac8 bp 0x7fffde126de0 sp 0x7fffde1268a0 T0)
==13700==The signal is caused by a READ memory access.
#0 0x570ac7 in unsigned int wabt::interp::ReadUxAt<unsigned int>(unsigned char const*) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:721:3
#1 0x570ac7 in unsigned int wabt::interp::ReadUx<unsigned int>(unsigned char const**) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:727
#2 0x570ac7 in wabt::interp::ReadU32(unsigned char const**) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:745
#3 0x570ac7 in wabt::interp::ReadOpcode(unsigned char const**) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:765
#4 0x570ac7 in wabt::interp::Thread::Run(int) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:1569
#5 0x5c7dca in wabt::interp::Executor::RunDefinedFunction(unsigned int) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:4630:24
#6 0x5c7dca in wabt::interp::Executor::RunFunction(unsigned int, std::vector<wabt::interp::TypedValue, std::allocator<wabt::interp::TypedValue> > const&) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:4571
#7 0x5c8f38 in wabt::interp::Executor::RunStartFunction(wabt::interp::DefinedModule*) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:4590:28
#8 0x5526b5 in ReadAndRunModule(char const*) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/tools/wasm-interp.cc:198:39
#9 0x5526b5 in ProgramMain(int, char**) /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/tools/wasm-interp.cc:217
#10 0x5530d5 in main /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/tools/wasm-interp.cc:223:10
#11 0x7f1cde491b96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
#12 0x45df29 in _start (/home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/build/wasm-interp+0x45df29)
AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV /home/happy/wabt_afl_fuzzy_qt/wabt_afl_fuzzy/src/interp.cc:721:3 in unsigned int wabt::interp::ReadUxAt<unsigned int>(unsigned char const*)
==13700==ABORTING
```
|
malformed binary WASM file crashes "wasm-interp"
|
https://api.github.com/repos/WebAssembly/wabt/issues/1077/comments
| 2 |
2019-05-08T15:30:52Z
|
2019-05-09T00:59:09Z
|
https://github.com/WebAssembly/wabt/issues/1077
| 441,796,450 | 1,077 |
[
"WebAssembly",
"wabt"
] |
### Input file
`hello_world.wat`
```wasm
(module
(func $output_println (import "System::Output" "println") (param i32))
(func $factorial (param $n i32) (result i32)
(if
(i32.eq
(get_local $n)
(i32.const 1)
)
(then
(return
(i32.const 1)
)
)
(else
(return
(i32.mul
(get_local $n)
(call
$factorial
(i32.sub
(get_local $n)
(i32.const 1)
)
)
)
)
)
)
)
(func $Main (export "Main")
(call
$output_println
(call
$factorial
(i32.const 5)
)
)
)
)
```
### Command run
```
wat2wasm hello_world.wat -o hello_world.wasm
```
### Output
```
hello_world.wat:29:9: error: type mismatch in implicit return, expected [i32] but got []
)
^
```
### Expected output
wat2wasm infers that all code paths result in i32 being returned, and compiles to wasm sucessfully.
Adding an explicit return after the if structure within `$factorial` fixes the issue, but is an impossible code path.
|
wat2wasm - type mismatch in implicit return
|
https://api.github.com/repos/WebAssembly/wabt/issues/1075/comments
| 4 |
2019-05-05T23:05:09Z
|
2019-05-16T00:17:25Z
|
https://github.com/WebAssembly/wabt/issues/1075
| 440,500,996 | 1,075 |
[
"WebAssembly",
"wabt"
] |
https://webassembly.github.io/wabt/demo/wat2wasm/
selecting factorial, an error shows
```
Error: resolveNames failed:
test.wast:13:12: error: undefined function variable "$fac"
call $fac
^^^^
```
Was reading this https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format and figured out how to fix it...
can fix it specifying a name....
``` wasm
(module
--- ;; (func (export "fac") (param f64) (result f64)
+++ (func $fac (export "fac") (param f64) (result f64)
local.get 0
f64.const 1
f64.lt
if (result f64)
f64.const 1
else
local.get 0
local.get 0
f64.const 1
f64.sub
call $fac
f64.mul
end))
```
Or I guess add at the end
```
--- ;; (func (export "fac") (param f64) (result f64)
+++ (func $fac (param f64) (result f64)
+++ (export "fac" (func $fac)
)
```
|
Factorial Example doesn't work
|
https://api.github.com/repos/WebAssembly/wabt/issues/1072/comments
| 1 |
2019-04-27T08:50:06Z
|
2019-04-29T01:01:57Z
|
https://github.com/WebAssembly/wabt/issues/1072
| 437,922,548 | 1,072 |
[
"WebAssembly",
"wabt"
] |
These seems to be new. Wondering if its a known is issue?
```
ninja: Entering directory `out/clang/Debug/'
[48/94] Building CXX object CMakeFiles/wabt.dir/src/interp/interp-trace.cc.o
../../../src/interp/interp-trace.cc:35:11: warning: enumeration value 'RefFunc' not handled in switch [-Wswitch]
switch (opcode) {
^
1 warning generated.
[56/94] Building CXX object CMakeFiles/wabt.dir/src/interp/interp-disassemble.cc.o
../../../src/interp/interp-disassemble.cc:44:13: warning: enumeration value 'RefFunc' not handled in switch [-Wswitch]
switch (opcode) {
^
1 warning generated.
[65/94] Building CXX object CMakeFiles/wabt.dir/src/interp/interp.cc.o
../../../src/interp/interp.cc:1538:13: warning: enumeration value 'RefFunc' not handled in switch [-Wswitch]
switch (opcode) {
^
1 warning generated.
```
|
New -Wswitch warnings
|
https://api.github.com/repos/WebAssembly/wabt/issues/1070/comments
| 1 |
2019-04-24T01:06:32Z
|
2019-04-24T07:24:41Z
|
https://github.com/WebAssembly/wabt/issues/1070
| 436,451,869 | 1,070 |
[
"WebAssembly",
"wabt"
] |
Hi,
Help needed, when i use wat2wasm for compile ``S-Expression`` text format script to WebAssembly binary, error reports:
```
base64.wast:252:22: error: type mismatch in if true branch, expected [] but got [i32]
(call $array_push (get_local $chars) (call $fromCharCode ...
^^^^
base64.wast:258:5: error: type mismatch in if false branch, expected [] but got [i32, i32, i32]
)
^
base64.wast:290:14: error: type mismatch in if true branch, expected [] but got [i32]
(set_local $n (i32.add (get_local $n) (i32.const 1)))
^^^^^^^^^
base64.wast:297:5: error: type mismatch in if false branch, expected [] but got [i32]
)
^
```
But after i check the input wast file, i didn't found any errors in the wast script file. I not sure there is some bugs in ``wat2wasm`` or I'm just missed something.....
Here are some necessary information for reproduce these errors:
> Demo script: [base64_wast.txt](https://github.com/WebAssembly/wabt/files/3099945/base64_wast.txt)
> Version of wat2wasm: [wabt-1.0.10-win64](https://github.com/WebAssembly/wabt/releases/tag/1.0.10)
> Command line for run the compiler:
```cmd
wat2wasm.exe base64.wast --verbose --debug-parser --output base64.wasm --debug-names
```
|
[Bugs Report] failed to compile
|
https://api.github.com/repos/WebAssembly/wabt/issues/1067/comments
| 4 |
2019-04-20T10:04:27Z
|
2019-04-21T09:07:12Z
|
https://github.com/WebAssembly/wabt/issues/1067
| 435,380,140 | 1,067 |
[
"WebAssembly",
"wabt"
] |
It seems the `section_starts_` is shared for all custom sections, so it ends up being overwritten if there are multiple custom sections in the binary. It probably should be changed to use the section index instead of the section code. @sbc100
|
[wasm-objdump] File offset for relocation of custom sections is wrong
|
https://api.github.com/repos/WebAssembly/wabt/issues/1064/comments
| 0 |
2019-04-15T18:58:52Z
|
2019-04-15T18:58:52Z
|
https://github.com/WebAssembly/wabt/issues/1064
| 433,431,000 | 1,064 |
[
"WebAssembly",
"wabt"
] |
Running the 1.0.10 testsuite (test/run-tests.py) on big-endian arches (POWER8/ppc64 and s390x) yields the following failed tests:
```
- test/binary/bad-call-indirect-reserved.txt
- test/binary/bad-data-count-mismatch.txt
- test/binary/bad-data-count-order-after-code.txt
- test/binary/bad-data-count-order-before-elem.txt
- test/binary/bad-data-size.txt
- test/binary/bad-duplicate-section-around-custom.txt
- test/binary/bad-duplicate-section.txt
- test/binary/bad-duplicate-subsection.txt
- test/binary/bad-event-after-export.txt
- test/binary/bad-event-before-global.txt
- test/binary/bad-export-func.txt
- test/binary/bad-extra-end.txt
- test/binary/bad-function-body-count.txt
- test/binary/bad-function-body-size.txt
- test/binary/bad-function-count-missing-code-section.txt
- test/binary/bad-function-local-count.txt
- test/binary/bad-function-local-type.txt
- test/binary/bad-function-names-too-many.txt
- test/binary/bad-function-param-type.txt
- test/binary/bad-function-result-type.txt
- test/binary/bad-function-sig.txt
- test/binary/bad-function-too-many-results.txt
- test/binary/bad-import-sig.txt
- test/binary/bad-linking-metadata.txt
- test/binary/bad-logging-basic.txt
- test/binary/bad-memory-grow-reserved.txt
- test/binary/bad-memory-init-max-size.txt
- test/binary/bad-memory-init-size.txt
- test/binary/bad-memory-max-size.txt
- test/binary/bad-memory-size-reserved.txt
- test/binary/bad-name-section-invalid-index.txt
- test/binary/bad-name-section-location.txt
- test/binary/bad-names-duplicate-locals.txt
- test/binary/bad-names-duplicates.txt
- test/binary/bad-names-function-locals-out-of-order.txt
- test/binary/bad-names-out-of-order.txt
- test/binary/bad-op-after-end.txt
- test/binary/bad-opcode-prefix.txt
- test/binary/bad-opcode.txt
- test/binary/bad-returncallindirect-reserved.txt
- test/binary/bad-section-ends-early.txt
- test/binary/bad-section-size-zero.txt
- test/binary/bad-segment-no-memory.txt
- test/binary/bad-simd-type.txt
- test/binary/bad-start-func.txt
- test/binary/bad-subsection-out-of-order.txt
- test/binary/bad-subsection-size.txt
- test/binary/bad-subsection-unfinished.txt
- test/binary/bad-too-many-locals.txt
- test/binary/bad-type-form.txt
- test/binary/bad-typecheck-fail.txt
- test/binary/bad-typecheck-missing-drop.txt
- test/binary/bad-version.txt
- test/binary/basic.txt
- test/binary/duplicate-func-names.txt
- test/binary/duplicate-local-names.txt
- test/binary/dylink-section.txt
- test/binary/ignore-custom-section-error-objdump.txt
- test/binary/ignore-custom-section-error-wasm2wat.txt
- test/binary/invalid-name.txt
- test/binary/linking-section.txt
- test/binary/missing-code-section-empty-function-section.txt
- test/binary/missing-function-section-empty-code-section.txt
- test/binary/names.txt
- test/binary/no-global-names.txt
- test/binary/no-names.txt
- test/binary/relocs.txt
- test/binary/user-section.txt
- test/dump/bad-version-logging.txt
- test/dump/bad-version.txt
- test/dump/basic.txt
- test/dump/binary.txt
- test/dump/block-257-exprs-br.txt
- test/dump/block-257-exprs.txt
- test/dump/block-multi.txt
- test/dump/block.txt
- test/dump/br-block-named.txt
- test/dump/br-block.txt
- test/dump/br-loop-inner-expr.txt
- test/dump/br-loop-inner.txt
- test/dump/br-loop.txt
- test/dump/br_on_exn.txt
- test/dump/brif-loop.txt
- test/dump/brif.txt
- test/dump/brtable-empty.txt
- test/dump/brtable.txt
- test/dump/call.txt
- test/dump/callimport.txt
- test/dump/callindirect.txt
- test/dump/cast.txt
- test/dump/compare.txt
- test/dump/const.txt
- test/dump/convert-sat.txt
- test/dump/convert.txt
- test/dump/current-memory.txt
- test/dump/debug-import-names.txt
- test/dump/debug-names.txt
- test/dump/dedupe-sig.txt
- test/dump/drop.txt
- test/dump/event.txt
- test/dump/export-multi.txt
- test/dump/expr-br.txt
- test/dump/expr-brif.txt
- test/dump/func-exported.txt
- test/dump/func-multi.txt
- test/dump/func-named.txt
- test/dump/func-result-multi.txt
- test/dump/getglobal.txt
- test/dump/getlocal-param.txt
- test/dump/getlocal.txt
- test/dump/global.txt
- test/dump/grow-memory.txt
- test/dump/hexfloat_f32.txt
- test/dump/hexfloat_f64.txt
- test/dump/if-multi.txt
- test/dump/if-then-else-list.txt
- test/dump/if-then-list.txt
- test/dump/if.txt
- test/dump/import.txt
- test/dump/invalid-data-segment-no-memory.txt
- test/dump/invalid-data-segment-offset.txt
- test/dump/invalid-elem-segment-no-table.txt
- test/dump/invalid-elem-segment-offset.txt
- test/dump/load-aligned.txt
- test/dump/load.txt
- test/dump/locals.txt
- test/dump/loop-257-exprs-br.txt
- test/dump/loop-257-exprs.txt
- test/dump/loop-multi.txt
- test/dump/loop.txt
- test/dump/memory-1-byte.txt
- test/dump/memory-data-size.txt
- test/dump/memory-hex.txt
- test/dump/memory.txt
- test/dump/module-name.txt
- test/dump/mutable-global.txt
- test/dump/no-canonicalize.txt
- test/dump/nocheck.txt
- test/dump/nop.txt
- test/dump/param-multi.txt
- test/dump/result.txt
- test/dump/rethrow.txt
- test/dump/return.txt
- test/dump/select.txt
- test/dump/setglobal.txt
- test/dump/setlocal-param.txt
- test/dump/setlocal.txt
- test/dump/signatures.txt
- test/dump/simd-basic.txt
- test/dump/simd-binary.txt
- test/dump/simd-bitselect.txt
- test/dump/simd-compare.txt
- test/dump/simd-lane.txt
- test/dump/simd-load-store.txt
- test/dump/simd-shift.txt
- test/dump/simd-splat.txt
- test/dump/simd-unary.txt
- test/dump/start.txt
- test/dump/store-aligned.txt
- test/dump/store.txt
- test/dump/string-escape.txt
- test/dump/string-hex.txt
- test/dump/table.txt
- test/dump/tee_local.txt
- test/dump/throw.txt
- test/dump/try-multi.txt
- test/dump/try.txt
- test/dump/unary-extend.txt
- test/dump/unary.txt
- test/dump/unreachable.txt
- test/gen-spec-js/action.txt
- test/gen-spec-js/assert_exhaustion.txt
- test/gen-spec-js/assert_return.txt
- test/gen-spec-js/assert_return_nan.txt
- test/gen-spec-js/assert_trap.txt
- test/gen-spec-js/assert_uninstantiable.txt
- test/gen-spec-js/assert_unlinkable.txt
- test/gen-spec-js/basic.txt
- test/gen-spec-js/many-modules.txt
- test/gen-spec-js/register.txt
- test/interp/atomic-load.txt
- test/interp/atomic-rmw-add.txt
- test/interp/atomic-rmw-and.txt
- test/interp/atomic-rmw-cmpxchg.txt
- test/interp/atomic-rmw-or.txt
- test/interp/atomic-rmw-sub.txt
- test/interp/atomic-rmw-xchg.txt
- test/interp/atomic-rmw-xor.txt
- test/interp/atomic-store.txt
- test/interp/basic-logging.txt
- test/interp/load.txt
- test/interp/logging-all-opcodes.txt
- test/interp/simd-binary.txt
- test/interp/simd-compare.txt
- test/interp/simd-lane.txt
- test/interp/simd-load-store.txt
- test/interp/simd-shift.txt
- test/interp/simd-splat.txt
- test/interp/simd-unary.txt
- test/interp/store.txt
- test/opcodecnt/basic.txt
- test/parse/expr/bad-simd-shuffle-lane-index-overflow.txt
- test/parse/module/binary-module.txt
- test/regress/regress-20.txt
- test/regress/regress-24.txt
- test/regress/regress-7.txt
- test/regress/regress-8.txt
- test/spec/address.txt
- test/spec/binary.txt
- test/spec/custom.txt
- test/spec/endianness.txt
- test/spec/float_exprs.txt
- test/spec/float_literals.txt
- test/spec/float_memory.txt
- test/spec/globals.txt
- test/spec/imports.txt
- test/spec/left-to-right.txt
- test/spec/memory.txt
- test/spec/memory_redundancy.txt
- test/spec/memory_trap.txt
- test/spec/mutable-global/globals.txt
- test/spec/utf8-custom-section-id.txt
- test/spec/utf8-import-field.txt
- test/spec/utf8-import-module.txt
- test/strip/basic.txt
- test/strip/names.txt
- test/strip/no-custom-sections.txt
- test/two-commands.txt
- test/wasm2c/spec/address.txt
- test/wasm2c/spec/binary.txt
- test/wasm2c/spec/custom.txt
- test/wasm2c/spec/endianness.txt
- test/wasm2c/spec/float_exprs.txt
- test/wasm2c/spec/float_literals.txt
- test/wasm2c/spec/float_memory.txt
- test/wasm2c/spec/imports.txt
- test/wasm2c/spec/left-to-right.txt
- test/wasm2c/spec/memory.txt
- test/wasm2c/spec/memory_redundancy.txt
- test/wasm2c/spec/memory_trap.txt
- test/wasm2c/spec/token.txt
- test/wasm2c/spec/typecheck.txt
- test/wasm2c/spec/unreached-invalid.txt
- test/wasm2c/spec/utf8-custom-section-id.txt
- test/wasm2c/spec/utf8-import-field.txt
- test/wasm2c/spec/utf8-import-module.txt
- test/wasm2c/spec/utf8-invalid-encoding.txt
```
Is running on big-endian supported at all? Only 1027 tests passed and 1702 were skipped, so this is a significant portion.
|
247 test failures on big-endian arches (ppc64 and s390x)
|
https://api.github.com/repos/WebAssembly/wabt/issues/1063/comments
| 6 |
2019-04-15T14:12:19Z
|
2021-02-03T10:55:06Z
|
https://github.com/WebAssembly/wabt/issues/1063
| 433,305,063 | 1,063 |
[
"WebAssembly",
"wabt"
] |
Hi,
I followed the instruction on your github and did a
cmake ..
I got no error, but in the clang/Debug there is no binary file wat2wasm etc...
Where will the binaries reside after building using cmake ?
Regards
Ranga
|
cmake error no wat2wasm binary found
|
https://api.github.com/repos/WebAssembly/wabt/issues/1062/comments
| 2 |
2019-04-11T06:08:52Z
|
2019-04-12T07:05:08Z
|
https://github.com/WebAssembly/wabt/issues/1062
| 431,845,624 | 1,062 |
[
"WebAssembly",
"wabt"
] |
Hi there!
I found that the result of wasm2wat is not real s-expression, the "if-else" branching code is an indentation-based syntax just like Python. This inconsistency makes it harder to use Lisp-like languages (for example, Scheme) to implement a static analyzer. It means people have to write a specific parser for it.
For example:
```scheme
(func $_main (type 5) (result i32)
(local i32 i32 i32 i32)
global.get 14
......
i32.ge_s
if ;; label = @1
i32.const 16
call $abortStackOverflow
end
......
return)
```
An ideal form should be:
```scheme
(func $_main (type 5) (result i32)
(local i32 i32 i32 i32)
global.get 14
......
i32.ge_s
(if ;; label = @1
i32.const 16
call $abortStackOverflow)
......
return)
```
This shouldn't be hard to implement in the current wabt, what do you think?
Thanks!
|
The result of wasm2wat is not real s-expression
|
https://api.github.com/repos/WebAssembly/wabt/issues/1048/comments
| 4 |
2019-03-20T12:45:02Z
|
2019-03-22T12:32:29Z
|
https://github.com/WebAssembly/wabt/issues/1048
| 423,231,662 | 1,048 |
[
"WebAssembly",
"wabt"
] |
When building 1.0.10 on Fedora rawhide (development) with gcc-9.0.1 and RHEL/CentOS 7 with gcc-4.8.5, the following tests fail on POWER8 (ppc64le) architecture:
```
- test/spec/conversions.txt
expected error code 0, got 2.
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1,3 @@
-401/401 tests passed.
+out/test/spec/conversions.wast:348: expected result to be nan, got f64:nan
+out/test/spec/conversions.wast:350: expected result to be nan, got f64:-nan
+399/401 tests passed.
- test/wasm2c/spec/conversions.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,15 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 407, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 400, in main
+ forward_stdout=True).RunWithArgs()
+ File "/builddir/build/BUILD/wabt-1.0.10/test/utils.py", line 104, in RunWithArgs
+ raise error
+utils.Error: Error running "out/test/wasm2c/spec/conversions/conversions":
+conversions-main.c:1118: assertion failed: in Z_conversions_0Z_f64Z2Epromote_f32Z_df(make_nan_f32(0x200000)): expected result to be a arithmetic nan, got 0x0000000000000000.
+conversions-main.c:1124: assertion failed: in Z_conversions_0Z_f64Z2Epromote_f32Z_df(-make_nan_f32(0x200000)): expected result to be a arithmetic nan, got 0x0000000000000000.
+During handling of the above exception, another exception occurred:
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 413, in <module>
+ sys.stderr.write(u'{0}\n'.format(e).encode('ascii', 'replace'))
+TypeError: write() argument must be str, not bytes
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-401/401 tests passed.
+399/401 tests passed.
```
Additionally, the following tests fail only on RHEL/CentOS 7 with gcc-4.8.5:
```
- test/wasm2c/spec/f32.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,3 @@
+Error running "out/test/wasm2c/spec/f32/f32":
+f32-main.c:7733: assertion failed: in Z_f32_0Z_nearestZ_ff(-make_nan_f32(0x200000)): expected result to be a arithmetic nan, got 0xffa00000.
+f32-main.c:7739: assertion failed: in Z_f32_0Z_nearestZ_ff(make_nan_f32(0x200000)): expected result to be a arithmetic nan, got 0x7fa00000.
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-2500/2500 tests passed.
+2498/2500 tests passed.
- test/wasm2c/spec/f64.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,3 @@
+Error running "out/test/wasm2c/spec/f64/f64":
+f64-main.c:7733: assertion failed: in Z_f64_0Z_nearestZ_dd(-make_nan_f64(0x4000000000000)): expected result to be a arithmetic nan, got 0x0000000000000000.
+f64-main.c:7739: assertion failed: in Z_f64_0Z_nearestZ_dd(make_nan_f64(0x4000000000000)): expected result to be a arithmetic nan, got 0x0000000000000000.
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-2500/2500 tests passed.
+2498/2500 tests passed.
```
|
test failures on POWER8 (ppc64le)
|
https://api.github.com/repos/WebAssembly/wabt/issues/1045/comments
| 9 |
2019-03-15T19:13:40Z
|
2023-06-16T14:01:34Z
|
https://github.com/WebAssembly/wabt/issues/1045
| 421,667,429 | 1,045 |
[
"WebAssembly",
"wabt"
] |
Running the 1.0.10 testsuite (`test/run-tests.py`) on x86 32bit (i686) yields the following failed tests:
```
- test/interp/unary.txt
STDOUT MISMATCH:
--- expected
+++ actual
@@ -21,7 +21,7 @@
f64_abs() => f64:100.000000
f64_sqrt_neg_is_nan() => i32:1
f64_sqrt_100() => f64:10.000000
-f64_ceil() => f64:-0.000000
+f64_ceil() => f64:0.000000
f64_floor() => f64:-1.000000
f64_trunc() => f64:-0.000000
f64_nearest_lo() => f64:1.000000
...
- test/wasm2c/spec/conversions.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,17 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 407, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 400, in main
+ forward_stdout=True).RunWithArgs()
+ File "/builddir/build/BUILD/wabt-1.0.10/test/utils.py", line 104, in RunWithArgs
+ raise error
+utils.Error: Error running "out/test/wasm2c/spec/conversions/conversions":
+conversions-main.c:1394: assertion failed: in Z_conversions_0Z_i32Z2Ereinterpret_f32Z_if(make_nan_f32(0x200000)): expected 2141192192, got 2145386496.
+conversions-main.c:1397: assertion failed: in Z_conversions_0Z_i32Z2Ereinterpret_f32Z_if(-make_nan_f32(0x200000)): expected 4288675840, got 4292870144.
+conversions-main.c:1439: assertion failed: in Z_conversions_0Z_i64Z2Ereinterpret_f64Z_jd(make_nan_f64(0x4000000000000)): expected 9219994337134247936, got 9222246136947933184.
+conversions-main.c:1442: assertion failed: in Z_conversions_0Z_i64Z2Ereinterpret_f64Z_jd(-make_nan_f64(0x4000000000000)): expected 18443366373989023744, got 18445618173802708992.
+During handling of the above exception, another exception occurred:
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 413, in <module>
+ sys.stderr.write(u'{0}\n'.format(e).encode('ascii', 'replace'))
+TypeError: write() argument must be str, not bytes
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-401/401 tests passed.
+397/401 tests passed.
- test/wasm2c/spec/float_literals.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,21 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 407, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 400, in main
+ forward_stdout=True).RunWithArgs()
+ File "/builddir/build/BUILD/wabt-1.0.10/test/utils.py", line 104, in RunWithArgs
+ raise error
+utils.Error: Error running "out/test/wasm2c/spec/float_literals/float_literals":
+float_literals-main.c:258: assertion failed: in Z_float_literals_0Z_f32Z2Einformally_known_as_plain_snanZ_iv(): expected 2141192192, got 2145386496.
+float_literals-main.c:264: assertion failed: in Z_float_literals_0Z_f32Z2Emisc_nanZ_iv(): expected 2139169605, got 2143363909.
+float_literals-main.c:267: assertion failed: in Z_float_literals_0Z_f32Z2Emisc_positive_nanZ_iv(): expected 2142257232, got 2146451536.
+float_literals-main.c:270: assertion failed: in Z_float_literals_0Z_f32Z2Emisc_negative_nanZ_iv(): expected 4289379550, got 4293573854.
+float_literals-main.c:351: assertion failed: in Z_float_literals_0Z_f64Z2Einformally_known_as_plain_snanZ_jv(): expected 9219994337134247936, got 9222246136947933184.
+float_literals-main.c:357: assertion failed: in Z_float_literals_0Z_f64Z2Emisc_nanZ_jv(): expected 9218888453225749180, got 9221140253039434428.
+float_literals-main.c:360: assertion failed: in Z_float_literals_0Z_f64Z2Emisc_positive_nanZ_jv(): expected 9219717281780008969, got 9221969081593694217.
+float_literals-main.c:363: assertion failed: in Z_float_literals_0Z_f64Z2Emisc_negative_nanZ_jv(): expected 18442992325002076997, got 18445244124815762245.
+During handling of the above exception, another exception occurred:
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 413, in <module>
+ sys.stderr.write(u'{0}\n'.format(e).encode('ascii', 'replace'))
+TypeError: write() argument must be str, not bytes
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-83/83 tests passed.
+75/83 tests passed.
- test/wasm2c/spec/float_memory.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,17 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 407, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 400, in main
+ forward_stdout=True).RunWithArgs()
+ File "/builddir/build/BUILD/wabt-1.0.10/test/utils.py", line 104, in RunWithArgs
+ raise error
+utils.Error: Error running "out/test/wasm2c/spec/float_memory/float_memory":
+float_memory-main.c:280: assertion failed: in Z_float_memory_0Z_i32Z2EloadZ_iv(): expected 2141192192, got 2145386496.
+float_memory-main.c:325: assertion failed: in Z_float_memory_1Z_i64Z2EloadZ_jv(): expected 9219994337134247936, got 9222246136947933184.
+float_memory-main.c:370: assertion failed: in Z_float_memory_2Z_i32Z2EloadZ_iv(): expected 2141192192, got 2145386496.
+float_memory-main.c:415: assertion failed: in Z_float_memory_3Z_i64Z2EloadZ_jv(): expected 9219994337134247936, got 9222246136947933184.
+During handling of the above exception, another exception occurred:
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 413, in <module>
+ sys.stderr.write(u'{0}\n'.format(e).encode('ascii', 'replace'))
+TypeError: write() argument must be str, not bytes
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-60/60 tests passed.
+56/60 tests passed.
- test/wasm2c/spec/float_misc.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,42 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 407, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 400, in main
+ forward_stdout=True).RunWithArgs()
+ File "/builddir/build/BUILD/wabt-1.0.10/test/utils.py", line 104, in RunWithArgs
+ raise error
+utils.Error: Error running "out/test/wasm2c/spec/float_misc/float_misc":
+float_misc-main.c:257: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(1, 1.1102230246251568e-16): expected 1.0000000000000002, got 1.
+float_misc-main.c:269: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(9.2233720368547758e+18, 1024.25): expected 9.2233720368547779e+18, got 9.2233720368547758e+18.
+float_misc-main.c:275: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(9007199254740992, 1.0000100000000001): expected 4.4501477170144047e-308, got 9007199254740992.
+float_misc-main.c:278: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(9007199254740994, 0.9999847412109375): expected 4.4501477170144047e-308, got 9007199254740996.
+float_misc-main.c:383: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(-2.1089660532788995e+242, 5.8148323342119634e+248): expected 5.8148302252459106e+248, got 5.8148302252459096e+248.
+float_misc-main.c:386: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(1.0231579266682148e+236, 4.5020430079749491e+224): expected 1.0231579266727168e+236, got 1.023157926672717e+236.
+float_misc-main.c:389: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(-1.3052997857095656e+188, 1.5489943422018657e+203): expected 1.5489943422018645e+203, got 1.5489943422018643e+203.
+float_misc-main.c:392: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(4.7629997434721684e+139, 4.5558645105825967e+155): expected 4.5558645105825967e+155, got 4.5558645105825976e+155.
+float_misc-main.c:395: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(3.9589525165584138e-300, 2.3092460710062946e-290): expected 2.30924607140219e-290, got 2.3092460714021897e-290.
+float_misc-main.c:491: assertion failed: in Z_float_misc_0Z_f64Z2EaddZ_ddd(1.7976931348623157e+308, 9.979201547673598e+291): expected 1.7976931348623157e+308, got inf.
+float_misc-main.c:512: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(1, 5.5511151231257839e-17): expected 0.99999999999999989, got 1.
+float_misc-main.c:605: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(5.8169880657930389e-24, 2.5021499241540866e-35): expected 5.8169880657680178e-24, got 5.816988065768017e-24.
+float_misc-main.c:608: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(4.3336683304809554e-296, 1.6945582607476316e-304): expected 4.3336683135353726e-296, got 4.3336683135353731e-296.
+float_misc-main.c:611: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(6.9080526763152571e-77, 1.2001773734799856e-60): expected -1.2001773734799856e-60, got -1.2001773734799854e-60.
+float_misc-main.c:614: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(-2.2044291547443813e-12, -2.7947429925618632e-21): expected -2.2044291519496381e-12, got -2.2044291519496385e-12.
+float_misc-main.c:617: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(4.0163935691177612e-08, 0.17053881989395447): expected -0.17053877973001877, got -0.1705387797300188.
+float_misc-main.c:701: assertion failed: in Z_float_misc_0Z_f64Z2EsubZ_ddd(1.7976931348623157e+308, 9.979201547673598e+291): expected 1.7976931348623157e+308, got 1.7976931348623155e+308.
+float_misc-main.c:728: assertion failed: in Z_float_misc_0Z_f64Z2EmulZ_ddd(1848874847, 19954562207): expected 3.6893488147419111e+19, got 3.6893488147419103e+19.
+float_misc-main.c:827: assertion failed: in Z_float_misc_0Z_f64Z2EmulZ_ddd(4.4091927284399547e-103, 1.1518840702296592e-173): expected 5.0788788664624316e-276, got 5.0788788664624308e-276.
+float_misc-main.c:830: assertion failed: in Z_float_misc_0Z_f64Z2EmulZ_ddd(-0.0029800418264724318, 6.3125412993218003e+217): expected -1.8811637103313594e+215, got -1.8811637103313598e+215.
+float_misc-main.c:833: assertion failed: in Z_float_misc_0Z_f64Z2EmulZ_ddd(-3.0834457808130011e+110, -1.0081049555008529e-196): expected 3.1084369716557833e-86, got 3.1084369716557829e-86.
+float_misc-main.c:836: assertion failed: in Z_float_misc_0Z_f64Z2EmulZ_ddd(3.4938750131567728e+233, 2.1313169159308099e+18): expected 7.4465549176890102e+251, got 7.4465549176890113e+251.
+float_misc-main.c:839: assertion failed: in Z_float_misc_0Z_f64Z2EmulZ_ddd(-1.2500108005100234e-83, 1.0352657041604675e+270): expected -1.294093311598199e+187, got -1.2940933115981991e+187.
+float_misc-main.c:1055: assertion failed: in Z_float_misc_0Z_f64Z2EdivZ_ddd(-2.0395956046834761e+176, -7.4740887394612257e+58): expected 2.7288886656040712e+117, got 2.7288886656040717e+117.
+float_misc-main.c:1058: assertion failed: in Z_float_misc_0Z_f64Z2EdivZ_ddd(-3.0426171229468766e+164, -2.6556792326588243e+99): expected 1.1457020432022042e+65, got 1.145702043202204e+65.
+float_misc-main.c:1061: assertion failed: in Z_float_misc_0Z_f64Z2EdivZ_ddd(4.9235240512480726e+55, -3.6634082831003669e+290): expected -1.3439736089369927e-235, got -1.3439736089369929e-235.
+float_misc-main.c:1064: assertion failed: in Z_float_misc_0Z_f64Z2EdivZ_ddd(2.8926084355634162e+65, 5.1719487583733548e+128): expected 5.5928791461444777e-64, got 5.5928791461444784e-64.
+float_misc-main.c:1067: assertion failed: in Z_float_misc_0Z_f64Z2EdivZ_ddd(-4.2154258234426861e+248, 1.4285058546706491e+105): expected -2.9509335293656034e+143, got -2.950933529365603e+143.
+float_misc-main.c:1217: assertion failed: in Z_float_misc_0Z_f64Z2EdivZ_ddd(1, 0.99999999999999989): expected 1.0000000000000002, got 1.
+During handling of the above exception, another exception occurred:
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 413, in <module>
+ sys.stderr.write(u'{0}\n'.format(e).encode('ascii', 'replace'))
+TypeError: write() argument must be str, not bytes
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-440/440 tests passed.
+411/440 tests passed.
- test/wasm2c/spec/float_exprs.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,17 @@
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 407, in <module>
+ sys.exit(main(sys.argv[1:]))
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 400, in main
+ forward_stdout=True).RunWithArgs()
+ File "/builddir/build/BUILD/wabt-1.0.10/test/utils.py", line 104, in RunWithArgs
+ raise error
+utils.Error: Error running "out/test/wasm2c/spec/float_exprs/float_exprs":
+float_exprs-main.c:3133: assertion failed: in Z_float_exprs_87Z_f32Z2Enonarithmetic_nan_bitpatternZ_ii(2139107856u): expected 4286591504, got 4290785808.
+float_exprs-main.c:3136: assertion failed: in Z_float_exprs_87Z_f32Z2Enonarithmetic_nan_bitpatternZ_ii(4286591504u): expected 2139107856, got 2143302160.
+float_exprs-main.c:3163: assertion failed: in Z_float_exprs_87Z_f64Z2Enonarithmetic_nan_bitpatternZ_jj(9218868437227418128ull): expected 18442240474082193936, got 18444492273895879184.
+float_exprs-main.c:3166: assertion failed: in Z_float_exprs_87Z_f64Z2Enonarithmetic_nan_bitpatternZ_jj(18442240474082193936ull): expected 9218868437227418128, got 9221120237041103376.
+During handling of the above exception, another exception occurred:
+Traceback (most recent call last):
+ File "/builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py", line 413, in <module>
+ sys.stderr.write(u'{0}\n'.format(e).encode('ascii', 'replace'))
+TypeError: write() argument must be str, not bytes
STDOUT MISMATCH:
--- expected
+++ actual
@@ -1 +1 @@
-794/794 tests passed.
+790/794 tests passed.
...
**** FAILED ******************************************************************
- test/interp/unary.txt
/builddir/build/BUILD/wabt-1.0.10/bin/wasm-interp out/test/interp/unary/unary.wasm --run-all-exports
- test/wasm2c/spec/conversions.txt
/usr/bin/python3 /builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py out/test/wasm2c/spec/conversions.wast --bindir=/builddir/build/BUILD/wabt-1.0.10/bin --no-error-cmdline -o out/test/wasm2c/spec/conversions
- test/wasm2c/spec/float_literals.txt
/usr/bin/python3 /builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py out/test/wasm2c/spec/float_literals.wast --bindir=/builddir/build/BUILD/wabt-1.0.10/bin --no-error-cmdline -o out/test/wasm2c/spec/float_literals
- test/wasm2c/spec/float_memory.txt
/usr/bin/python3 /builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py out/test/wasm2c/spec/float_memory.wast --bindir=/builddir/build/BUILD/wabt-1.0.10/bin --no-error-cmdline -o out/test/wasm2c/spec/float_memory
- test/wasm2c/spec/float_misc.txt
/usr/bin/python3 /builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py out/test/wasm2c/spec/float_misc.wast --bindir=/builddir/build/BUILD/wabt-1.0.10/bin --no-error-cmdline -o out/test/wasm2c/spec/float_misc
- test/wasm2c/spec/float_exprs.txt
/usr/bin/python3 /builddir/build/BUILD/wabt-1.0.10/test/run-spec-wasm2c.py out/test/wasm2c/spec/float_exprs.wast --bindir=/builddir/build/BUILD/wabt-1.0.10/bin --no-error-cmdline -o out/test/wasm2c/spec/float_exprs
```
I suspect all but the first are due to lower float precision.
|
test failures on x86 32bit (i686)
|
https://api.github.com/repos/WebAssembly/wabt/issues/1044/comments
| 22 |
2019-03-15T15:38:56Z
|
2023-07-26T07:28:19Z
|
https://github.com/WebAssembly/wabt/issues/1044
| 421,580,529 | 1,044 |
[
"WebAssembly",
"wabt"
] |
Running the testsuite from 1.0.10 on ARM (armv7hl and aarch64) and POWER8 (ppc64le) fails:
```
- test/interp/simd-unary.txt
STDOUT MISMATCH:
--- expected
+++ actual
@@ -25,8 +25,8 @@
f32x4_abs_0() => v128:0x00000000 0x7fc00000 0x449a5000 0x3f800000
f64x2_abs_0() => v128:0x00000000 0x00000000 0x00000000 0x7ff80000
f64x2_abs_1() => v128:0x00000000 0x40934a00 0x00000000 0x3ff00000
-f32x4_sqrt_0() => v128:0xffc00000 0xffc00000 0x40000000 0x40400000
-f64x2_sqrt_0() => v128:0x00000000 0xfff80000 0x00000000 0xfff80000
+f32x4_sqrt_0() => v128:0x7fc00000 0xffc00000 0x40000000 0x40400000
+f64x2_sqrt_0() => v128:0x00000000 0x7ff80000 0x00000000 0xfff80000
f64x2_sqrt_1() => v128:0x00000000 0x40000000 0x00000000 0x40080000
f32x4_convert_i32x4_s_0() => v128:0x3f800000 0xbf800000 0x00000000 0x40400000
f32x4_convert_i32x4_u_0() => v128:0x3f800000 0x40000000 0x00000000 0x40400000
...
**** FAILED ******************************************************************
- test/interp/simd-unary.txt
/builddir/build/BUILD/wabt-1.0.10/bin/wasm-interp out/test/interp/simd-unary/simd-unary.wasm --run-all-exports --enable-simd
```
This is the only failing test on ARM.
There are more test failures on POWER8 (ppc64le) and other architectures, but I'll open separate issues for that.
|
test/interp/simd-unary.txt fails on ARM and POWER8
|
https://api.github.com/repos/WebAssembly/wabt/issues/1043/comments
| 3 |
2019-03-15T13:25:04Z
|
2019-04-15T18:01:09Z
|
https://github.com/WebAssembly/wabt/issues/1043
| 421,517,384 | 1,043 |
[
"WebAssembly",
"wabt"
] |
When configuring the build (1.0.10) with cmake 2.8, I get the following error:
```
-- Using prebuilt re2c lexer
CMake Error at CMakeLists.txt:281 (cmake_parse_arguments):
Unknown CMake command "cmake_parse_arguments".
Call Stack (most recent call first):
CMakeLists.txt:311 (wabt_executable)
-- Configuring incomplete, errors occurred!
```
The following patch fixes this:
``` diff
diff -up wabt-1.0.10/CMakeLists.txt.orig wabt-1.0.10/CMakeLists.txt
--- wabt-1.0.10/CMakeLists.txt.orig 2019-03-07 01:41:26.000000000 +0100
+++ wabt-1.0.10/CMakeLists.txt 2019-03-15 10:43:39.046455124 +0100
@@ -277,6 +277,7 @@ if (NOT EMSCRIPTEN)
endif ()
endif ()
+ include(CMakeParseArguments)
function(wabt_executable)
cmake_parse_arguments(EXE "WITH_LIBM;INSTALL" "NAME" "SOURCES;LIBS" ${ARGN})
```
|
Unknown CMake command "cmake_parse_arguments" with cmake 2.8
|
https://api.github.com/repos/WebAssembly/wabt/issues/1042/comments
| 2 |
2019-03-15T10:52:42Z
|
2019-09-12T08:46:49Z
|
https://github.com/WebAssembly/wabt/issues/1042
| 421,460,505 | 1,042 |
[
"WebAssembly",
"wabt"
] |
how to run wabt VM in intel SGX
|
how to run wabt VM in intel SGX
|
https://api.github.com/repos/WebAssembly/wabt/issues/1040/comments
| 2 |
2019-03-09T20:41:50Z
|
2019-03-18T07:07:37Z
|
https://github.com/WebAssembly/wabt/issues/1040
| 419,113,426 | 1,040 |
[
"WebAssembly",
"wabt"
] |
Due to the way my WASM code is generated, I have code bodies that explicitly list 0 locals of a certain type. It seems the binary reader (intentionally) fails on this:
error: local count must be > 0
Is there a reason why this restriction is there? I couldn't immediately find something in the spec that constrains this, and tools like `wasm-dis` don't seem to mind (and neither do the engines).
|
Binary reader errors on local count > 0
|
https://api.github.com/repos/WebAssembly/wabt/issues/1038/comments
| 1 |
2019-03-08T20:38:15Z
|
2019-03-18T19:36:39Z
|
https://github.com/WebAssembly/wabt/issues/1038
| 418,948,712 | 1,038 |
[
"WebAssembly",
"wabt"
] |
I saw parser tests allow `--enable-reference-types` but current version of wat2wasm it seems not support this flag?
Also this missing in [online version](https://webassembly.github.io/wabt/demo/wat2wasm/)
|
wat2wasm with reference types
|
https://api.github.com/repos/WebAssembly/wabt/issues/1035/comments
| 3 |
2019-03-06T11:27:10Z
|
2019-03-07T09:05:18Z
|
https://github.com/WebAssembly/wabt/issues/1035
| 417,755,734 | 1,035 |
[
"WebAssembly",
"wabt"
] |
The command line tools behave differently than the [web demos](https://webassembly.github.io/wabt/demo/) because the demos haven't been updated with the great renaming https://github.com/WebAssembly/wabt/pull/985
|
libwabt.js on gh-pages branch needs updating
|
https://api.github.com/repos/WebAssembly/wabt/issues/1024/comments
| 1 |
2019-02-21T19:09:44Z
|
2019-02-21T19:23:28Z
|
https://github.com/WebAssembly/wabt/issues/1024
| 413,079,453 | 1,024 |
[
"WebAssembly",
"wabt"
] |
At the https://github.com/WebAssembly/wabt/blob/master/src/wabt.post.js#L151 it uses "Pointer_stringify" function, which has been deprecated. See https://github.com/emscripten-core/emscripten/pull/8011
This prevents using the wabt demo with newly built libwabt.js. Thanks!
|
Deprecated function Pointer_stringify used
|
https://api.github.com/repos/WebAssembly/wabt/issues/1020/comments
| 1 |
2019-02-19T22:28:23Z
|
2019-02-20T00:40:51Z
|
https://github.com/WebAssembly/wabt/issues/1020
| 412,154,519 | 1,020 |
[
"WebAssembly",
"wabt"
] |
Edit: solution presented here is incorrect. In some cases the relocation offset is wrong, but not all.
When using the following code with `wat2wasm`:
```
(module
(type $t0 (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) ))
(type $t1 (func (result i32)))
(type $t2 (func ))
(import "env" "caml_program" (func $caml_program (type 1)))
(import "env" "heap_base" (global $__heap_base i32))
(global $caml_young_base (mut i32) (i32.const 0))
(global $caml_young_start (mut i32) (i32.const 0))
(global $caml_young_end (mut i32) (i32.const 0))
(global $caml_young_alloc_start (mut i32) (i32.const 0))
(global $caml_young_alloc_mid (mut i32) (i32.const 0))
(global $caml_young_alloc_end (mut i32) (i32.const 0))
(global $caml_young_trigger (mut i32) (i32.const 0))
(global $caml_young_limit (mut i32) (i32.const 0))
(global $caml_young_ptr (mut i32) (i32.const 0))
(global $caml_minor_heap_wsz (mut i32) (i32.const 0))
(func $caml_init_gc (export "caml_init_gc")
(param $caml_init_minor_heap_wsz i32)
(param $caml_init_heap_wsz i32)
(param $caml_init_heap_chunk_sz i32)
(param $caml_init_percent_free i32)
(param $caml_init_max_percent_free i32)
(param $caml_init_major_window i32)
get_local $caml_init_minor_heap_wsz
call $caml_set_minor_heap_size
)
(func $caml_set_minor_heap_size (export "caml_set_minor_heap_size")
(param $bsz i32)
get_global $__heap_base
set_global $caml_young_base
get_global $__heap_base
set_global $caml_young_start
get_global $__heap_base
get_local $bsz
i32.add
set_global $caml_young_end
get_global $caml_young_start
set_global $caml_young_alloc_start
get_global $caml_young_alloc_start
get_local $bsz
i32.const 8
i32.div_u
i32.add
set_global $caml_young_alloc_mid
get_global $caml_young_end
set_global $caml_young_alloc_end
get_global $caml_young_alloc_start
set_global $caml_young_trigger
get_global $caml_young_trigger
set_global $caml_young_limit
get_global $caml_young_alloc_end
set_global $caml_young_ptr
get_local $bsz
i32.const 4
i32.div_u
set_global $caml_minor_heap_wsz
)
(func $caml_main
i32.const 262144 ;; caml_init_minor_heap_wsz
i32.const 126976 ;; caml_init_heap_wsz
i32.const 15 ;; caml_init_heap_chunk_sz
i32.const 80 ;; caml_init_percent_free
i32.const 500 ;; caml_init_max_percent_free
i32.const 1 ;; caml_init_major_window
call $caml_init_gc
call $caml_program
drop
)
(func $_start (export "_start") (type 2)
call $caml_main
)
(func $pleh (export "pleh") (type 2)
call $_start
)
)
```
I got `bad relocation offset` errors.
After inspecting with `wasm-objdump` it seems that the relocations are off by 2. When I add 2 to `last_section_payload_offset_` in binary_writer.cc it seems to work correctly.
|
Relocations seem to be off by 2
|
https://api.github.com/repos/WebAssembly/wabt/issues/1018/comments
| 2 |
2019-02-19T07:43:18Z
|
2019-02-19T11:41:16Z
|
https://github.com/WebAssembly/wabt/issues/1018
| 411,787,008 | 1,018 |
[
"WebAssembly",
"wabt"
] |
The real objcopy is the ultimate swiss army knife tool and we don't want to emulate all of its feature but we we probably want to be able to such as
- Extracting/dumping selected section(s)
- Replacing sections
- Stripping sections
See `objcopy` options: `--remove-section`, `--add-section`, `--update-section`, `--rename-section`
https://linux.die.net/man/1/objcopyhttps://linux.die.net/man/1/objcopy
|
Create `wasm-objcopy` tool for manipulating wasm binary files
|
https://api.github.com/repos/WebAssembly/wabt/issues/1015/comments
| 1 |
2019-02-12T18:51:25Z
|
2020-03-20T20:35:36Z
|
https://github.com/WebAssembly/wabt/issues/1015
| 409,448,329 | 1,015 |
[
"WebAssembly",
"wabt"
] |
The [dylink section](https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md) says
> The "dylink" section should be the very first section in the module; this allows detection of whether a binary is a dynamic library without having to scan the entire contents.
It looks like wabt does not preserve that order. I'm not sure if this is a bug or whether the dylink section spec is out of date?
|
Order of dylink section?
|
https://api.github.com/repos/WebAssembly/wabt/issues/1011/comments
| 1 |
2019-02-11T18:26:05Z
|
2019-02-11T19:28:57Z
|
https://github.com/WebAssembly/wabt/issues/1011
| 408,915,440 | 1,011 |
[
"WebAssembly",
"wabt"
] |
When I run `wasm-opt -O3 myfile.wasm`, I get no error and no output, but `myfile.wasm` stays the same. This lead me to believe that these files had already been properly optimized.
Then @kripken told me that I had to specify an output file like this: `wasm-opt -O3 -o myfile2.wasm myfile.wasm`.
I think a no-op like my first command should error.
|
`wasm-opt -O <file>` should throw an error
|
https://api.github.com/repos/WebAssembly/wabt/issues/1008/comments
| 2 |
2019-02-08T20:05:51Z
|
2019-02-08T21:44:59Z
|
https://github.com/WebAssembly/wabt/issues/1008
| 408,304,556 | 1,008 |
[
"WebAssembly",
"wabt"
] |
Instead it looks like it supports and old version of the proposal based on a custom section.
This makes it hard when working with llvm output which uses the latest spec proposal (i.e. a new known section '13').
I started down the road of converting it but god pretty bogged down
|
wabt does not support the new binary format for exceptions
|
https://api.github.com/repos/WebAssembly/wabt/issues/1006/comments
| 2 |
2019-02-06T22:56:56Z
|
2019-03-09T01:05:19Z
|
https://github.com/WebAssembly/wabt/issues/1006
| 407,469,589 | 1,006 |
[
"WebAssembly",
"wabt"
] |
We discovered that the `wast2json` and `spectest-interp` tools in this repository were perfect for our use case of trying to execute wasm spec tests, as they did all the heavy lifting of figuring out what to do where! (and made it so we didn't have to write a wast parser)
We noticed, however, that we mistakenly thought all spec tests were passing when there were actually a number of failures. We originally thought that an exit code of zero from `spectest-interp` indicated success, but we actually needed to also check for `X/Y tests passed.` and make sure `X` equals `Y`.
Would it be possible to update the `spectest-interp` tool to exit with a nonzero exit status if any tests failed? That'd at least make the checking a bit easier on our end and hopefully more future-proof for others!
|
Exit code of spectest-interp
|
https://api.github.com/repos/WebAssembly/wabt/issues/1002/comments
| 3 |
2019-02-01T21:48:14Z
|
2019-02-02T18:12:11Z
|
https://github.com/WebAssembly/wabt/issues/1002
| 405,886,554 | 1,002 |
[
"WebAssembly",
"wabt"
] |
Would it be possible to include sha256 files for the Windows zip files? Specifically, this would make it easier to integrate with the [Scoop](https://github.com/lukesampson/scoop) package manager.
|
sha256 files for Windows releases?
|
https://api.github.com/repos/WebAssembly/wabt/issues/995/comments
| 2 |
2019-01-16T07:38:14Z
|
2019-01-16T16:27:25Z
|
https://github.com/WebAssembly/wabt/issues/995
| 399,682,696 | 995 |
[
"WebAssembly",
"wabt"
] |
ke ..
|
https://api.github.com/repos/WebAssembly/wabt/issues/994/comments
| 0 |
2019-01-11T14:32:28Z
|
2019-01-16T05:56:16Z
|
https://github.com/WebAssembly/wabt/issues/994
| 398,312,756 | 994 |
|
[
"WebAssembly",
"wabt"
] |
Update: In another place in the docs, it says to manually create a "build" folder and run "cmake .." from there. This seems to work. I did not keep track of where I found "cmake ." in the toplevel folder, unfortunately.
Bottom line:
* The manual specifies multiple "recipes" for building wabt which work or don't work. It should specify a single recipe that "just works".
* The statement that make just invokes cmake is wrong. If that were the case, it would at least have the same effect (even though just running cmake, then make is the wrong way, too).
* The fact that one must run cmake from a manually created new build folder is unintuitive, and above all, it should stop with a clear error message if running from the wrong folder. (It is unintuitive because, although the project folder is specified explicitly, it still affects the build what the current working directory is).
* It is worrying that, although all this affects folders inside the project folder specified using relative paths, the exact behavior is different depending on the platform.
------------------------------------------------------------------------------------------
The build process is broken on Mac OS X 10.11.6 (can't try newer a OSX version since it won't install due to old graphics hardware).
I first tried:
```
git clone https://github.com/WebAssembly/wabt.git
cd wabt
make
```
Output:
```
martin: ~/git-repos/wabt > make
mkdir -p out/clang/Debug/
cd out/clang/Debug/ && cmake -G "Unix Makefiles" /Users/martin/git-repos/wabt/ -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=Debug
-- The C compiler identification is Clang 6.0.1
-- The CXX compiler identification is Clang 6.0.1
-- Check for working C compiler: /Users/martin/git-repos/emsdk/clang/e1.38.21_64bit/clang
-- Check for working C compiler: /Users/martin/git-repos/emsdk/clang/e1.38.21_64bit/clang -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /Users/martin/git-repos/emsdk/clang/e1.38.21_64bit/clang++
-- Check for working CXX compiler: /Users/martin/git-repos/emsdk/clang/e1.38.21_64bit/clang++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Looking for alloca.h
-- Looking for alloca.h - found
-- Looking for unistd.h
-- Looking for unistd.h - found
-- Looking for snprintf
-- Looking for snprintf - found
-- Looking for sysconf
-- Looking for sysconf - found
-- Looking for strcasecmp
-- Looking for strcasecmp - found
-- Looking for sys/types.h
-- Looking for sys/types.h - found
-- Looking for stdint.h
-- Looking for stdint.h - found
-- Looking for stddef.h
-- Looking for stddef.h - found
-- Check size of ssize_t
-- Check size of ssize_t - done
-- Check size of size_t
-- Check size of size_t - done
-- Using prebuilt re2c lexer
-- Looking for pthread.h
-- Looking for pthread.h - found
-- Looking for pthread_create
-- Looking for pthread_create - found
-- Found Threads: TRUE
-- Found PythonInterp: /usr/bin/python2.7 (found suitable version "2.7.10", minimum required is "2.7")
-- Configuring done
-- Generating done
-- Build files have been written to: /Users/martin/git-repos/wabt/out/clang/Debug
/Library/Developer/CommandLineTools/usr/bin/make --no-print-directory -C out/clang/Debug/ all
Scanning dependencies of target wabt
[ 1%] Building CXX object CMakeFiles/wabt.dir/src/apply-names.cc.o
In file included from /Users/martin/git-repos/wabt/src/apply-names.cc:17:
In file included from /Users/martin/git-repos/wabt/src/apply-names.h:20:
/Users/martin/git-repos/wabt/src/common.h:20:10: fatal error: 'algorithm' file not found
#include <algorithm>
^~~~~~~~~~~
1 error generated.
make[3]: *** [CMakeFiles/wabt.dir/src/apply-names.cc.o] Error 1
make[2]: *** [CMakeFiles/wabt.dir/all] Error 2
make[1]: *** [all] Error 2
make: *** [clang-debug] Error 2
martin: ~/git-repos/wabt >
```
Cleanup and try with cmake, then make:
```
git reset --hard
git clean -df
git status
cmake .
make
```
Output:
```
martin: ~/git-repos/wabt > cmake .
-- The C compiler identification is AppleClang 8.0.0.8000042
-- The CXX compiler identification is AppleClang 8.0.0.8000042
-- Check for working C compiler: /Library/Developer/CommandLineTools/usr/bin/cc
-- Check for working C compiler: /Library/Developer/CommandLineTools/usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /Library/Developer/CommandLineTools/usr/bin/c++
-- Check for working CXX compiler: /Library/Developer/CommandLineTools/usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Looking for alloca.h
-- Looking for alloca.h - found
-- Looking for unistd.h
-- Looking for unistd.h - found
-- Looking for snprintf
-- Looking for snprintf - found
-- Looking for sysconf
-- Looking for sysconf - found
-- Looking for strcasecmp
-- Looking for strcasecmp - found
-- Looking for sys/types.h
-- Looking for sys/types.h - found
-- Looking for stdint.h
-- Looking for stdint.h - found
-- Looking for stddef.h
-- Looking for stddef.h - found
-- Check size of ssize_t
-- Check size of ssize_t - done
-- Check size of size_t
-- Check size of size_t - done
-- Using prebuilt re2c lexer
-- Looking for pthread.h
-- Looking for pthread.h - found
-- Looking for pthread_create
-- Looking for pthread_create - found
-- Found Threads: TRUE
-- Found PythonInterp: /usr/bin/python2.7 (found suitable version "2.7.10", minimum required is "2.7")
-- Configuring done
-- Generating done
-- Build files have been written to: /Users/martin/git-repos/wabt
martin: ~/git-repos/wabt > make
Scanning dependencies of target wabt
[ 1%] Building CXX object CMakeFiles/wabt.dir/src/apply-names.cc.o
[ 2%] Building CXX object CMakeFiles/wabt.dir/src/binary.cc.o
[ 3%] Building CXX object CMakeFiles/wabt.dir/src/binary-reader.cc.o
[ 4%] Building CXX object CMakeFiles/wabt.dir/src/binary-reader-ir.cc.o
[ 6%] Building CXX object CMakeFiles/wabt.dir/src/binary-reader-logging.cc.o
[ 7%] Building CXX object CMakeFiles/wabt.dir/src/binary-writer.cc.o
[ 8%] Building CXX object CMakeFiles/wabt.dir/src/binary-writer-spec.cc.o
[ 9%] Building CXX object CMakeFiles/wabt.dir/src/binding-hash.cc.o
[ 10%] Building CXX object CMakeFiles/wabt.dir/src/color.cc.o
[ 12%] Building CXX object CMakeFiles/wabt.dir/src/common.cc.o
[ 13%] Building CXX object CMakeFiles/wabt.dir/src/config.cc.o
[ 14%] Building CXX object CMakeFiles/wabt.dir/src/error-formatter.cc.o
[ 15%] Building CXX object CMakeFiles/wabt.dir/src/expr-visitor.cc.o
[ 16%] Building CXX object CMakeFiles/wabt.dir/src/feature.cc.o
[ 18%] Building CXX object CMakeFiles/wabt.dir/src/filenames.cc.o
[ 19%] Building CXX object CMakeFiles/wabt.dir/src/generate-names.cc.o
[ 20%] Building CXX object CMakeFiles/wabt.dir/src/hash-util.cc.o
[ 21%] Building CXX object CMakeFiles/wabt.dir/src/ir.cc.o
[ 22%] Building CXX object CMakeFiles/wabt.dir/src/leb128.cc.o
[ 24%] Building CXX object CMakeFiles/wabt.dir/src/lexer-source.cc.o
[ 25%] Building CXX object CMakeFiles/wabt.dir/src/lexer-source-line-finder.cc.o
[ 26%] Building CXX object CMakeFiles/wabt.dir/src/literal.cc.o
[ 27%] Building CXX object CMakeFiles/wabt.dir/src/opcode.cc.o
[ 28%] Building C object CMakeFiles/wabt.dir/src/opcode-code-table.c.o
[ 30%] Building CXX object CMakeFiles/wabt.dir/src/option-parser.cc.o
[ 31%] Building CXX object CMakeFiles/wabt.dir/src/resolve-names.cc.o
[ 32%] Building CXX object CMakeFiles/wabt.dir/src/stream.cc.o
[ 33%] Building CXX object CMakeFiles/wabt.dir/src/string-view.cc.o
[ 34%] Building CXX object CMakeFiles/wabt.dir/src/token.cc.o
[ 36%] Building CXX object CMakeFiles/wabt.dir/src/tracing.cc.o
[ 37%] Building CXX object CMakeFiles/wabt.dir/src/type-checker.cc.o
[ 38%] Building CXX object CMakeFiles/wabt.dir/src/utf8.cc.o
[ 39%] Building CXX object CMakeFiles/wabt.dir/src/validator.cc.o
[ 40%] Building CXX object CMakeFiles/wabt.dir/src/wast-parser.cc.o
[ 42%] Building CXX object CMakeFiles/wabt.dir/src/wat-writer.cc.o
[ 43%] Building CXX object CMakeFiles/wabt.dir/src/prebuilt/wast-lexer-gen.cc.o
[ 44%] Building CXX object CMakeFiles/wabt.dir/src/interp/binary-reader-interp.cc.o
[ 45%] Building CXX object CMakeFiles/wabt.dir/src/interp/interp.cc.o
[ 46%] Building CXX object CMakeFiles/wabt.dir/src/interp/interp-disassemble.cc.o
[ 48%] Building CXX object CMakeFiles/wabt.dir/src/interp/interp-trace.cc.o
[ 49%] Linking CXX static library libwabt.a
/Library/Developer/CommandLineTools/usr/bin/ranlib: file: libwabt.a(config.cc.o) has no symbols
/Library/Developer/CommandLineTools/usr/bin/ranlib: file: libwabt.a(config.cc.o) has no symbols
[ 49%] Built target wabt
Scanning dependencies of target libgtest
[ 50%] Building CXX object CMakeFiles/libgtest.dir/third_party/gtest/googletest/src/gtest-all.cc.o
[ 51%] Linking CXX static library liblibgtest.a
[ 51%] Built target libgtest
Scanning dependencies of target hexfloat_test
[ 53%] Building CXX object CMakeFiles/hexfloat_test.dir/src/literal.cc.o
[ 54%] Building CXX object CMakeFiles/hexfloat_test.dir/src/test-hexfloat.cc.o
[ 55%] Building CXX object CMakeFiles/hexfloat_test.dir/third_party/gtest/googletest/src/gtest_main.cc.o
[ 56%] Linking CXX executable hexfloat_test
[ 56%] Built target hexfloat_test
Scanning dependencies of target wasm-validate
[ 57%] Building CXX object CMakeFiles/wasm-validate.dir/src/tools/wasm-validate.cc.o
[ 59%] Linking CXX executable wasm-validate
[ 59%] Built target wasm-validate
Scanning dependencies of target wasm-validate-copy-to-bin
[ 59%] Built target wasm-validate-copy-to-bin
Scanning dependencies of target wasm-interp
[ 60%] Building CXX object CMakeFiles/wasm-interp.dir/src/tools/wasm-interp.cc.o
[ 61%] Linking CXX executable wasm-interp
[ 61%] Built target wasm-interp
Scanning dependencies of target wasm-strip
[ 62%] Building CXX object CMakeFiles/wasm-strip.dir/src/tools/wasm-strip.cc.o
[ 63%] Linking CXX executable wasm-strip
[ 63%] Built target wasm-strip
Scanning dependencies of target wasm-strip-copy-to-bin
[ 63%] Built target wasm-strip-copy-to-bin
Scanning dependencies of target wat-desugar
[ 65%] Building CXX object CMakeFiles/wat-desugar.dir/src/tools/wat-desugar.cc.o
[ 66%] Linking CXX executable wat-desugar
[ 66%] Built target wat-desugar
Scanning dependencies of target spectest-interp
[ 67%] Building CXX object CMakeFiles/spectest-interp.dir/src/tools/spectest-interp.cc.o
[ 68%] Linking CXX executable spectest-interp
[ 68%] Built target spectest-interp
Scanning dependencies of target wat2wasm
[ 69%] Building CXX object CMakeFiles/wat2wasm.dir/src/tools/wat2wasm.cc.o
[ 71%] Linking CXX executable wat2wasm
[ 71%] Built target wat2wasm
Scanning dependencies of target wasm-interp-copy-to-bin
[ 71%] Built target wasm-interp-copy-to-bin
Scanning dependencies of target wast2json
[ 72%] Building CXX object CMakeFiles/wast2json.dir/src/tools/wast2json.cc.o
[ 73%] Linking CXX executable wast2json
[ 73%] Built target wast2json
Scanning dependencies of target wast2json-copy-to-bin
[ 73%] Built target wast2json-copy-to-bin
Scanning dependencies of target wat-desugar-copy-to-bin
[ 73%] Built target wat-desugar-copy-to-bin
Scanning dependencies of target wasm-objdump
[ 74%] Building CXX object CMakeFiles/wasm-objdump.dir/src/tools/wasm-objdump.cc.o
[ 75%] Building CXX object CMakeFiles/wasm-objdump.dir/src/binary-reader-objdump.cc.o
[ 77%] Linking CXX executable wasm-objdump
[ 77%] Built target wasm-objdump
Scanning dependencies of target wasm-objdump-copy-to-bin
[ 77%] Built target wasm-objdump-copy-to-bin
Scanning dependencies of target wabt-unittests
[ 78%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-binary-reader.cc.o
[ 79%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-circular-array.cc.o
[ 80%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-interp.cc.o
[ 81%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-intrusive-list.cc.o
[ 83%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-literal.cc.o
[ 84%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-string-view.cc.o
[ 85%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-filenames.cc.o
[ 86%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-utf8.cc.o
[ 87%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-wast-parser.cc.o
[ 89%] Building CXX object CMakeFiles/wabt-unittests.dir/third_party/gtest/googletest/src/gtest_main.cc.o
[ 90%] Linking CXX executable wabt-unittests
[ 90%] Built target wabt-unittests
Scanning dependencies of target wasm2c
[ 91%] Building CXX object CMakeFiles/wasm2c.dir/src/tools/wasm2c.cc.o
[ 92%] Building CXX object CMakeFiles/wasm2c.dir/src/c-writer.cc.o
[ 93%] Linking CXX executable wasm2c
ld: can't open output file for writing: wasm2c, errno=21 for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [wasm2c] Error 1
make[1]: *** [CMakeFiles/wasm2c.dir/all] Error 2
make: *** [all] Error 2
martin: ~/git-repos/wabt >
```
Better, but still not there. I tried what the errors suggested but the following message is wrong:
```
clang: error: linker command failed with exit code 1 (use -v to see invocation)
```
That produces:
```
martin: ~/git-repos/wabt > make -v
GNU Make 3.81
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
This program built for i386-apple-darwin11.3.0
martin: ~/git-repos/wabt >
```
The correct option would be -n:
```
martin: ~/git-repos/wabt > make -n
/Applications/CMake.app/Contents/bin/cmake -S/Users/martin/git-repos/wabt -B/Users/martin/git-repos/wabt --check-build-system CMakeFiles/Makefile.cmake 0
/Applications/CMake.app/Contents/bin/cmake -E cmake_progress_start /Users/martin/git-repos/wabt/CMakeFiles /Users/martin/git-repos/wabt/CMakeFiles/progress.marks
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/Makefile2 all
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wabt.dir/build.make CMakeFiles/wabt.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wabt.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wabt.dir/build.make CMakeFiles/wabt.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49 "Built target wabt"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/libgtest.dir/build.make CMakeFiles/libgtest.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/libgtest.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/libgtest.dir/build.make CMakeFiles/libgtest.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=5,6 "Built target libgtest"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/hexfloat_test.dir/build.make CMakeFiles/hexfloat_test.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/hexfloat_test.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/hexfloat_test.dir/build.make CMakeFiles/hexfloat_test.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=1,2,3,4 "Built target hexfloat_test"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-validate.dir/build.make CMakeFiles/wasm-validate.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-validate.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-validate.dir/build.make CMakeFiles/wasm-validate.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=71,72 "Built target wasm-validate"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-validate-copy-to-bin.dir/build.make CMakeFiles/wasm-validate-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-validate-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-validate-copy-to-bin.dir/build.make CMakeFiles/wasm-validate-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wasm-validate /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wasm-validate-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-interp.dir/build.make CMakeFiles/wasm-interp.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-interp.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-interp.dir/build.make CMakeFiles/wasm-interp.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=61,62 "Built target wasm-interp"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-strip.dir/build.make CMakeFiles/wasm-strip.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-strip.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-strip.dir/build.make CMakeFiles/wasm-strip.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=69,70 "Built target wasm-strip"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-strip-copy-to-bin.dir/build.make CMakeFiles/wasm-strip-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-strip-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-strip-copy-to-bin.dir/build.make CMakeFiles/wasm-strip-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wasm-strip /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wasm-strip-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wat-desugar.dir/build.make CMakeFiles/wat-desugar.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wat-desugar.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wat-desugar.dir/build.make CMakeFiles/wat-desugar.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=80,81 "Built target wat-desugar"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/spectest-interp.dir/build.make CMakeFiles/spectest-interp.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/spectest-interp.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/spectest-interp.dir/build.make CMakeFiles/spectest-interp.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=7,8 "Built target spectest-interp"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wat2wasm.dir/build.make CMakeFiles/wat2wasm.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wat2wasm.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wat2wasm.dir/build.make CMakeFiles/wat2wasm.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=82,83 "Built target wat2wasm"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-interp-copy-to-bin.dir/build.make CMakeFiles/wasm-interp-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-interp-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-interp-copy-to-bin.dir/build.make CMakeFiles/wasm-interp-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wasm-interp /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wasm-interp-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wast2json.dir/build.make CMakeFiles/wast2json.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wast2json.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wast2json.dir/build.make CMakeFiles/wast2json.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=78,79 "Built target wast2json"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wast2json-copy-to-bin.dir/build.make CMakeFiles/wast2json-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wast2json-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wast2json-copy-to-bin.dir/build.make CMakeFiles/wast2json-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wast2json /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wast2json-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wat-desugar-copy-to-bin.dir/build.make CMakeFiles/wat-desugar-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wat-desugar-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wat-desugar-copy-to-bin.dir/build.make CMakeFiles/wat-desugar-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wat-desugar /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wat-desugar-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-objdump.dir/build.make CMakeFiles/wasm-objdump.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-objdump.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-objdump.dir/build.make CMakeFiles/wasm-objdump.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=63,64,65 "Built target wasm-objdump"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-objdump-copy-to-bin.dir/build.make CMakeFiles/wasm-objdump-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-objdump-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-objdump-copy-to-bin.dir/build.make CMakeFiles/wasm-objdump-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wasm-objdump /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wasm-objdump-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wabt-unittests.dir/build.make CMakeFiles/wabt-unittests.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wabt-unittests.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wabt-unittests.dir/build.make CMakeFiles/wabt-unittests.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=50,51,52,53,54,55,56,57,58,59,60 "Built target wabt-unittests"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2c.dir/build.make CMakeFiles/wasm2c.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm2c.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2c.dir/build.make CMakeFiles/wasm2c.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --green --bold --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=75 "Linking CXX executable wasm2c"
/Applications/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/wasm2c.dir/link.txt --verbose=
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=73,74,75 "Built target wasm2c"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2c-copy-to-bin.dir/build.make CMakeFiles/wasm2c-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm2c-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2c-copy-to-bin.dir/build.make CMakeFiles/wasm2c-copy-to-bin.dir/build
/Applications/CMake.app/Contents/bin/cmake -E make_directory /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E copy /Users/martin/git-repos/wabt/wasm2c /Users/martin/git-repos/wabt/bin
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num= "Built target wasm2c-copy-to-bin"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-opcodecnt.dir/build.make CMakeFiles/wasm-opcodecnt.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm-opcodecnt.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm-opcodecnt.dir/build.make CMakeFiles/wasm-opcodecnt.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --green --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=66 "Building CXX object CMakeFiles/wasm-opcodecnt.dir/src/tools/wasm-opcodecnt.cc.o"
/Library/Developer/CommandLineTools/usr/bin/c++ -D__STDC_FORMAT_MACROS=1 -D__STDC_LIMIT_MACROS=1 -I/Users/martin/git-repos/wabt -I/Users/martin/git-repos/wabt/third_party/gtest/googletest -I/Users/martin/git-repos/wabt/third_party/gtest/googletest/include -std=c++11 -Wold-style-cast -Wall -Wextra -Wno-unused-parameter -Wpointer-arith -g -Wuninitialized -fno-exceptions -std=gnu++11 -o CMakeFiles/wasm-opcodecnt.dir/src/tools/wasm-opcodecnt.cc.o -c /Users/martin/git-repos/wabt/src/tools/wasm-opcodecnt.cc
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --green --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=67 "Building CXX object CMakeFiles/wasm-opcodecnt.dir/src/binary-reader-opcnt.cc.o"
/Library/Developer/CommandLineTools/usr/bin/c++ -D__STDC_FORMAT_MACROS=1 -D__STDC_LIMIT_MACROS=1 -I/Users/martin/git-repos/wabt -I/Users/martin/git-repos/wabt/third_party/gtest/googletest -I/Users/martin/git-repos/wabt/third_party/gtest/googletest/include -std=c++11 -Wold-style-cast -Wall -Wextra -Wno-unused-parameter -Wpointer-arith -g -Wuninitialized -fno-exceptions -std=gnu++11 -o CMakeFiles/wasm-opcodecnt.dir/src/binary-reader-opcnt.cc.o -c /Users/martin/git-repos/wabt/src/binary-reader-opcnt.cc
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --green --bold --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=68 "Linking CXX executable wasm-opcodecnt"
/Applications/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/wasm-opcodecnt.dir/link.txt --verbose=
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=66,67,68 "Built target wasm-opcodecnt"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2wat.dir/build.make CMakeFiles/wasm2wat.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm2wat.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2wat.dir/build.make CMakeFiles/wasm2wat.dir/build
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --green --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=76 "Building CXX object CMakeFiles/wasm2wat.dir/src/tools/wasm2wat.cc.o"
/Library/Developer/CommandLineTools/usr/bin/c++ -D__STDC_FORMAT_MACROS=1 -D__STDC_LIMIT_MACROS=1 -I/Users/martin/git-repos/wabt -I/Users/martin/git-repos/wabt/third_party/gtest/googletest -I/Users/martin/git-repos/wabt/third_party/gtest/googletest/include -std=c++11 -Wold-style-cast -Wall -Wextra -Wno-unused-parameter -Wpointer-arith -g -Wuninitialized -fno-exceptions -std=gnu++11 -o CMakeFiles/wasm2wat.dir/src/tools/wasm2wat.cc.o -c /Users/martin/git-repos/wabt/src/tools/wasm2wat.cc
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --green --bold --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=77 "Linking CXX executable wasm2wat"
/Applications/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/wasm2wat.dir/link.txt --verbose=
/Applications/CMake.app/Contents/bin/cmake -E cmake_echo_color --switch= --progress-dir=/Users/martin/git-repos/wabt/CMakeFiles --progress-num=76,77 "Built target wasm2wat"
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2wat-copy-to-bin.dir/build.make CMakeFiles/wasm2wat-copy-to-bin.dir/depend
cd /Users/martin/git-repos/wabt && /Applications/CMake.app/Contents/bin/cmake -E cmake_depends "Unix Makefiles" /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt /Users/martin/git-repos/wabt/CMakeFiles/wasm2wat-copy-to-bin.dir/DependInfo.cmake --color=
/Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/wasm2wat-copy-to-bin.dir/build.make CMakeFiles/wasm2wat-copy-to-bin.dir/build
make[2]: *** No rule to make target `wasm2wat', needed by `CMakeFiles/wasm2wat-copy-to-bin'. Stop.
make[1]: *** [CMakeFiles/wasm2wat-copy-to-bin.dir/all] Error 2
make: *** [all] Error 2
martin: ~/git-repos/wabt >
```
Unfortunately I don't have any experience with cmake and only minimal experience with make, so I'm mostly stuck. On a second try, it seems to skip wasm2wat and go to wasm2c, throwing a similar error. I think I tracked down the offending internal command (for the case of wasm2c) to this:
```
/Library/Developer/CommandLineTools/usr/bin/c++ -std=c++11 -Wold-style-cast -Wl,-search_paths_first -Wl,-headerpad_max_install_names CMakeFiles/wasm2c.dir/src/tools/wasm2c.cc.o CMakeFiles/wasm2c.dir/src/c-writer.cc.o -o wasm2c libwabt.a
```
... which cannot generate a file called "wasm2c" in the toplevel folder of the project because there is already a folder with that name. "git status" says that this folder is untracked, so it was created by the build process itself.
Regardless of the cause of this breakage, the manual telling that make would just invoke cmake, so either can be used, is wrong.
|
Build broken on Mac OS X
|
https://api.github.com/repos/WebAssembly/wabt/issues/992/comments
| 4 |
2018-12-31T12:13:25Z
|
2022-04-27T18:02:31Z
|
https://github.com/WebAssembly/wabt/issues/992
| 394,972,062 | 992 |
[
"WebAssembly",
"wabt"
] |
Debug build, just updated the sources (but crashed with older code too). Fedora 28, compiled with clang 6.0.1, it looks like.
Test file mytest.wat:
(module (func (export "fn")))
Run thusly:
wat2wasm -d mytest.wat
Backtrace:
```
#0 wabt::Stream::WriteData (this=0x0, src=0x7fffffffd230, size=9, desc=0x0,
print_chars=wabt::PrintChars::No) at /home/lhansen/src/wabt/src/stream.cc:57
#1 0x000000000054401f in wabt::Stream::Writef (this=0x0, format=0x60463a "%07zx: ")
at /home/lhansen/src/wabt/src/stream.cc:75
#2 0x0000000000543ad1 in wabt::Stream::WriteMemoryDump (this=0x0, start=0x8ca5e0, size=32, offset=0,
print_chars=wabt::PrintChars::No, prefix=0x0, desc=0x0) at /home/lhansen/src/wabt/src/stream.cc:92
#3 0x000000000050b001 in WriteBufferToFile (filename=..., buffer=...)
at /home/lhansen/src/wabt/src/tools/wat2wasm.cc:109
#4 0x000000000050aa84 in ProgramMain (argc=3, argv=0x7fffffffd688)
at /home/lhansen/src/wabt/src/tools/wat2wasm.cc:156
#5 0x000000000050b052 in main (argc=3, argv=0x7fffffffd688)
at /home/lhansen/src/wabt/src/tools/wat2wasm.cc:169
```
I suspect the null 'this' pointer might not be right :)
|
wat2wasm segfaults with -d
|
https://api.github.com/repos/WebAssembly/wabt/issues/989/comments
| 2 |
2018-12-20T13:45:03Z
|
2018-12-25T18:37:36Z
|
https://github.com/WebAssembly/wabt/issues/989
| 393,052,800 | 989 |
[
"WebAssembly",
"wabt"
] |
failed to compile, because the output binary `wasm2c`, conflicts with the existing directory of the same name
|
failed to compile
|
https://api.github.com/repos/WebAssembly/wabt/issues/988/comments
| 1 |
2018-12-20T02:20:50Z
|
2022-04-27T18:02:59Z
|
https://github.com/WebAssembly/wabt/issues/988
| 392,859,135 | 988 |
[
"WebAssembly",
"wabt"
] |
- the output.c via `wasm2c` fails to compile, if the .wasm was produced by Emscripten, due to missing defines, e.g.
```
/* import: 'env' 'enlargeMemory' */
extern u32 (*Z_envZ_enlargeMemoryZ_iv)(void) = &enlargeMemory;
/* import: 'env' 'getTotalMemory' */
extern u32 (*Z_envZ_getTotalMemoryZ_iv)(void) = &getTotalMemory;
```
- https://zhuanlan.zhihu.com/p/43986042 contains more details, but no fix i.e. defines for missing functions
- /wabt/wasm2c/{wasm-rt.h,wasm-rt-impl.{c,h}} is insufficient
|
the output.c via `wasm2c` fails to compile
|
https://api.github.com/repos/WebAssembly/wabt/issues/987/comments
| 4 |
2018-12-20T02:20:11Z
|
2022-02-22T15:51:42Z
|
https://github.com/WebAssembly/wabt/issues/987
| 392,859,006 | 987 |
[
"WebAssembly",
"wabt"
] |
The test fails on OpenBSD:
```
- test/wasm2c/spec/names.txt
expected error code 0, got 1.
STDERR MISMATCH:
--- expected
+++ actual
@@ -0,0 +1,22 @@
+Error running "cc -c -o /tmp/wabt/out/test/wasm2c/spec/names/names.2.o names.2.c -I/tmp/wabt/wasm2c -DWASM_RT_MODULE_PREFIX=Z_names_2":
+names.2.c:169:21: error: expected identifier or '('
+static u32 __malloc(void);
+ ^
+names.2.c:169:21: error: expected ')'
+names.2.c:169:20: note: to match this '('
+static u32 __malloc(void);
+ ^
+names.2.c:733:21: error: expected identifier or '('
+static u32 __malloc(void) {
+ ^
+names.2.c:733:21: error: expected ')'
+names.2.c:733:20: note: to match this '('
+static u32 __malloc(void) {
+ ^
+names.2.c:5437:42: error: expected expression
+ WASM_RT_ADD_PREFIX(Z___mallocZ_iv) = (&__malloc);
+ ^
+/usr/include/sys/cdefs.h:227:18: note: expanded from macro '__malloc'
+#define __malloc __attribute__((__malloc__))
+ ^
```
The problem is that __malloc is defined in /usr/include/sys/cdefs.h on OpenBSD.
(http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/sys/sys/cdefs.h)
The same test succeeds with "_malloc".
|
Test that we can use some libc hidden names without conflict.
|
https://api.github.com/repos/WebAssembly/wabt/issues/981/comments
| 2 |
2018-12-17T10:39:03Z
|
2022-02-22T15:50:45Z
|
https://github.com/WebAssembly/wabt/issues/981
| 391,651,170 | 981 |
[
"WebAssembly",
"wabt"
] |
When building [wasmtime](https://github.com/CraneStation/wasmtime), which uses wabt via [wabt Rust bindings](https://crates.io/crates/wabt-sys), on MSVC in Appveyor, I see warnings like this:
```
C:\Users\appveyor\.cargo\registry\src\github.com-1ecc6299db9ec823\wabt-sys-0.5.2\wabt\src/string-view.h(165): warning C4577: 'noexcept' used with no exception handling mode specified; termination on exception is not guaranteed. Specify /EHsc [C:\projects\wasmtime\target\debug\build\wabt-sys-df9460bd8a8b54fb\out\build\wabt.vcxproj]
```
which are itnerpreted as errors:
```
C:\Users\appveyor\.cargo\registry\src\github.com-1ecc6299db9ec823\wabt-sys-0.5.2\wabt\src/string-view.h(165): error C2220: warning treated as error - no 'object' file generated [C:\projects\wasmtime\target\debug\build\wabt-sys-df9460bd8a8b54fb\out\build\wabt.vcxproj]
```
which if I'm reading things correctly comes from the -WX (/WX) [in wabt's CMakeLists.txt](https://github.com/WebAssembly/wabt/blob/master/CMakeLists.txt#L82).
See [here](https://ci.appveyor.com/project/CraneStation/wasmtime/build/job/8ovrt46vmwl5htb5) for the full log.
Would it be possible and reasonable to remove -WX outside of developer builds?
Alternatively, MSVC is suggesting adding `/EHsc`; would it make sense to add that?
|
noexcept warning, treated as error on MSVC in Appveyor
|
https://api.github.com/repos/WebAssembly/wabt/issues/980/comments
| 2 |
2018-12-17T08:31:29Z
|
2019-01-16T05:57:49Z
|
https://github.com/WebAssembly/wabt/issues/980
| 391,604,828 | 980 |
[
"WebAssembly",
"wabt"
] |
I want to use the parameter --enable-reference-types from #938 with libwabt.js like in #920.
Please can you add support for it.
|
How to pass --enable-reference-types to libwabt.js?
|
https://api.github.com/repos/WebAssembly/wabt/issues/978/comments
| 2 |
2018-12-16T10:17:04Z
|
2019-03-18T19:37:40Z
|
https://github.com/WebAssembly/wabt/issues/978
| 391,452,997 | 978 |
[
"WebAssembly",
"wabt"
] |
Consider this module:
```wasm
(module
(func $dup (result i32 i32)
(i32.const 0)
(i32.const 0)
)
(func $foo (result i32)
(call $dup)
(drop))
)
```
Note that `$dup` returns two arguments, but only one of them is consumed by `(drop)`. Yet `wasm2wat` produces this output with `--fold-exprs`:
```wasm
/tmp $ wat2wasm --enable-multi-value test2.wat && wasm2wat --fold --enable-multi-value test2.wasm
(module
(type (;0;) (func (result i32 i32)))
(type (;1;) (func (result i32)))
(func (;0;) (type 0) (result i32 i32)
(i32.const 0)
(i32.const 0))
(func (;1;) (type 1) (result i32)
(drop
(call 0))))
```
This is of course a minified example.
It seems that a multi-return expression should not be used as an argument in a folded expression.
|
wasm2wat --fold-expr confused by multi-return
|
https://api.github.com/repos/WebAssembly/wabt/issues/977/comments
| 4 |
2018-12-15T00:10:48Z
|
2018-12-18T18:07:33Z
|
https://github.com/WebAssembly/wabt/issues/977
| 391,319,857 | 977 |
[
"WebAssembly",
"wabt"
] |
I found this while using another project that depends on `wabt`. I could not build the project on windows. I narrowed the issue down to `wabt`. I may not understand something about building `wabt` on windows (which is very likely). It appears to fail on linking a static library.
Dev environment:
Windows 10
Git Bash terminal or command prompt
stable-x86_64-pc-windows-msvc
Steps to reproduce:
1. Make a rust library project with cargo
```
[package]
name = "test-install-wabt"
version = "0.1.0"
authors = ["author"]
edition = "2018"
[dependencies]
wabt = "0.7"
```
2. Run `cargo build --verbose`
Output from `cargo build`:
```
error: could not find native static library `wabt`, perhaps an -L flag is missing?
error: aborting due to previous error
The following warnings were emitted during compilation:
warning: cl : Command line warning D9002 : ignoring unknown option '-std=c++11'
warning: cl : Command line warning D9002 : ignoring unknown option '-std=c++11'
error: Could not compile `wabt-sys`.
Caused by:
process didn't exit successfully: `rustc --crate-name wabt_sys C:\Users\Mac\.cargo\registry\src\github.com-1ecc6299db9ec823\wabt-sys-0.5.1\src\lib.rs --color always --crate-type lib --emit=dep-info,link -C debuginfo=2 -C metadata=30eaec991ef17094 -C extra-filename=-30eaec991ef17094 --out-dir C:\Users\Mac\CLionProjects\test-install-wabt\target\debug\deps -L dependency=C:\Users\Mac\CLionProjects\test-install-wabt\target\debug\deps --cap-lints allow -L native=C:\Users\Mac\CLionProjects\test-install-wabt\target\debug\build\wabt-sys-e96e7bad3e0ee4c3\out\build -L native=C:\Users\Mac\CLionProjects\test-install-wabt\target\debug\build\wabt-sys-e96e7bad3e0ee4c3\out -l static=wabt -l static=wabt_shim` (exit code: 1)
```
I expected this to build without issue.
|
Cannot build project with wabt on windows
|
https://api.github.com/repos/WebAssembly/wabt/issues/972/comments
| 3 |
2018-12-09T08:28:39Z
|
2018-12-10T18:13:29Z
|
https://github.com/WebAssembly/wabt/issues/972
| 388,999,391 | 972 |
[
"WebAssembly",
"wabt"
] |
If I provide a module name, eg. `(module $foo)` in the [wat2wasm demo](https://webassembly.github.io/wabt/demo/wat2wasm/index.html), I see the custom "name" section in the build log.
However, if I run `wat2wasm` on the same source and then do `wasm-objdump --details` on the binary it produces, the "name" section isn't present.
Is the online demo using a version newer than `wabt-1.0.6`, or does the online demo just behave differently?
|
Different behavior when using wat2wasm online demo vs local binary
|
https://api.github.com/repos/WebAssembly/wabt/issues/967/comments
| 4 |
2018-12-03T22:52:13Z
|
2018-12-04T19:56:46Z
|
https://github.com/WebAssembly/wabt/issues/967
| 387,041,585 | 967 |
[
"WebAssembly",
"wabt"
] |
If I try to convert from wasm to wat and back to wasm again, like this:
```
$ wasm2wat foo.wasm > foo.wat
$ wat2wasm foo.wat > foo2.wasm
```
I get errors saying: `error: redefinition of local "$my_local"`
@nomeata pointed out to me that:
> The names for locals are not unique (and need not be, [per spec](https://webassembly.github.io/spec/core/appendix/custom.html), “Names need not be unique.”).
@rossberg suggested that I try the spec interpreter instead, and create an issue here for duplicate symbols being flagged as an error.
```
$ wasm -d foo.wasm -o foo2.wasm
```
|
error: redefinition of local "$my_local"
|
https://api.github.com/repos/WebAssembly/wabt/issues/966/comments
| 2 |
2018-12-03T18:37:37Z
|
2018-12-04T18:08:38Z
|
https://github.com/WebAssembly/wabt/issues/966
| 386,949,975 | 966 |
[
"WebAssembly",
"wabt"
] |
I'm trying to create a module which I'm intending to compile in into my program. The module looks like the following:
```WebAssembly
(module
(import "env" "__stack_pointer" (global $sp (mut i32)))
(func (export "reserve_stack") (param $size i32)
get_global $sp
get_local $size
i32.sub
set_global $sp
)
)
```
When I'm trying to compile it I'm getting the following error:
```
wat2wasm -r -o linkme.wasm linkme.wat
~/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/x86_64-apple-darwin/bin/rust-lld \
-flavor wasm \
--relocatable \
-o liblinkme.a \
--export "reserve_stack" \
linkme.wasm
rust-lld: error: symbol exported via --export not found: reserve_stack
```
is this supported use-case at all?
cc @sbc100
|
Creating wasm object file with wat2wasm
|
https://api.github.com/repos/WebAssembly/wabt/issues/965/comments
| 8 |
2018-11-30T15:35:47Z
|
2018-12-03T15:47:15Z
|
https://github.com/WebAssembly/wabt/issues/965
| 386,236,638 | 965 |
[
"WebAssembly",
"wabt"
] |
```
$ /dev/wasm/wabt/bin/wasm-objdump -d -x /tmp
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted
```
|
wasm-objdump aborts if passed a directory name
|
https://api.github.com/repos/WebAssembly/wabt/issues/962/comments
| 0 |
2018-11-29T20:09:03Z
|
2019-01-16T05:57:59Z
|
https://github.com/WebAssembly/wabt/issues/962
| 385,905,998 | 962 |
[
"WebAssembly",
"wabt"
] |
I run my code the code gives me some binary or supported txt format file. How can I get `.wasm` file from that?
Here is the some part of file (since file is too long can't upload full file)
```
ELF>P@8A@8 @ @@@��888 ȐȐ 0�0�"0�"��O ����"��"��TTTDDP�td�>�>�>TTQ�tdR�td0�0�"0�"��/lib64/ld-linux-x86-64.so.2GNUGNU$p M |vK00�A�#V�P 0�P #( � ĉ��ݣkĹ�@9� ��2 HT0O��[A�bz�)N i��� �r! �] �"� �"!(�" !(�"(�"�@�"libc.so.6fflushflockfileexitsprintfsignal__stack_chk_failmemchrisattymmapstrlenmemsetmemcmpclearerrlongjmp_setjmpstdoutfputsmemcpytzsetgetenvstderrmunmapfilenofwritegettimeofdayfunlockfile__cxa_finalizestrcmp__libc_start_mainferror__environGLIBC_2.14GLIBC_2.4GLIBC_2.2.5_ITM_deregisterTMCloneTable__gmon_start___ITM_registerTMCloneTable���ii
ui &0�"P8�"@�" H�"�`�";&h�"B&p�"I&x�"P&��"X&��"f&��"l&��"s&��"z&��"�&��"�&��"�&��"�&Ț"�&К"�&ؚ"�&�"�&�"�&�"�&��"�&�"�&�"'�"
'�"' �"'(�"$'0�"+'8�"5'@�"A'H�"J'P�"T'X�"^'`�"d'h�"k'p�"s'x�"{'��"�'��"�'��"�'��"�'��"�'��"�'��"�'��"�'��"�'ț"�'Л"�'؛"�'�"�'�"(�"(��" (�"9(�"O(�"i(�"�( �"�((�"�(0�"�(8�"�(@�"�(H�"�(P�"�(X�"�(`�"�(h�")p�")��" )��"$)��"+)��"2)��"@0��"`1��"�1��"v5Ȝ"y5М"�5�"�5�"�5�"�5�"�"П"؟"�"�" �" �" (�"#@�"$�"�"�"�" �"(�"0�"8�" @�"
H�" P�" X�"
`�"h�"p�"x�"��"��"��"��"��"��"��"��"��" ȟ" H��H�]�"H��t��H����5Z�"�%\�" @�%Z�"h������%R�"h������%J�"h������%B�"h�����%:�"h�����%2�"h�����%*�"h�����%"�"h�p����%�"h�`����%�"h �P����%
�"h
�@����%�"h �0����%��"h � ����%�"h
�����%�"h�����%�"h������%ڊ"h������%Ҋ"h������%ʊ"h������%"h�����%��"h�����%��"h�����%��"h�����%��"h�p����%��"h�`����%��"h�P����%��"f�1�I��^H��H���PTL�:H�
��H�=�1�^�"� DH�=��"UH���"H9�H��tH�2�"H��t
]��f. �]� @f. �H�=I�"H�5B�"UH)�H��H��H��H��?H�H��tH���"H��t ]��f �]� @f. ��=1�"u/H�=ω"UH��t H�=ډ"�
����H���� �"]� ���f DUH��]�f���UH��H��0H�}�H�u�H�U�H�E�H�U�H�M�H�E�H��H���#���H�E����UH��H�� H�}�H�u�H�U�H�U�H�M�H�E�H��H���������UH��H��H�}�H�u�H�}�tJH�E�H�H�PH�E�H�HH�E�H�H�pH�E�H�H��H������H�E�H�H�E�H�H�H�E�H������UH��H��#H�H���#�]�UH��H��PH�}�dH�%(H�E�1�H�H�E�H�H�E�H�E�f�E�H�E�H�����H�E�H�E�H�E�H��H�E�H�E�H�E�H�E�H��H�E�H�E�H��H�E�H�E�H��t-H�E�H��H�E�H�E�H�H��H�E�H)�H��H�E�� �H�E�H�YH�E�H�E������H�E�H�M�dH3 %(t������UH��H��PdH�%(H�E�1�H�H�E�H�H�E�H�E�f�E�H�E�H�����H�E�H�E�H�E�H��H�E�H���"H�E�H�E�H��H�E�H�E�H�E�H���W���H�E�H�E�HE��.���H�E�H�U�dH3%(t�������UH��H��PH�}�dH�%(H�E�1�H�^H�E�H�bH�E�H�E�f�E�H�E�H��� �H�E�H�E��H�-H�E�H�E�H���(H�E�����H�E�H�U�dH3%(t�K�����UH��H��PH�}�dH�%(H�E�1�H��H�E�H��H�E�H�E�f�E�H�E�H����H�E�H�E�H��H�E�H�E�H�E�H�E�H��H�E�H�E�H�H9E�t?H�E�H�qH�E�H�E�H�@H�E�H�E�H�RH�E�H�E�H�H�E�봐����H�E�H�U�dH3%(t�^�����UH��H��PH�}�dH�%(H�E�1�H� H�E�H��H�E�H�E�f�E�H�E�H����H�E�H�E�H��H�E�H�E�����H�E�H��H�E�H�E�H�E�H�E�H��H�E�H�E�H�H9E�t@H�E�H�iH�E�H�E�H�@H�E�H�E�H�JH�E�H�E�H�@H�E�볐����H�E�H�U�dH3%(t�U�����UH��H��@H�}�dH�%(H�E�1�H�H�E�H��H�E�H�E�f�E�H�E�H����H�E�uH��H�E�H�E�H���0H������H��H�E�H�H�E�vH�{H�E�H�E�H���0H���V���H��H�E�H�P������H�E�dH3%(t������UH��H��@H�}�H�u�dH�%(H�E�1�H�gH�E�H��H�E�H�E�f�E�H�E�H������n����H�E�dH3%(t�"�����UH��H��PH�}�dH�%(H�E�1�H� H�E�H�}H�E�H�E�f�E�H�E�H���_��E�H�E��H�LH�E��E�������E�H�U�dH3%(t������UH��H��PH�}�dH�%(H�E�1�H��H�E�H��H�E�H�E�f�E�H�E�H�����H�E�H�E�H�_H�E�H�E�H��H�E��[���H�E�H�U�dH3%(t� �����UH��H��PH�}�H�u�dH�%(H�E�1�H�H�E�H��H�E�H�E�f�E�H�E�H���E�H�E�H�E�AH�VH�E�H�E���H�E�H��H�E�H�E�BH�0H�E�H�E�H�H�E�H�}�tLH�E�CH�H�E�H�E�H�@H9E�u
H�E�H�E��=�H�E�DH���H�E�H�E�H�H�E�뚐H�E�EH���H�E�H�E��*���H�E�H�M�dH3 %(t�������UH��H��`H�}�H�u�dH�%(H�E�1�H���H�E�H�Z�H�E�H�E�f�E�H�E�H�����E�H�E�PH�)�H�E�H�E�H�� H��H�E�H��H���O���H�E�H�E�QH���H�E�H�E�H���H�E�H�}���H�E�RH���H�E�H�E�%�H�E�H�E�SH���H�E�H�E�H�z�H�E�H�E�SH���H�E�H�E�H��H��H�E�H��H��H�Uȃ�?���H��H��H!�H�����E���H�E�UH�4�H�E��E������E�H�M�dH3 %(t�]�����UH��H��PH�}�dH�%(H�E�1�H�y�H�E�H���H�E�H�E�f�E�H�E�H����H�E�H�E�H���H�E�H�E�H�� H�E�����H�E�H�U�dH3%(t�������UH��H��PH�}�H�u�dH�%(H�E�1�H���H�E�H�K�H�E�H�E�f�E�H�E�H�����E�H�E��H��H�E�H�E�H�E�H�������H�E�H�E�H���(H�E�H��H���Y����E��a����E�H�M�dH3 %(t������UH��H��PH�}�dH�%(H�E�1�H�E�H�E�H���H�E�H�E�f�E�H�E�H���O�H�E�H�E�H�`�H�E�H�E�H%���H�E������H�E�H�U�dH3%(t������UH��H��PH�}�dH�%(H�E�1�H���H�E�H��H�E�H�E�f�E�H�E�H�����E�H�E�yH���H�E�H�E�H���H�����E��:����E�H�U�dH3%(t�������UH��H��PH�}�dH�%(H�E�1�H�3�H�E�H�n�H�E�H�E�f�E�H�E�H���(��E�H�E�vH�=�H�E�H�E�LH�*�H�E�H�E�H�@H=����Eϐ�����E�H�U�dH3%(t�B�����UH��H��`H�}�H�u�dH�%(H�E�1�H���H�E�H���H�E�H�E�f�E�H�E�H���{�H�E�H�E�"H���H�E�H�E�H�E�H�E�#H���H�E�H�E�H�H9E���H�E�$H�`�H�E��E�H�E�H�@H��H�E�H9����E��}�tH�E�H�@H��H�E�H9����E����}�t
H�E�H�E��A�H�E�%H���H�E�H�E�H�@H��H�E�H9�����H�E�Hc�H��H�E��O�����;���H�E�H�M�dH3 %(t�������UH��H��H��X���H��P���dH�%(H�E�1�H�<�H�E�H�b�H�E�H�E�f�E�H�E�H��� �HDžp���H�E�yH�*�H�E�ƅm���H��P���H��X���H��H��������m�����m�����H�E�zH���H�E�H��P���H������H��x���H�E�{H���H�E�ƅn���H��x���H���r�����n�����n����^H�E�|H��H�E�ƅo���H��x���H���������o�����o����iH�E�}H�C�H�E�H��x���H�E�H�E�~H�%�H�E�H�E�H��H�E�H�E�LH���H�E�H��P���%�H��8H�E�H�E�H���H�E�H�E�H�@0H��H�E�H9���H�E�H���H�E�H�E�H���H�E�H�E�H���H�E�H�E�H�t�H�E�H�E�H��8H��H�E�H� H�E�H�U�H�RH�ֺH��H��H)�H��H�E�H�E�H�*�H�E�H�E�H�@H��v)H�E�H� �H�E�H�E�H��p������������H�E�H���H�E�H��x���H�E�H�E�H���H�E�H�E�H�� H�E�H�E�H���H�E�ƅk���H�E�H;�P�������k�����k���tH�E�H�@H������k�������k���t)H�E�H�D�H�E�H�E�H��p���������H�E�H��H�E�H��P���H�E�H�E�H���H�E�ƅl���H��X���H�H��H�E�H9�����l�����l���t H��X���H�@H��H�E�H9�����l�������l�����H�E�H���H�E�H��X���H���0H�U�H��H���u���H�E�H�E�H�T�H�E�H�E�H�'�H�E�H�}���H�E�H�#�H�E�H�E�H�@H�E�H�E�H��H�E�H�E�H�E�H���*���H�E�H�E�H�E�H�E�H���H�E�H�E�H�@H��v&H�E�H���H�E�H�E�H��p�������������H��p���H�M�dH3 %(t�������UH��H��PH�}�H�u�dH�%(H�E�1�H�4�H�E�H�1�H�E�H�E�f�E�H�E�H�����H�E�H�E� H���H�E�H�E�H�P�H�E�H�H�E�H��H!�H�E��o���H�E�H�M�dH3 %(t� �����UH��H��P�}�dH�%(H�E�1�H���H�E�H���H�E�H�E�f�E�H�E�H���^�H�E�H�E�H�o�H�E�}���w2H�E�H�S�H�E�}��w H�E���;�H�E��0�H�E�H� �H�E�}����w
H�E�� �H�E�H�E�H���H�E�H�E��E������H�U��H��H�E�H�H�E��D���H�E�H�u�dH34%(t�������UH��H��pH�}�H�u�H�U�dH�%(H�E�1�H�y�H�E�H�p�H�E�H�E�f�E�H�E�H���*�H�E�H�C�H�E�H�E�H�E�H����Y���H�E�H�E�H�E������H��H�оH������H�E�H�E�H��H�E�H�E�H���H�E�H�E�H�H�E�H�H�E�H�H�E�H���H�E�H�E�H�H�U�H��H!�H�E�H�H�E�H���H�E�H�E�H��?H=?HN�H�E�H�H�E�H�Z�H�E�H�E�H����x���H��H�E�H�H�E�H�/�H�E�H�E�H�H��H�E�H�����H��H��H�P�H�E�H�H�E�H���H�E�H�E�H�H�P�H�E�H��_����H�E�dH3%(t������UH��H��P�}�dH�%(H�E�1�H���H�E�H���H�E�H�E�f�E�H�E�H���Q�H�E�H�E�H�b�H�E�E���#E�������H�E������H�E�H�U�dH3%(t�|�����UH��H��`H�}�H�u�H�U�dH�%(H�E�1�H��H�E�H���H�E�H�E�f�E�H�E�H��豵H�E�H�E�H���H�E�H�E�H�H�E�H���T�H�E�H��������H��!ЉE�H�E�H���H�E�H�E�H�E�H�h�H�E�H�E�H�;�H�E�}�thH�E�H�<�H�E�Eĉ��k���H��H�E�H�H�E�H��H�E�H�E�H�H�E�H�H�E�H��H�H��H�D�H�E����H�E�H���H�E�H�E���H�E�H����������H��H��!Љ������H��H�E�H�H�E�H���H�E�H�E�H�H��~xH�E�H�m�H�E�H�E�H�H�E�H���D�������H��H�E�H�H�E�H�3�H�E�H�E�H�H�E�H�H�E�H��H�H��H�D�H�E�������H�E�H�}�dH3<%(t�4�����UH��H�}�H�E��E�H�}����E��}�uH�E�H�H�����E����}�t
H���H�E��
```
|
How to get .wasm file from unsupported text file?
|
https://api.github.com/repos/WebAssembly/wabt/issues/961/comments
| 3 |
2018-11-29T07:59:37Z
|
2022-05-19T01:41:35Z
|
https://github.com/WebAssembly/wabt/issues/961
| 385,612,157 | 961 |
[
"WebAssembly",
"wabt"
] |
Doing a git clone followed by 'make' results in:
```
Scanning dependencies of target wabt-unittests
[ 53%] Building CXX object CMakeFiles/wabt-unittests.dir/src/test-binary-reader.cc.o
In file included from /home/gback/emsdk/wabt/src/test-binary-reader.cc:17:
In file included from /home/gback/emsdk/wabt/third_party/gtest/googletest/include/gtest/gtest.h:55:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/ostream:38:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/ios:42:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/ios_base.h:41:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/locale_classes.h:40:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/string:52:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/basic_string.h:6352:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/ext/string_conversions.h:41:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/cstdlib:77:
/usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/std_abs.h:102:3: error: support for type
'__float128' is not yet implemented
abs(__float128 __x)
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/std_abs.h:102:18: error: support for type
'__float128' is not yet implemented
abs(__float128 __x)
^
2 errors generated.
```
I have clang
```
$ clang --version
Ubuntu clang version 3.6.2-3ubuntu2 (tags/RELEASE_362/final) (based on LLVM 3.6.2)
$ gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/7/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 7.3.0-27ubuntu1~18.04' --with-bugurl=file:///usr/share/doc/gcc-7/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-7 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
gcc version 7.3.0 (Ubuntu 7.3.0-27ubuntu1~18.04)
```
Is Ubuntu 18.04 a supported environment for wabt?
|
fails to build on Ubuntu 18.04
|
https://api.github.com/repos/WebAssembly/wabt/issues/951/comments
| 4 |
2018-11-06T15:51:38Z
|
2018-11-07T01:53:59Z
|
https://github.com/WebAssembly/wabt/issues/951
| 377,909,487 | 951 |
[
"WebAssembly",
"wabt"
] |
According to the "Memory Instructions of WebAssembly Core Specification"
https://webassembly.github.io/spec/core/bikeshed/index.html#syntax-instr-memory
linear memory in wasm will access with load or store.
loads and stores are followed by the encoding of their memory-immediate {align:u32, offset:u32}
however, we I read the source code in wabt/src/interp/interp.cc, I was confused with the ReadMemory. did i miss some important clues?
`
template <typename MemType, typename ResultType>
Result Thread::Load(const uint8_t** pc) {
typedef typename ExtendMemType<ResultType, MemType>::type ExtendedType;
void* src;
CHECK_TRAP(GetAccessAddress<MemType>(pc, &src));
MemType value;
LoadFromMemory<MemType>(&value, src);
return Push<ResultType>(static_cast<ExtendedType>(value));
}
template <typename MemType, typename ResultType>
Result Thread::Store(const uint8_t** pc) {
typedef typename WrapMemType<ResultType, MemType>::type WrappedType;
WrappedType value = PopRep<ResultType>();
void* dst;
CHECK_TRAP(GetAccessAddress<MemType>(pc, &dst));
StoreToMemory<WrappedType>(dst, value);
return Result::Ok;
}
Memory* Thread::ReadMemory(const uint8_t** pc) {
Index memory_index = ReadU32(pc);
return &env_->memories_[memory_index];
}
template <typename MemType>
Result Thread::GetAccessAddress(const uint8_t** pc, void** out_address) {
Memory* memory = ReadMemory(pc);
uint64_t addr = static_cast<uint64_t>(Pop<uint32_t>()) + ReadU32(pc);
TRAP_IF(addr + sizeof(MemType) > memory->data.size(),
MemoryAccessOutOfBounds);
*out_address = memory->data.data() + static_cast<IstreamOffset>(addr);
return Result::Ok;
}
`
|
did Thread::ReadMemory have implicit bugs?
|
https://api.github.com/repos/WebAssembly/wabt/issues/944/comments
| 3 |
2018-11-02T11:12:01Z
|
2018-11-08T04:54:18Z
|
https://github.com/WebAssembly/wabt/issues/944
| 376,767,720 | 944 |
[
"WebAssembly",
"wabt"
] |
I have spent some time using wasm-interp to investigate some issues in compiled wasm code and think that It would be better to change the trace formatting scheme. In particular, I suggest to use `$` only for representing local variables of functions. I understand the current rule of `$` using but traces traces like this one
```
get_local $1
i32.const $1
```
is still a little bit confusing for me. After the first look It is intuitively expected that `i32.const` also operates with local variable and `$1` doesn't a simply numerical constant.
|
Improvement of the interpretator traces
|
https://api.github.com/repos/WebAssembly/wabt/issues/943/comments
| 4 |
2018-11-01T21:20:05Z
|
2023-03-15T06:30:48Z
|
https://github.com/WebAssembly/wabt/issues/943
| 376,575,424 | 943 |
[
"WebAssembly",
"wabt"
] |
See, for example [here](https://travis-ci.org/WebAssembly/wabt/jobs/447926261)
```
WARNING:root:not all asm.js optimizations are possible with ALLOW_MEMORY_GROWTH, disabling those. [-Walmost-asm]
ERROR:root:undefined exported function: "_dummy_workaround_for_emscripten_issue_7073"
CMakeFiles/libwabtjs.dir/build.make:100: recipe for target 'libwabt.js' failed
make[2]: *** [libwabt.js] Error 1
```
We can probably remove this line from [emscripten-exported.json](https://github.com/WebAssembly/wabt/blob/master/src/emscripten-exported.json) to fix, since I believe this is now fixed upstream. If we want to continue to support older emscripten versions where this bug is not fixed, I think we can add a matching empty function with this name to `emscripten-helpers.cc`.
|
Fix emscripten error in Travis
|
https://api.github.com/repos/WebAssembly/wabt/issues/939/comments
| 0 |
2018-10-30T17:18:10Z
|
2018-11-01T17:28:13Z
|
https://github.com/WebAssembly/wabt/issues/939
| 375,603,333 | 939 |
[
"WebAssembly",
"wabt"
] |
While I was testing my own webassembly compiler against the official interpreter tests, I was trying to verify the results against wabt, but accidentally discovered that the wat compiler fails part of `call_indirect.wast`. Namely, it is not verifying that the inline type declarations match the explicit type reference. Instead, the inline type declarations override the explicit type reference, which is very unexpected.
This `.wat` module currently compiles in [wat2wasm](https://webassembly.github.io/wabt/demo/wat2wasm/):
```
(module
(type $sig (func (param i32) (result i32)))
(table 0 anyfunc)
(func (result i32)
(call_indirect (type $sig) (result i32) (i32.const 0))
)
)
```
This code is malformed, because there exists an inline type declaration in addition to the explicit type reference. The inline type declaration forms a function that takes no parameters and returns `i32`. The referenced type, however, is a function that takes `i32` and returns `i32`. This is expected to throw an "inline function type" error in [`call_indirect.wast`](https://github.com/WebAssembly/spec/blob/b3de271e8da3f8aa29a9ea3455665f88b1a4c3d2/test/core/call_indirect.wast#L359).
Instead, wat2wasm discards the referenced type and uses the inline type to compile the function. If the situation is reversed, the code does not compile, but only because the type is now expecting a parameter that is not provided, not because of a signature mismatch.
```
(module
(type $sig (func (result i32)))
(table 0 anyfunc)
(func (result i32)
(call_indirect (type $sig) (param i32) (result i32) (i32.const 0))
)
)
```
Yields:
```
test.wast:5:8: error: type mismatch in call_indirect, expected [i32] but got []
(call_indirect (type $sig) (param i32) (result i32) (i32.const 0))
```
|
Fails to warn about malformed wat
|
https://api.github.com/repos/WebAssembly/wabt/issues/936/comments
| 1 |
2018-10-25T19:20:23Z
|
2018-10-30T19:58:24Z
|
https://github.com/WebAssembly/wabt/issues/936
| 374,094,454 | 936 |
[
"WebAssembly",
"wabt"
] |
See https://github.com/WebAssembly/spec/issues/884
There are plans to rename many instructions, and we should implement them here. We'll want to keep support for the old names for a while, and we may even want to have a flag to output the old names too during the transition.
The full rename list is duplicated here:
```
;; table declaration
anyfunc -> funcref
;; core instructions
get_local -> local.get
set_local -> local.set
tee_local -> local.tee
get_global -> global.get
set_global -> global.set
i32.wrap/i64 -> i32.wrap_i64
i32.trunc_s/f32 -> i32.trunc_f32_s
i32.trunc_u/f32 -> i32.trunc_f32_u
i32.trunc_s/f64 -> i32.trunc_f64_s
i32.trunc_u/f64 -> i32.trunc_f64_u
i64.extend_s/i32 -> i64.extend_i32_s
i64.extend_u/i32 -> i64.extend_i32_u
i64.trunc_s/f32 -> i64.trunc_f32_s
i64.trunc_u/f32 -> i64.trunc_f32_u
i64.trunc_s/f64 -> i64.trunc_f64_s
i64.trunc_u/f64 -> i64.trunc_f64_u
f32.convert_s/i32 -> f32.convert_i32_s
f32.convert_u/i32 -> f32.convert_i32_u
f32.convert_s/i64 -> f32.convert_i64_s
f32.convert_u/i64 -> f32.convert_i64_u
f32.demote/f64 -> f32.demote_f64
f64.convert_s/i32 -> f64.convert_i32_s
f64.convert_u/i32 -> f64.convert_i32_u
f64.convert_s/i64 -> f64.convert_i64_s
f64.convert_u/i64 -> f64.convert_i64_u
f64.promote/f32 -> f64.promote_f32
i32.reinterpret/f32 -> i32.reinterpret_f32
i64.reinterpret/f64 -> i64.reinterpret_f64
f32.reinterpret/i32 -> f32.reinterpret_i32
f64.reinterpret/i64 -> f64.reinterpret_i64
;; saturating-float-to-int instructions
i32.trunc_s:sat/f32 -> i32.trunc_sat_f32_s
i32.trunc_u:sat/f32 -> i32.trunc_sat_f32_u
i32.trunc_s:sat/f64 -> i32.trunc_sat_f64_s
i32.trunc_u:sat/f64 -> i32.trunc_sat_f64_u
i64.trunc_s:sat/f32 -> i64.trunc_sat_f32_s
i64.trunc_u:sat/f32 -> i64.trunc_sat_f32_u
i64.trunc_s:sat/f64 -> i64.trunc_sat_f64_s
i64.trunc_u:sat/f64 -> i64.trunc_sat_f64_u
;; simd instructions
f32x4.convert_s/i32x4 -> f32x4.convert_i32x4_s
f32x4.convert_u/i32x4 -> f32x4.convert_i32x4_u
f64x2.convert_s/i64x2 -> f64x2.convert_i64x2_s
f64x2.convert_u/i64x2 -> f64x2.convert_i64x2_u
i32x4.trunc_s/f32x4:sat -> i32x4.trunc_sat_f32x4_s
i32x4.trunc_u/f32x4:sat -> i32x4.trunc_sat_f32x4_u
i64x2.trunc_s/f64x2:sat -> i64x2.trunc_sat_f64x2_s
i64x2.trunc_u/f64x2:sat -> i64x2.trunc_sat_f64x2_u
;; atomic instructions
atomic.wake -> atomic.notify
i32.atomic.rmw8_u.add -> i32.atomic.rmw8.add_u
i32.atomic.rmw16_u.add -> i32.atomic.rmw16.add_u
i64.atomic.rmw8_u.add -> i64.atomic.rmw8.add_u
i64.atomic.rmw16_u.add -> i64.atomic.rmw16.add_u
i64.atomic.rmw32_u.add -> i64.atomic.rmw32.add_u
i32.atomic.rmw8_u.sub -> i32.atomic.rmw8.sub_u
i32.atomic.rmw16_u.sub -> i32.atomic.rmw16.sub_u
i64.atomic.rmw8_u.sub -> i64.atomic.rmw8.sub_u
i64.atomic.rmw16_u.sub -> i64.atomic.rmw16.sub_u
i64.atomic.rmw32_u.sub -> i64.atomic.rmw32.sub_u
i32.atomic.rmw8_u.and -> i32.atomic.rmw8.and_u
i32.atomic.rmw16_u.and -> i32.atomic.rmw16.and_u
i64.atomic.rmw8_u.and -> i64.atomic.rmw8.and_u
i64.atomic.rmw16_u.and -> i64.atomic.rmw16.and_u
i64.atomic.rmw32_u.and -> i64.atomic.rmw32.and_u
i32.atomic.rmw8_u.or -> i32.atomic.rmw8.or_u
i32.atomic.rmw16_u.or -> i32.atomic.rmw16.or_u
i64.atomic.rmw8_u.or -> i64.atomic.rmw8.or_u
i64.atomic.rmw16_u.or -> i64.atomic.rmw16.or_u
i64.atomic.rmw32_u.or -> i64.atomic.rmw32.or_u
i32.atomic.rmw8_u.xor -> i32.atomic.rmw8.xor_u
i32.atomic.rmw16_u.xor -> i32.atomic.rmw16.xor_u
i64.atomic.rmw8_u.xor -> i64.atomic.rmw8.xor_u
i64.atomic.rmw16_u.xor -> i64.atomic.rmw16.xor_u
i64.atomic.rmw32_u.xor -> i64.atomic.rmw32.xor_u
i32.atomic.rmw8_u.xchg -> i32.atomic.rmw8.xchg_u
i32.atomic.rmw16_u.xchg -> i32.atomic.rmw16.xchg_u
i64.atomic.rmw8_u.xchg -> i64.atomic.rmw8.xchg_u
i64.atomic.rmw16_u.xchg -> i64.atomic.rmw16.xchg_u
i64.atomic.rmw32_u.xchg -> i64.atomic.rmw32.xchg_u
i32.atomic.rmw8_u.cmpxchg -> i32.atomic.rmw8.cmpxchg_u
i32.atomic.rmw16_u.cmpxchg -> i32.atomic.rmw16.cmpxchg_u
i64.atomic.rmw8_u.cmpxchg -> i64.atomic.rmw8.cmpxchg_u
i64.atomic.rmw16_u.cmpxchg -> i64.atomic.rmw16.cmpxchg_u
i64.atomic.rmw32_u.cmpxchg -> i64.atomic.rmw32.cmpxchg_u
```
|
Rename instructions in text format
|
https://api.github.com/repos/WebAssembly/wabt/issues/933/comments
| 2 |
2018-10-16T18:27:14Z
|
2019-01-16T05:58:26Z
|
https://github.com/WebAssembly/wabt/issues/933
| 370,741,035 | 933 |
[
"WebAssembly",
"wabt"
] |
@aardappel mentioned that it would be nice to have a checklist when adding a new instruction; there are a lot of places that you need to change, and it's easy to miss some.
The compiler will catch a number of them, since adding a new enum to the opcodes list will create a warning, but there are some that only get flushed out with a new test.
It may be instructive to look at the distinction between the bulk-memory-operation change [here](https://github.com/WebAssembly/wabt/commit/27d833c6c8bbb041c43e5f67e1049d6c0095bd56), and the one that landed afterward [here](https://github.com/WebAssembly/wabt/commit/b234c76e30b49f75ddcd095c5f1e7d9d27d82160).
|
Add checklist for new instructions
|
https://api.github.com/repos/WebAssembly/wabt/issues/932/comments
| 1 |
2018-10-15T23:08:26Z
|
2018-10-16T05:39:21Z
|
https://github.com/WebAssembly/wabt/issues/932
| 370,377,631 | 932 |
[
"WebAssembly",
"wabt"
] |
We'll want the full suite of tests that wabt typically provides:
* `test/binary`
* `test/dump`
* `test/parse/expr`
* `test/typecheck`
We'll also want to run spec tests for the proposal (see `update-spec-tests.py`)
|
More tests for the tail-call feature
|
https://api.github.com/repos/WebAssembly/wabt/issues/929/comments
| 0 |
2018-10-12T21:20:01Z
|
2018-10-17T00:00:26Z
|
https://github.com/WebAssembly/wabt/issues/929
| 369,714,314 | 929 |
[
"WebAssembly",
"wabt"
] |
First added in https://github.com/WebAssembly/wabt/pull/927 the bulk memory operations aren't fully validated yet. Right now they don't verify that the immediate indexes passed to `{table,memory}.{init,drop}` are valid segments for the table/memory sections. For validation to be complete we'll need to validate that the index is indeed in bounds ~~and it's also a passive segment~~ (not needed any more!).
|
Implement further segment validation checks for bulk memory operations
|
https://api.github.com/repos/WebAssembly/wabt/issues/928/comments
| 3 |
2018-10-12T20:12:51Z
|
2020-03-20T20:36:31Z
|
https://github.com/WebAssembly/wabt/issues/928
| 369,694,988 | 928 |
[
"WebAssembly",
"wabt"
] |
Rawgit is shutting down, see https://rawgit.com/
|
Remove uses of rawgit
|
https://api.github.com/repos/WebAssembly/wabt/issues/924/comments
| 0 |
2018-10-09T16:04:44Z
|
2018-10-12T03:04:14Z
|
https://github.com/WebAssembly/wabt/issues/924
| 368,285,524 | 924 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.