From 24d9c826b430767f10be975893c12f56e16580dd Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 29 Mar 2024 16:17:55 -0700 Subject: [PATCH 01/36] yolo --- CMakeLists.txt | 30 +++++++++++++++++++++++++++--- src/binaryen-embind.cpp | 26 ++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 3 deletions(-) create mode 100644 src/binaryen-embind.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 3a8af137cfe..1ca2cf5a16e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -371,9 +371,9 @@ if(EMSCRIPTEN) # On Node.js, make the tools immediately usable. add_link_flag("-sNODERAWFS") endif() - # in opt builds, LTO helps so much (>20%) it's worth slow compile times - add_nondebug_compile_flag("-flto") - endif() + # in opt builds, LTO helps so much (>20%) it's worth slow compile times + #add_nondebug_compile_flag("-flto") +endif() # clang doesn't print colored diagnostics when invoked from Ninja if(UNIX AND CMAKE_GENERATOR STREQUAL "Ninja") @@ -539,6 +539,30 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_js debug "--profiling") target_link_libraries(binaryen_js debug "-sASSERTIONS") install(TARGETS binaryen_js DESTINATION ${CMAKE_INSTALL_BINDIR}) + + # binaryen.embind.js variant (WebAssembly) + add_executable(binaryen_embind_wasm + src/binaryen_embind.cpp + ${binaryen_emscripten_SOURCES}) + target_link_libraries(binaryen_embind_wasm wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) + target_link_libraries(binaryen_embind_wasm "-sFILESYSTEM") + target_link_libraries(binaryen_embind_wasm "-sEXPORT_NAME=Binaryen") + target_link_libraries(binaryen_embind_wasm "-sNODERAWFS=0") + # Do not error on the repeated NODERAWFS argument + target_link_libraries(binaryen_embind_wasm "-Wno-unused-command-line-argument") + # Emit a single file for convenience of people using binaryen.js as a library, + # so they only need to distribute a single file. + target_link_libraries(binaryen_embind_wasm "-sSINGLE_FILE") + target_link_libraries(binaryen_embind_wasm "-sEXPORT_ES6") + target_link_libraries(binaryen_embind_wasm "--bind") + target_link_libraries(binaryen_embind_wasm "-msign-ext") + target_link_libraries(binaryen_embind_wasm "-mbulk-memory") + #target_link_libraries(binaryen_embind_wasm optimized "--closure=1") + # TODO: Fix closure warnings! (#5062) + target_link_libraries(binaryen_embind_wasm optimized "-Wno-error=closure") + #target_link_libraries(binaryen_embind_wasm optimized "-flto") + target_link_libraries(binaryen_embind_wasm debug "--profiling") + install(TARGETS binaryen_embind_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() configure_file(scripts/binaryen-lit.in ${CMAKE_BINARY_DIR}/bin/binaryen-lit @ONLY) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp new file mode 100644 index 00000000000..260f1cace4e --- /dev/null +++ b/src/binaryen-embind.cpp @@ -0,0 +1,26 @@ +/* + * Copyright 2024 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//============================== +// Binaryen Embind declarations +//============================== + +#include + +#include "wasm.h" + +using namespace wasm; + From 82fb2c9948792b3e85ef17c70d9be68b914b1272 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 29 Mar 2024 16:36:04 -0700 Subject: [PATCH 02/36] test --- CMakeLists.txt | 13 +++++++------ src/binaryen-embind.cpp | 5 +++++ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1ca2cf5a16e..3db0e823ccd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -372,7 +372,8 @@ if(EMSCRIPTEN) add_link_flag("-sNODERAWFS") endif() # in opt builds, LTO helps so much (>20%) it's worth slow compile times - #add_nondebug_compile_flag("-flto") + add_nondebug_compile_flag("-flto") + add_compile_flag("-DEMSCRIPTEN_HAS_UNBOUND_TYPE_NAMES=0") # XXX - ? endif() # clang doesn't print colored diagnostics when invoked from Ninja @@ -542,25 +543,25 @@ if(EMSCRIPTEN) # binaryen.embind.js variant (WebAssembly) add_executable(binaryen_embind_wasm - src/binaryen_embind.cpp + src/binaryen-embind.cpp ${binaryen_emscripten_SOURCES}) target_link_libraries(binaryen_embind_wasm wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) target_link_libraries(binaryen_embind_wasm "-sFILESYSTEM") - target_link_libraries(binaryen_embind_wasm "-sEXPORT_NAME=Binaryen") + #target_link_libraries(binaryen_embind_wasm "-sEXPORT_NAME=Binaryen") target_link_libraries(binaryen_embind_wasm "-sNODERAWFS=0") # Do not error on the repeated NODERAWFS argument target_link_libraries(binaryen_embind_wasm "-Wno-unused-command-line-argument") # Emit a single file for convenience of people using binaryen.js as a library, # so they only need to distribute a single file. - target_link_libraries(binaryen_embind_wasm "-sSINGLE_FILE") - target_link_libraries(binaryen_embind_wasm "-sEXPORT_ES6") + #target_link_libraries(binaryen_embind_wasm "-sSINGLE_FILE") + #target_link_libraries(binaryen_embind_wasm "-sEXPORT_ES6") target_link_libraries(binaryen_embind_wasm "--bind") target_link_libraries(binaryen_embind_wasm "-msign-ext") target_link_libraries(binaryen_embind_wasm "-mbulk-memory") #target_link_libraries(binaryen_embind_wasm optimized "--closure=1") # TODO: Fix closure warnings! (#5062) target_link_libraries(binaryen_embind_wasm optimized "-Wno-error=closure") - #target_link_libraries(binaryen_embind_wasm optimized "-flto") + target_link_libraries(binaryen_embind_wasm optimized "-flto") target_link_libraries(binaryen_embind_wasm debug "--profiling") install(TARGETS binaryen_embind_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 260f1cace4e..e6e35f011ee 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -23,4 +23,9 @@ #include "wasm.h" using namespace wasm; +using namespace emscripten; +EMSCRIPTEN_BINDINGS(Binaryen) { + class_("Expression") + .function("finalize", &Expression::finalize); +} From 63b05706a06d1e9ca5fe80538ae00b9ffc539d5e Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 13:48:44 -0700 Subject: [PATCH 03/36] weird --- CMakeLists.txt | 5 +++-- src/binaryen-embind.cpp | 34 +++++++++++++++++++++++++++++++++- 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3db0e823ccd..5a8c5de9aed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -372,7 +372,7 @@ if(EMSCRIPTEN) add_link_flag("-sNODERAWFS") endif() # in opt builds, LTO helps so much (>20%) it's worth slow compile times - add_nondebug_compile_flag("-flto") + #add_nondebug_compile_flag("-flto") add_compile_flag("-DEMSCRIPTEN_HAS_UNBOUND_TYPE_NAMES=0") # XXX - ? endif() @@ -561,7 +561,8 @@ if(EMSCRIPTEN) #target_link_libraries(binaryen_embind_wasm optimized "--closure=1") # TODO: Fix closure warnings! (#5062) target_link_libraries(binaryen_embind_wasm optimized "-Wno-error=closure") - target_link_libraries(binaryen_embind_wasm optimized "-flto") + #target_link_libraries(binaryen_embind_wasm optimized "-flto") + target_link_libraries(binaryen_embind_wasm optimized "--profiling") # XXX target_link_libraries(binaryen_embind_wasm debug "--profiling") install(TARGETS binaryen_embind_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index e6e35f011ee..debd077c724 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -25,7 +25,39 @@ using namespace wasm; using namespace emscripten; +Function* (Module::*Module_addFunction)(Function*) = &Module::addFunction; // XXX work around overloaded name + EMSCRIPTEN_BINDINGS(Binaryen) { + + class_("Type") + .function("isTuple", &Type::isTuple) + .function("isRef", &Type::isRef) + .function("isFunction", &Type::isFunction) + .function("isData", &Type::isData) + .function("isNullable", &Type::isNullable) + .function("isNonNullable", &Type::isNonNullable) + .function("isNull", &Type::isNull) + .function("isSignature", &Type::isSignature) + .function("isStruct", &Type::isStruct) + .function("isArray", &Type::isArray) + .function("isException", &Type::isException) + .function("isString", &Type::isString) + .function("isDefaultable", &Type::isDefaultable); + + class_("Name") + .constructor(); + class_("Expression") - .function("finalize", &Expression::finalize); + .property("type", &Expression::type); + + class_("Function") + ; + + class_("Module") + .property("start", &Module::start) + .function("getFunction", &Module::getFunction, allow_raw_pointers()) + .function("getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) + .function("addFunction", Module_addFunction, allow_raw_pointers()) // XXX + ; + } From 49d943350d11097e8e5cee96953770f9c4a2fc96 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 13:49:59 -0700 Subject: [PATCH 04/36] work --- src/binaryen-embind.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index debd077c724..8ce5dbf2840 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -25,8 +25,6 @@ using namespace wasm; using namespace emscripten; -Function* (Module::*Module_addFunction)(Function*) = &Module::addFunction; // XXX work around overloaded name - EMSCRIPTEN_BINDINGS(Binaryen) { class_("Type") @@ -57,7 +55,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property("start", &Module::start) .function("getFunction", &Module::getFunction, allow_raw_pointers()) .function("getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) - .function("addFunction", Module_addFunction, allow_raw_pointers()) // XXX + .function("addFunction", select_overload(&Module::addFunction), allow_raw_pointers()) ; } From d370b82bdc09a921fad9abb9eba6078dcf99e8a5 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 13:52:36 -0700 Subject: [PATCH 05/36] work --- src/binaryen-embind.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 8ce5dbf2840..702aef400eb 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -21,6 +21,7 @@ #include #include "wasm.h" +#include "wasm-builder.h" using namespace wasm; using namespace emscripten; @@ -48,9 +49,15 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Expression") .property("type", &Expression::type); + // All Expression classes... + class_("Function") ; + class_("Builder") + .constructor() + ; + class_("Module") .property("start", &Module::start) .function("getFunction", &Module::getFunction, allow_raw_pointers()) From da000ce1b29d3a2e3e9591825a3c99da8c368e44 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 13:55:47 -0700 Subject: [PATCH 06/36] work --- src/binaryen-embind.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 702aef400eb..4f821857801 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -56,13 +56,14 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Builder") .constructor() + .function("makeFunction", select_overload (Name, std::vector&&, HeapType, std::vector&& vars, Expression*)>, allow_raw_pointers()) ; class_("Module") .property("start", &Module::start) .function("getFunction", &Module::getFunction, allow_raw_pointers()) .function("getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) - .function("addFunction", select_overload(&Module::addFunction), allow_raw_pointers()) + .function("addFunction", select_overload(&Module::addFunction), allow_raw_pointers()) ; } From 60b2d6cd4ded6a6199414be89d689b077da1099e Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 13:57:27 -0700 Subject: [PATCH 07/36] work --- src/binaryen-embind.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 4f821857801..1b3d2f725a3 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -56,7 +56,10 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Builder") .constructor() - .function("makeFunction", select_overload (Name, std::vector&&, HeapType, std::vector&& vars, Expression*)>, allow_raw_pointers()) + .function("makeFunction", select_overload (Name, std::vector&&, HeapType, std::vector&& vars, Expression*)>(&Builder::makeFunction), allow_raw_pointers()) + + // All Expression classes... + .function("makeNop", &Builder::makeNop, allow_raw_pointers()) ; class_("Module") From 9d4257033104b1e0f597b4d91a745730ba335d4e Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 14:07:27 -0700 Subject: [PATCH 08/36] fix --- CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5a8c5de9aed..9e77b4de1dd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -543,8 +543,7 @@ if(EMSCRIPTEN) # binaryen.embind.js variant (WebAssembly) add_executable(binaryen_embind_wasm - src/binaryen-embind.cpp - ${binaryen_emscripten_SOURCES}) + src/binaryen-embind.cpp) target_link_libraries(binaryen_embind_wasm wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) target_link_libraries(binaryen_embind_wasm "-sFILESYSTEM") #target_link_libraries(binaryen_embind_wasm "-sEXPORT_NAME=Binaryen") From 6fcbbef50f7d00789144967e5c92e5285e131821 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 14:14:47 -0700 Subject: [PATCH 09/36] work --- CMakeLists.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9e77b4de1dd..177b3c5c2b8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -548,13 +548,14 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_embind_wasm "-sFILESYSTEM") #target_link_libraries(binaryen_embind_wasm "-sEXPORT_NAME=Binaryen") target_link_libraries(binaryen_embind_wasm "-sNODERAWFS=0") + target_link_libraries(binaryen_embind_wasm "-sMODULARIZE") # Do not error on the repeated NODERAWFS argument target_link_libraries(binaryen_embind_wasm "-Wno-unused-command-line-argument") # Emit a single file for convenience of people using binaryen.js as a library, # so they only need to distribute a single file. #target_link_libraries(binaryen_embind_wasm "-sSINGLE_FILE") #target_link_libraries(binaryen_embind_wasm "-sEXPORT_ES6") - target_link_libraries(binaryen_embind_wasm "--bind") + target_link_libraries(binaryen_embind_wasm "-lembind") target_link_libraries(binaryen_embind_wasm "-msign-ext") target_link_libraries(binaryen_embind_wasm "-mbulk-memory") #target_link_libraries(binaryen_embind_wasm optimized "--closure=1") @@ -562,6 +563,7 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_embind_wasm optimized "-Wno-error=closure") #target_link_libraries(binaryen_embind_wasm optimized "-flto") target_link_libraries(binaryen_embind_wasm optimized "--profiling") # XXX + target_link_libraries(binaryen_embind_wasm optimized "-O1") # XXX target_link_libraries(binaryen_embind_wasm debug "--profiling") install(TARGETS binaryen_embind_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() From c3143095679e12bd27a7630b8bd8400a67429059 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 15:57:07 -0700 Subject: [PATCH 10/36] test --- check.py | 1 + scripts/test/binaryenjs.py | 16 ++++++++++++++++ scripts/test/shared.py | 1 + test/binaryen-embind.js/basics.js | 13 +++++++++++++ 4 files changed, 31 insertions(+) create mode 100644 test/binaryen-embind.js/basics.js diff --git a/check.py b/check.py index 0b5ed5ce7d6..6ca60a41f8c 100755 --- a/check.py +++ b/check.py @@ -372,6 +372,7 @@ def run(): ('unit', run_unittest), ('binaryenjs', binaryenjs.test_binaryen_js), ('binaryenjs_wasm', binaryenjs.test_binaryen_wasm), + ('binaryenjs_embind', binaryenjs.test_binaryen_embind), ('lit', run_lit), ('gtest', run_gtest), ]) diff --git a/scripts/test/binaryenjs.py b/scripts/test/binaryenjs.py index d546ced1336..87f0c9edadb 100644 --- a/scripts/test/binaryenjs.py +++ b/scripts/test/binaryenjs.py @@ -113,3 +113,19 @@ def test_binaryen_js(): def test_binaryen_wasm(): do_test_binaryen_js_with(shared.BINARYEN_WASM) + + +def test_binaryen_embind(): + print('\n[ checking binaryen.js (embind) testcases (' + shared.BINARYEN_EMBIND + ')... ]\n') + + for s in sorted(os.listdir(os.path.join(shared.options.binaryen_test, 'binaryen-embind.js'))): + if not s.endswith('.js'): + continue + print(s) + test_path = os.path.join(shared.options.binaryen_test, 'binaryen-embind.js', s) + + # Run the test and pass the build as an argument, so it knows where to + # load it. + out = support.run_command([shared.NODEJS, test_path, shared.BINARYEN_EMBIND]) + assert('success.' in out) + diff --git a/scripts/test/shared.py b/scripts/test/shared.py index 3a9b5a26c20..9f4f35647be 100644 --- a/scripts/test/shared.py +++ b/scripts/test/shared.py @@ -214,6 +214,7 @@ def is_exe(fpath): 'wasm-emscripten-finalize')] BINARYEN_JS = os.path.join(options.binaryen_bin, 'binaryen_js.js') BINARYEN_WASM = os.path.join(options.binaryen_bin, 'binaryen_wasm.js') +BINARYEN_EMBIND = os.path.join(options.binaryen_bin, 'binaryen_embind_wasm.js') def wrap_with_valgrind(cmd): diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js new file mode 100644 index 00000000000..b7f6ce040c4 --- /dev/null +++ b/test/binaryen-embind.js/basics.js @@ -0,0 +1,13 @@ +const assert = require('node:assert'); +const argv = require('node:process'); + +const binaryen_js_path = argv.argv[2]; + +const factory = require(binaryen_js_path); + +factory().then((Module) => { + assert.ok(Module.Builder, 'the Builder class must be exposed'); + + console.log('success.'); +}); + From f78c683a99f3a51b30c52858cda1c1108008797c Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 15:58:44 -0700 Subject: [PATCH 11/36] test --- scripts/emcc-tests.sh | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/scripts/emcc-tests.sh b/scripts/emcc-tests.sh index 409ba256ed4..205a38a03f9 100755 --- a/scripts/emcc-tests.sh +++ b/scripts/emcc-tests.sh @@ -4,6 +4,12 @@ set -o errexit set -o pipefail mkdir -p emcc-build + +# TODO +# ninja -C emcc-build binaryen_embind_wasm +# NODE=nodejs ./check.py --binaryen-bin=emcc-build/bin binaryenjs_embind +# + echo "emcc-tests: build:wasm" emcmake cmake -B emcc-build -DCMAKE_BUILD_TYPE=Release -G Ninja ninja -C emcc-build binaryen_wasm From 9c15c11ded5c31b4b11ccafe2b763b65708c200d Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:28:02 -0700 Subject: [PATCH 12/36] work --- src/binaryen-embind.cpp | 24 ++++++++++++++++++++++++ test/binaryen-embind.js/basics.js | 17 ++++++++++++++--- 2 files changed, 38 insertions(+), 3 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 1b3d2f725a3..2d0e183c889 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -26,8 +26,21 @@ using namespace wasm; using namespace emscripten; +// Wrappers for things that don't quite fit with embind. +namespace { + +std::string stringify(Module& wasm) { + std::stringstream str; + str << wasm; + return str.str(); +} + +} // anonymous namespace + EMSCRIPTEN_BINDINGS(Binaryen) { + function("stringify", &stringify); + class_("Type") .function("isTuple", &Type::isTuple) .function("isRef", &Type::isRef) @@ -51,6 +64,16 @@ EMSCRIPTEN_BINDINGS(Binaryen) { // All Expression classes... + // Module-level constructs. + + class_("Named") + .property("name", &Named::name); + + class_("Importable") + .property("module", &Importable::module) + .property("base", &Importable::base) + ; + class_("Function") ; @@ -63,6 +86,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { ; class_("Module") + .smart_ptr_constructor("Module", &std::make_shared) .property("start", &Module::start) .function("getFunction", &Module::getFunction, allow_raw_pointers()) .function("getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index b7f6ce040c4..123e8fe9aa1 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -3,10 +3,21 @@ const argv = require('node:process'); const binaryen_js_path = argv.argv[2]; -const factory = require(binaryen_js_path); +const binaryenFactory = require(binaryen_js_path); -factory().then((Module) => { - assert.ok(Module.Builder, 'the Builder class must be exposed'); +binaryenFactory().then((binaryen) => { + // Basic smoke test that something got exposed at all. + assert.ok(binaryen.Builder, 'the Builder class must be exposed'); + + // Create a Module. + var module = new binaryen.Module(); + + // Check it prints out as empty. + assert.equal(binaryen.stringify(module), +`(module +) +` + ); console.log('success.'); }); From 72e1808bba9eb963b5a5c940845609346c4ab05f Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:36:10 -0700 Subject: [PATCH 13/36] work --- test/binaryen-embind.js/basics.js | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 123e8fe9aa1..69f62660e95 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -3,21 +3,28 @@ const argv = require('node:process'); const binaryen_js_path = argv.argv[2]; +// Compare after normalizing text by removing extra indentation. +function normEqual(x, y) { + function norm(a) { + a = a.replace(/^\n */g, ''); + a = a.replace(/\n +/g, '\n'); + return a; + } + assert.equal(norm(x), norm(y)); +} + const binaryenFactory = require(binaryen_js_path); binaryenFactory().then((binaryen) => { - // Basic smoke test that something got exposed at all. - assert.ok(binaryen.Builder, 'the Builder class must be exposed'); - // Create a Module. var module = new binaryen.Module(); // Check it prints out as empty. - assert.equal(binaryen.stringify(module), -`(module -) -` - ); + normEqual(binaryen.stringify(module), + ` + (module + ) + `); console.log('success.'); }); From a176ae1ebb8ca8a1c05946211cb06239886d5fb9 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:41:53 -0700 Subject: [PATCH 14/36] work --- src/binaryen-embind.cpp | 16 +++++++++++++++- test/binaryen-embind.js/basics.js | 4 +++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 2d0e183c889..99a86c8472a 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -77,9 +77,23 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Function") ; + class_("NameType") + .constructor() + .property("name", &NameType::name) + .property("type", &NameType::type) + ; + + register_vector("NameTypeVec"); + class_("Builder") .constructor() - .function("makeFunction", select_overload (Name, std::vector&&, HeapType, std::vector&& vars, Expression*)>(&Builder::makeFunction), allow_raw_pointers()) + .function("makeFunction", + select_overload (Name, + std::vector&&, + HeapType, + std::vector&& vars, + Expression*) + >(&Builder::makeFunction), allow_raw_pointers()) // All Expression classes... .function("makeNop", &Builder::makeNop, allow_raw_pointers()) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 69f62660e95..407bbe2e944 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -17,7 +17,7 @@ const binaryenFactory = require(binaryen_js_path); binaryenFactory().then((binaryen) => { // Create a Module. - var module = new binaryen.Module(); + const module = new binaryen.Module(); // Check it prints out as empty. normEqual(binaryen.stringify(module), @@ -26,6 +26,8 @@ binaryenFactory().then((binaryen) => { ) `); + const builder = new binaryen.Builder(module); + const func = builder.makeFunction("foo", console.log('success.'); }); From db1664892326243b990575e29d2c0284e6f8323d Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:45:54 -0700 Subject: [PATCH 15/36] work --- src/binaryen-embind.cpp | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 99a86c8472a..cffaa7286e4 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -54,7 +54,18 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("isArray", &Type::isArray) .function("isException", &Type::isException) .function("isString", &Type::isString) - .function("isDefaultable", &Type::isDefaultable); + .function("isDefaultable", &Type::isDefaultable) + .function("getHeapType", &Type::getHeapType) + ; + + class_("Signature") + .property("params", &Signature::params) + .property("results", &Signature::results) + ; + + class_("HeapType") + .constructor() + ; class_("Name") .constructor(); @@ -72,16 +83,16 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Importable") .property("module", &Importable::module) .property("base", &Importable::base) - ; + ; class_("Function") - ; + ; class_("NameType") .constructor() .property("name", &NameType::name) .property("type", &NameType::type) - ; + ; register_vector("NameTypeVec"); @@ -95,9 +106,9 @@ EMSCRIPTEN_BINDINGS(Binaryen) { Expression*) >(&Builder::makeFunction), allow_raw_pointers()) - // All Expression classes... - .function("makeNop", &Builder::makeNop, allow_raw_pointers()) - ; + // All Expression classes... + .function("makeNop", &Builder::makeNop, allow_raw_pointers()) + ; class_("Module") .smart_ptr_constructor("Module", &std::make_shared) @@ -105,6 +116,6 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("getFunction", &Module::getFunction, allow_raw_pointers()) .function("getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) .function("addFunction", select_overload(&Module::addFunction), allow_raw_pointers()) - ; + ; } From 3c95d367821a697de910632a24a9173a72eb104f Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:48:05 -0700 Subject: [PATCH 16/36] work --- src/binaryen-embind.cpp | 6 +++--- test/binaryen-embind.js/basics.js | 3 +++ 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index cffaa7286e4..21dc4131ba4 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -58,9 +58,9 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("getHeapType", &Type::getHeapType) ; - class_("Signature") - .property("params", &Signature::params) - .property("results", &Signature::results) + value_object("Signature") + .field("params", &Signature::params) + .field("results", &Signature::results) ; class_("HeapType") diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 407bbe2e944..96d4df86c83 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -27,6 +27,9 @@ binaryenFactory().then((binaryen) => { `); const builder = new binaryen.Builder(module); + + // Generate a function and everything we need for that. + const sig = new binaryen. const func = builder.makeFunction("foo", console.log('success.'); }); From 68a868ec469bcbf5b570f941ce13d08d8649b145 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:52:23 -0700 Subject: [PATCH 17/36] work --- test/binaryen-embind.js/basics.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 96d4df86c83..516f186e9b5 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -29,7 +29,7 @@ binaryenFactory().then((binaryen) => { const builder = new binaryen.Builder(module); // Generate a function and everything we need for that. - const sig = new binaryen. + const sig = new binaryen.Signature(); const func = builder.makeFunction("foo", console.log('success.'); }); From 085862c92edeb8f4969248707569da637cf6113b Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 1 Apr 2024 16:58:38 -0700 Subject: [PATCH 18/36] work --- src/binaryen-embind.cpp | 5 +++++ test/binaryen-embind.js/basics.js | 7 ++++++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 21dc4131ba4..70e2e0b3628 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -41,7 +41,12 @@ EMSCRIPTEN_BINDINGS(Binaryen) { function("stringify", &stringify); + enum_("BasicType") + .value("i32", Type::BasicType::i32) + ; + class_("Type") + .constructor() .function("isTuple", &Type::isTuple) .function("isRef", &Type::isRef) .function("isFunction", &Type::isFunction) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 516f186e9b5..8ff446102e3 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -16,6 +16,11 @@ function normEqual(x, y) { const binaryenFactory = require(binaryen_js_path); binaryenFactory().then((binaryen) => { + console.warn(binaryen.BasicType); + console.warn(binaryen.BasicType.i32); + console.warn(typeof binaryen.BasicType.i32); + assert.equal(binaryen.BasicType.i32, 2); + // Create a Module. const module = new binaryen.Module(); @@ -30,7 +35,7 @@ binaryenFactory().then((binaryen) => { // Generate a function and everything we need for that. const sig = new binaryen.Signature(); - const func = builder.makeFunction("foo", + //const func = builder.makeFunction("foo", console.log('success.'); }); From 989a1b2aa407918bc8e81be965f12df7f924ed4a Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 12:55:55 -0700 Subject: [PATCH 19/36] work --- test/binaryen-embind.js/basics.js | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 8ff446102e3..dbc82f4f04c 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -16,11 +16,6 @@ function normEqual(x, y) { const binaryenFactory = require(binaryen_js_path); binaryenFactory().then((binaryen) => { - console.warn(binaryen.BasicType); - console.warn(binaryen.BasicType.i32); - console.warn(typeof binaryen.BasicType.i32); - assert.equal(binaryen.BasicType.i32, 2); - // Create a Module. const module = new binaryen.Module(); @@ -34,8 +29,21 @@ binaryenFactory().then((binaryen) => { const builder = new binaryen.Builder(module); // Generate a function and everything we need for that. - const sig = new binaryen.Signature(); - //const func = builder.makeFunction("foo", + const i32 = new binaryen.Type(binaryen.BasicType.i32); + const sig = { + params: i32, + results: i32 + }; + const func_ii = new binaryen.HeapType(sig); + const params = new binaryen.NameTypeVec(); + params.push_back(new binaryen.NameType(new binaryen.Name("p0"), i32)); + const vars = new binaryen.NameTypeVec(); + const func = builder.makeFunction( + "foo", + params, + func_ii, + vars + ); console.log('success.'); }); From d45d4cc801d3fae9a1356db84f63510f3ffdd4dc Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 12:58:24 -0700 Subject: [PATCH 20/36] work --- src/binaryen-embind.cpp | 3 +-- test/binaryen-embind.js/basics.js | 6 ++---- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 70e2e0b3628..0ddfa4dae0f 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -105,9 +105,8 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .constructor() .function("makeFunction", select_overload (Name, - std::vector&&, HeapType, - std::vector&& vars, + std::vector&& vars, Expression*) >(&Builder::makeFunction), allow_raw_pointers()) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index dbc82f4f04c..5536b0bee4c 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -35,14 +35,12 @@ binaryenFactory().then((binaryen) => { results: i32 }; const func_ii = new binaryen.HeapType(sig); - const params = new binaryen.NameTypeVec(); - params.push_back(new binaryen.NameType(new binaryen.Name("p0"), i32)); const vars = new binaryen.NameTypeVec(); const func = builder.makeFunction( "foo", - params, func_ii, - vars + vars, + builder.makeNop() ); console.log('success.'); }); From e737c85af59cb155af886c237bca1e3fa270b134 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 13:01:57 -0700 Subject: [PATCH 21/36] work --- src/binaryen-embind.cpp | 3 +++ test/binaryen-embind.js/basics.js | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 0ddfa4dae0f..49d9fe24cac 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -63,6 +63,8 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("getHeapType", &Type::getHeapType) ; + register_vector("TypeVec"); + value_object("Signature") .field("params", &Signature::params) .field("results", &Signature::results) @@ -79,6 +81,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property("type", &Expression::type); // All Expression classes... + class_("Nop"); // Module-level constructs. diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 5536b0bee4c..9648e0e9cec 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -35,7 +35,7 @@ binaryenFactory().then((binaryen) => { results: i32 }; const func_ii = new binaryen.HeapType(sig); - const vars = new binaryen.NameTypeVec(); + const vars = new binaryen.TypeVec(); const func = builder.makeFunction( "foo", func_ii, From 417f7da8fe03813055fc353230fbe1ebae7b4f86 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 13:34:45 -0700 Subject: [PATCH 22/36] work --- src/binaryen-embind.cpp | 6 ++---- test/binaryen-embind.js/basics.js | 17 +++++++++++++++-- 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 49d9fe24cac..793b5567529 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -62,7 +62,6 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("isDefaultable", &Type::isDefaultable) .function("getHeapType", &Type::getHeapType) ; - register_vector("TypeVec"); value_object("Signature") @@ -81,7 +80,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property("type", &Expression::type); // All Expression classes... - class_("Nop"); + class_>("Nop"); // Module-level constructs. @@ -101,12 +100,11 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property("name", &NameType::name) .property("type", &NameType::type) ; - register_vector("NameTypeVec"); class_("Builder") .constructor() - .function("makeFunction", + .class_function("makeFunction", select_overload (Name, HeapType, std::vector&& vars, diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 9648e0e9cec..c37fd986693 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -36,12 +36,25 @@ binaryenFactory().then((binaryen) => { }; const func_ii = new binaryen.HeapType(sig); const vars = new binaryen.TypeVec(); - const func = builder.makeFunction( - "foo", + const func = binaryen.Builder.makeFunction( + new binaryen.Name("foo"), func_ii, vars, builder.makeNop() ); + module.addFunction(func); + + // Check the function prints out ok. + normEqual(binaryen.stringify(module), + ` + (module + (type $0 (func (param i32) (result i32))) + (func $foo (param $0 i32) (result i32) + (nop) + ) + ) + `); + console.log('success.'); }); From 42a7857aeec1fd1c92fbd093b0961f8d72272ff4 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 14:04:06 -0700 Subject: [PATCH 23/36] yolo --- src/binaryen-embind.cpp | 47 +- src/wasm-delegations-fields.def | 800 ++++++++++++------------------ test/binaryen-embind.js/basics.js | 3 + 3 files changed, 368 insertions(+), 482 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 793b5567529..3ed4a39afa4 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -79,9 +79,52 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Expression") .property("type", &Expression::type); - // All Expression classes... class_>("Nop"); + + + +#define DELEGATE_ID id + +#define DELEGATE_START(id) std::cout << "// " #id << '\n'; + +#define DELEGATE_END(id) std::cout << '\n'; + +#define DELEGATE_FIELD_CHILD(id, field) \ + std::cout << "BINARYEN_API BinaryenExpressionRef Binaryen" << #id << "Get" \ + << #field << "(BinaryenExpressionRef expr);\n"; + +#define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ + std::cout << "BINARYEN_API BinaryenExpressionRef Binaryen" << #id << "Get" \ + << #field \ + << "At(BinaryenExpressionRef expr, BinaryenIndex index);\n"; + +// TODO +#define DELEGATE_FIELD_TYPE(id, field) +#define DELEGATE_FIELD_HEAPTYPE(id, field) +#define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) +#define DELEGATE_FIELD_INT(id, field) +#define DELEGATE_FIELD_LITERAL(id, field) +#define DELEGATE_FIELD_NAME(id, field) +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) +#define DELEGATE_FIELD_ADDRESS(id, field) +#define DELEGATE_FIELD_INT_ARRAY(id, field) +#define DELEGATE_FIELD_INT_VECTOR(id, field) +#define DELEGATE_FIELD_NAME_VECTOR(id, field) +#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) +#define DELEGATE_FIELD_TYPE_VECTOR(id, field) + +#define DELEGATE(clazz) \ + class_>(#clazz) +#include "wasm-delegations-fields.def" + ; + +#include "wasm-delegations.def" + + + + // Module-level constructs. class_("Named") @@ -111,7 +154,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { Expression*) >(&Builder::makeFunction), allow_raw_pointers()) - // All Expression classes... + // TODO All Expression classes... .function("makeNop", &Builder::makeNop, allow_raw_pointers()) ; diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index 02674e8b26b..ef89fcea6f8 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -228,96 +228,99 @@ #error please define DELEGATE_FIELD_ADDRESS(id, field) #endif -switch (DELEGATE_ID) { - case Expression::Id::InvalidId: - case Expression::Id::NumExpressionIds: { - WASM_UNREACHABLE("unexpected expression type"); +// By default we emit a switch and cases, but that can be customized using the +// following: +#ifndef DELEGATE_FIELD_MAIN_START +#define DELEGATE_FIELD_MAIN_START \ +switch (DELEGATE_ID) { \ + case Expression::Id::InvalidId: \ + case Expression::Id::NumExpressionIds: { \ + WASM_UNREACHABLE("unexpected expression type"); \ } - case Expression::Id::BlockId: { - DELEGATE_START(Block); +#endif + +#ifndef DELEGATE_FIELD_MAIN_END +#define DELEGATE_FIELD_MAIN_END \ +} +#endif + +#ifndef DELEGATE_FIELD_CASE_START +#define DELEGATE_FIELD_CASE_START(id) \ + case Expression::Id::id#Id: { \ + DELEGATE_START(id); +#endif + +#ifndef DELEGATE_FIELD_CASE_END +#define DELEGATE_FIELD_CASE_END \ + DELEGATE_END(id); \ + break; \ + } +#endif + +DELEGATE_FIELD_MAIN_START + +DELEGATE_FIELD_CASE_START(Block) DELEGATE_FIELD_CHILD_VECTOR(Block, list); DELEGATE_FIELD_SCOPE_NAME_DEF(Block, name); - DELEGATE_END(Block); - break; - } - case Expression::Id::IfId: { - DELEGATE_START(If); +DELEGATE_FIELD_CASE_END(Block) + +DELEGATE_FIELD_CASE_START(If) DELEGATE_FIELD_OPTIONAL_CHILD(If, ifFalse); DELEGATE_FIELD_CHILD(If, ifTrue); DELEGATE_FIELD_CHILD(If, condition); - DELEGATE_END(If); - break; - } - case Expression::Id::LoopId: { - DELEGATE_START(Loop); +DELEGATE_FIELD_CASE_END(If) + +DELEGATE_FIELD_CASE_START(Loop) DELEGATE_FIELD_CHILD(Loop, body); DELEGATE_FIELD_SCOPE_NAME_DEF(Loop, name); - DELEGATE_END(Loop); - break; - } - case Expression::Id::BreakId: { - DELEGATE_START(Break); +DELEGATE_FIELD_CASE_END(Loop) + +DELEGATE_FIELD_CASE_START(Break) DELEGATE_FIELD_OPTIONAL_CHILD(Break, condition); DELEGATE_FIELD_OPTIONAL_CHILD(Break, value); DELEGATE_FIELD_SCOPE_NAME_USE(Break, name); - DELEGATE_END(Break); - break; - } - case Expression::Id::SwitchId: { - DELEGATE_START(Switch); +DELEGATE_FIELD_CASE_END(Break) + +DELEGATE_FIELD_CASE_START(Switch) DELEGATE_FIELD_CHILD(Switch, condition); DELEGATE_FIELD_OPTIONAL_CHILD(Switch, value); DELEGATE_FIELD_SCOPE_NAME_USE(Switch, default_); DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Switch, targets); - DELEGATE_END(Switch); - break; - } - case Expression::Id::CallId: { - DELEGATE_START(Call); +DELEGATE_FIELD_CASE_END(Switch) + +DELEGATE_FIELD_CASE_START(Call) DELEGATE_FIELD_CHILD_VECTOR(Call, operands); DELEGATE_FIELD_NAME_KIND(Call, target, ModuleItemKind::Function); DELEGATE_FIELD_INT(Call, isReturn); - DELEGATE_END(Call); - break; - } - case Expression::Id::CallIndirectId: { - DELEGATE_START(CallIndirect); +DELEGATE_FIELD_CASE_END(Call) + +DELEGATE_FIELD_CASE_START(CallIndirect) DELEGATE_FIELD_CHILD(CallIndirect, target); DELEGATE_FIELD_NAME_KIND(CallIndirect, table, ModuleItemKind::Table); DELEGATE_FIELD_CHILD_VECTOR(CallIndirect, operands); DELEGATE_FIELD_HEAPTYPE(CallIndirect, heapType); DELEGATE_FIELD_INT(CallIndirect, isReturn); - DELEGATE_END(CallIndirect); - break; - } - case Expression::Id::LocalGetId: { - DELEGATE_START(LocalGet); +DELEGATE_FIELD_CASE_END(CallIndirect) + +DELEGATE_FIELD_CASE_START(LocalGet) DELEGATE_FIELD_INT(LocalGet, index); - DELEGATE_END(LocalGet); - break; - } - case Expression::Id::LocalSetId: { - DELEGATE_START(LocalSet); +DELEGATE_FIELD_CASE_END(LocalGet) + +DELEGATE_FIELD_CASE_START(LocalSet) DELEGATE_FIELD_CHILD(LocalSet, value); DELEGATE_FIELD_INT(LocalSet, index); - DELEGATE_END(LocalSet); - break; - } - case Expression::Id::GlobalGetId: { - DELEGATE_START(GlobalGet); +DELEGATE_FIELD_CASE_END(LocalSet) + +DELEGATE_FIELD_CASE_START(GlobalGet) DELEGATE_FIELD_NAME_KIND(GlobalGet, name, ModuleItemKind::Global); - DELEGATE_END(GlobalGet); - break; - } - case Expression::Id::GlobalSetId: { - DELEGATE_START(GlobalSet); +DELEGATE_FIELD_CASE_END(GlobalGet) + +DELEGATE_FIELD_CASE_START(GlobalSet) DELEGATE_FIELD_CHILD(GlobalSet, value); DELEGATE_FIELD_NAME_KIND(GlobalSet, name, ModuleItemKind::Global); - DELEGATE_END(GlobalSet); - break; - } - case Expression::Id::LoadId: { - DELEGATE_START(Load); +DELEGATE_FIELD_CASE_END(GlobalSet) + +DELEGATE_FIELD_CASE_START(Load) DELEGATE_FIELD_CHILD(Load, ptr); DELEGATE_FIELD_INT(Load, bytes); DELEGATE_FIELD_INT(Load, signed_); @@ -325,11 +328,9 @@ switch (DELEGATE_ID) { DELEGATE_FIELD_ADDRESS(Load, align); DELEGATE_FIELD_INT(Load, isAtomic); DELEGATE_FIELD_NAME_KIND(Load, memory, ModuleItemKind::Memory); - DELEGATE_END(Load); - break; - } - case Expression::Id::StoreId: { - DELEGATE_START(Store); +DELEGATE_FIELD_CASE_END(Load) + +DELEGATE_FIELD_CASE_START(Store) DELEGATE_FIELD_CHILD(Store, value); DELEGATE_FIELD_CHILD(Store, ptr); DELEGATE_FIELD_INT(Store, bytes); @@ -338,111 +339,87 @@ switch (DELEGATE_ID) { DELEGATE_FIELD_INT(Store, isAtomic); DELEGATE_FIELD_TYPE(Store, valueType); DELEGATE_FIELD_NAME_KIND(Store, memory, ModuleItemKind::Memory); - DELEGATE_END(Store); - break; - } - case Expression::Id::AtomicRMWId: { - DELEGATE_START(AtomicRMW); +DELEGATE_FIELD_CASE_END(Store) + +DELEGATE_FIELD_CASE_START(AtomicRMW) DELEGATE_FIELD_CHILD(AtomicRMW, value); DELEGATE_FIELD_CHILD(AtomicRMW, ptr); DELEGATE_FIELD_INT(AtomicRMW, op); DELEGATE_FIELD_INT(AtomicRMW, bytes); DELEGATE_FIELD_ADDRESS(AtomicRMW, offset); DELEGATE_FIELD_NAME_KIND(AtomicRMW, memory, ModuleItemKind::Memory); - DELEGATE_END(AtomicRMW); - break; - } - case Expression::Id::AtomicCmpxchgId: { - DELEGATE_START(AtomicCmpxchg); +DELEGATE_FIELD_CASE_END(AtomicRMW) + +DELEGATE_FIELD_CASE_START(AtomicCmpxchg) DELEGATE_FIELD_CHILD(AtomicCmpxchg, replacement); DELEGATE_FIELD_CHILD(AtomicCmpxchg, expected); DELEGATE_FIELD_CHILD(AtomicCmpxchg, ptr); DELEGATE_FIELD_INT(AtomicCmpxchg, bytes); DELEGATE_FIELD_ADDRESS(AtomicCmpxchg, offset); DELEGATE_FIELD_NAME_KIND(AtomicCmpxchg, memory, ModuleItemKind::Memory); - DELEGATE_END(AtomicCmpxchg); - break; - } - case Expression::Id::AtomicWaitId: { - DELEGATE_START(AtomicWait); +DELEGATE_FIELD_CASE_END(AtomicCmpxchg) + +DELEGATE_FIELD_CASE_START(AtomicWait) DELEGATE_FIELD_CHILD(AtomicWait, timeout); DELEGATE_FIELD_CHILD(AtomicWait, expected); DELEGATE_FIELD_CHILD(AtomicWait, ptr); DELEGATE_FIELD_ADDRESS(AtomicWait, offset); DELEGATE_FIELD_TYPE(AtomicWait, expectedType); DELEGATE_FIELD_NAME_KIND(AtomicWait, memory, ModuleItemKind::Memory); - DELEGATE_END(AtomicWait); - break; - } - case Expression::Id::AtomicNotifyId: { - DELEGATE_START(AtomicNotify); +DELEGATE_FIELD_CASE_END(AtomicWait) + +DELEGATE_FIELD_CASE_START(AtomicNotify) DELEGATE_FIELD_CHILD(AtomicNotify, notifyCount); DELEGATE_FIELD_CHILD(AtomicNotify, ptr); DELEGATE_FIELD_ADDRESS(AtomicNotify, offset); DELEGATE_FIELD_NAME_KIND(AtomicNotify, memory, ModuleItemKind::Memory); - DELEGATE_END(AtomicNotify); - break; - } - case Expression::Id::AtomicFenceId: { - DELEGATE_START(AtomicFence); +DELEGATE_FIELD_CASE_END(AtomicNotify) + +DELEGATE_FIELD_CASE_START(AtomicFence) DELEGATE_FIELD_INT(AtomicFence, order); - DELEGATE_END(AtomicFence); - break; - } - case Expression::Id::SIMDExtractId: { - DELEGATE_START(SIMDExtract); +DELEGATE_FIELD_CASE_END(AtomicFence) + +DELEGATE_FIELD_CASE_START(SIMDExtract) DELEGATE_FIELD_CHILD(SIMDExtract, vec); DELEGATE_FIELD_INT(SIMDExtract, op); DELEGATE_FIELD_INT(SIMDExtract, index); - DELEGATE_END(SIMDExtract); - break; - } - case Expression::Id::SIMDReplaceId: { - DELEGATE_START(SIMDReplace); +DELEGATE_FIELD_CASE_END(SIMDExtract) + +DELEGATE_FIELD_CASE_START(SIMDReplace) DELEGATE_FIELD_CHILD(SIMDReplace, value); DELEGATE_FIELD_CHILD(SIMDReplace, vec); DELEGATE_FIELD_INT(SIMDReplace, op); DELEGATE_FIELD_INT(SIMDReplace, index); - DELEGATE_END(SIMDReplace); - break; - } - case Expression::Id::SIMDShuffleId: { - DELEGATE_START(SIMDShuffle); +DELEGATE_FIELD_CASE_END(SIMDReplace) + +DELEGATE_FIELD_CASE_START(SIMDShuffle) DELEGATE_FIELD_CHILD(SIMDShuffle, right); DELEGATE_FIELD_CHILD(SIMDShuffle, left); DELEGATE_FIELD_INT_ARRAY(SIMDShuffle, mask); - DELEGATE_END(SIMDShuffle); - break; - } - case Expression::Id::SIMDTernaryId: { - DELEGATE_START(SIMDTernary); +DELEGATE_FIELD_CASE_END(SIMDShuffle) + +DELEGATE_FIELD_CASE_START(SIMDTernary) DELEGATE_FIELD_CHILD(SIMDTernary, c); DELEGATE_FIELD_CHILD(SIMDTernary, b); DELEGATE_FIELD_CHILD(SIMDTernary, a); DELEGATE_FIELD_INT(SIMDTernary, op); - DELEGATE_END(SIMDTernary); - break; - } - case Expression::Id::SIMDShiftId: { - DELEGATE_START(SIMDShift); +DELEGATE_FIELD_CASE_END(SIMDTernary) + +DELEGATE_FIELD_CASE_START(SIMDShift) DELEGATE_FIELD_CHILD(SIMDShift, shift); DELEGATE_FIELD_CHILD(SIMDShift, vec); DELEGATE_FIELD_INT(SIMDShift, op); - DELEGATE_END(SIMDShift); - break; - } - case Expression::Id::SIMDLoadId: { - DELEGATE_START(SIMDLoad); +DELEGATE_FIELD_CASE_END(SIMDShift) + +DELEGATE_FIELD_CASE_START(SIMDLoad) DELEGATE_FIELD_CHILD(SIMDLoad, ptr); DELEGATE_FIELD_INT(SIMDLoad, op); DELEGATE_FIELD_ADDRESS(SIMDLoad, offset); DELEGATE_FIELD_ADDRESS(SIMDLoad, align); DELEGATE_FIELD_NAME_KIND(SIMDLoad, memory, ModuleItemKind::Memory); - DELEGATE_END(SIMDLoad); - break; - } - case Expression::Id::SIMDLoadStoreLaneId: { - DELEGATE_START(SIMDLoadStoreLane); +DELEGATE_FIELD_CASE_END(SIMDLoad) + +DELEGATE_FIELD_CASE_START(SIMDLoadStoreLane) DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, vec); DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, ptr); DELEGATE_FIELD_INT(SIMDLoadStoreLane, op); @@ -450,537 +427,394 @@ switch (DELEGATE_ID) { DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, align); DELEGATE_FIELD_INT(SIMDLoadStoreLane, index); DELEGATE_FIELD_NAME_KIND(SIMDLoadStoreLane, memory, ModuleItemKind::Memory); - DELEGATE_END(SIMDLoadStoreLane); - break; - } - case Expression::Id::MemoryInitId: { - DELEGATE_START(MemoryInit); +DELEGATE_FIELD_CASE_END(SIMDLoadStoreLane) + +DELEGATE_FIELD_CASE_START(MemoryInit) DELEGATE_FIELD_CHILD(MemoryInit, size); DELEGATE_FIELD_CHILD(MemoryInit, offset); DELEGATE_FIELD_CHILD(MemoryInit, dest); DELEGATE_FIELD_NAME_KIND(MemoryInit, segment, ModuleItemKind::DataSegment); DELEGATE_FIELD_NAME_KIND(MemoryInit, memory, ModuleItemKind::Memory); - DELEGATE_END(MemoryInit); - break; - } - case Expression::Id::DataDropId: { - DELEGATE_START(DataDrop); +DELEGATE_FIELD_CASE_END(MemoryInit) + +DELEGATE_FIELD_CASE_START(DataDrop) DELEGATE_FIELD_NAME_KIND(DataDrop, segment, ModuleItemKind::DataSegment); - DELEGATE_END(DataDrop); - break; - } - case Expression::Id::MemoryCopyId: { - DELEGATE_START(MemoryCopy); +DELEGATE_FIELD_CASE_END(DataDrop) + +DELEGATE_FIELD_CASE_START(MemoryCopy) DELEGATE_FIELD_CHILD(MemoryCopy, size); DELEGATE_FIELD_CHILD(MemoryCopy, source); DELEGATE_FIELD_CHILD(MemoryCopy, dest); DELEGATE_FIELD_NAME_KIND(MemoryCopy, sourceMemory, ModuleItemKind::Memory); DELEGATE_FIELD_NAME_KIND(MemoryCopy, destMemory, ModuleItemKind::Memory); - DELEGATE_END(MemoryCopy); - break; - } - case Expression::Id::MemoryFillId: { - DELEGATE_START(MemoryFill); +DELEGATE_FIELD_CASE_END(MemoryCopy) + +DELEGATE_FIELD_CASE_START(MemoryFill) DELEGATE_FIELD_CHILD(MemoryFill, size); DELEGATE_FIELD_CHILD(MemoryFill, value); DELEGATE_FIELD_CHILD(MemoryFill, dest); DELEGATE_FIELD_NAME_KIND(MemoryFill, memory, ModuleItemKind::Memory); - DELEGATE_END(MemoryFill); - break; - } - case Expression::Id::ConstId: { - DELEGATE_START(Const); +DELEGATE_FIELD_CASE_END(MemoryFill) + +DELEGATE_FIELD_CASE_START(Const) DELEGATE_FIELD_LITERAL(Const, value); - DELEGATE_END(Const); - break; - } - case Expression::Id::UnaryId: { - DELEGATE_START(Unary); +DELEGATE_FIELD_CASE_END(Const) + +DELEGATE_FIELD_CASE_START(Unary) DELEGATE_FIELD_CHILD(Unary, value); DELEGATE_FIELD_INT(Unary, op); - DELEGATE_END(Unary); - break; - } - case Expression::Id::BinaryId: { - DELEGATE_START(Binary); +DELEGATE_FIELD_CASE_END(Unary) + +DELEGATE_FIELD_CASE_START(Binary) DELEGATE_FIELD_CHILD(Binary, right); DELEGATE_FIELD_CHILD(Binary, left); DELEGATE_FIELD_INT(Binary, op); - DELEGATE_END(Binary); - break; - } - case Expression::Id::SelectId: { - DELEGATE_START(Select); +DELEGATE_FIELD_CASE_END(Binary) + +DELEGATE_FIELD_CASE_START(Select) DELEGATE_FIELD_CHILD(Select, condition); DELEGATE_FIELD_CHILD(Select, ifFalse); DELEGATE_FIELD_CHILD(Select, ifTrue); - DELEGATE_END(Select); - break; - } - case Expression::Id::DropId: { - DELEGATE_START(Drop); +DELEGATE_FIELD_CASE_END(Select) + +DELEGATE_FIELD_CASE_START(Drop) DELEGATE_FIELD_CHILD(Drop, value); - DELEGATE_END(Drop); - break; - } - case Expression::Id::ReturnId: { - DELEGATE_START(Return); +DELEGATE_FIELD_CASE_END(Drop) + +DELEGATE_FIELD_CASE_START(Return) DELEGATE_FIELD_OPTIONAL_CHILD(Return, value); - DELEGATE_END(Return); - break; - } - case Expression::Id::MemorySizeId: { - DELEGATE_START(MemorySize); +DELEGATE_FIELD_CASE_END(Return) + +DELEGATE_FIELD_CASE_START(MemorySize) DELEGATE_FIELD_TYPE(MemorySize, ptrType); DELEGATE_FIELD_NAME_KIND(MemorySize, memory, ModuleItemKind::Memory); - DELEGATE_END(MemorySize); - break; - } - case Expression::Id::MemoryGrowId: { - DELEGATE_START(MemoryGrow); +DELEGATE_FIELD_CASE_END(MemorySize) + +DELEGATE_FIELD_CASE_START(MemoryGrow) DELEGATE_FIELD_TYPE(MemoryGrow, ptrType); DELEGATE_FIELD_CHILD(MemoryGrow, delta); DELEGATE_FIELD_NAME_KIND(MemoryGrow, memory, ModuleItemKind::Memory); - DELEGATE_END(MemoryGrow); - break; - } - case Expression::Id::RefNullId: { - DELEGATE_START(RefNull); - DELEGATE_END(RefNull); - break; - } - case Expression::Id::RefIsNullId: { - DELEGATE_START(RefIsNull); +DELEGATE_FIELD_CASE_END(MemoryGrow) + +DELEGATE_FIELD_CASE_START(RefNull) +DELEGATE_FIELD_CASE_END(RefNull) + +DELEGATE_FIELD_CASE_START(RefIsNull) DELEGATE_FIELD_CHILD(RefIsNull, value); - DELEGATE_END(RefIsNull); - break; - } - case Expression::Id::RefFuncId: { - DELEGATE_START(RefFunc); +DELEGATE_FIELD_CASE_END(RefIsNull) + +DELEGATE_FIELD_CASE_START(RefFunc) DELEGATE_FIELD_NAME_KIND(RefFunc, func, ModuleItemKind::Function); - DELEGATE_END(RefFunc); - break; - } - case Expression::Id::RefEqId: { - DELEGATE_START(RefEq); +DELEGATE_FIELD_CASE_END(RefFunc) + +DELEGATE_FIELD_CASE_START(RefEq) DELEGATE_FIELD_CHILD(RefEq, right); DELEGATE_FIELD_CHILD(RefEq, left); - DELEGATE_END(RefEq); - break; - } - case Expression::Id::TableGetId: { - DELEGATE_START(TableGet); +DELEGATE_FIELD_CASE_END(RefEq) + +DELEGATE_FIELD_CASE_START(TableGet) DELEGATE_FIELD_CHILD(TableGet, index); DELEGATE_FIELD_NAME_KIND(TableGet, table, ModuleItemKind::Table); - DELEGATE_END(TableGet); - break; - } - case Expression::Id::TableSetId: { - DELEGATE_START(TableSet); +DELEGATE_FIELD_CASE_END(TableGet) + +DELEGATE_FIELD_CASE_START(TableSet) DELEGATE_FIELD_CHILD(TableSet, value); DELEGATE_FIELD_CHILD(TableSet, index); DELEGATE_FIELD_NAME_KIND(TableSet, table, ModuleItemKind::Table); - DELEGATE_END(TableSet); - break; - } - case Expression::Id::TableSizeId: { - DELEGATE_START(TableSize); +DELEGATE_FIELD_CASE_END(TableSet) + +DELEGATE_FIELD_CASE_START(TableSize) DELEGATE_FIELD_NAME_KIND(TableSize, table, ModuleItemKind::Table); - DELEGATE_END(TableSize); - break; - } - case Expression::Id::TableGrowId: { - DELEGATE_START(TableGrow); +DELEGATE_FIELD_CASE_END(TableSize) + +DELEGATE_FIELD_CASE_START(TableGrow) DELEGATE_FIELD_CHILD(TableGrow, delta); DELEGATE_FIELD_CHILD(TableGrow, value); DELEGATE_FIELD_NAME_KIND(TableGrow, table, ModuleItemKind::Table); - DELEGATE_END(TableGrow); - break; - } - case Expression::Id::TableFillId: { - DELEGATE_START(TableFill); +DELEGATE_FIELD_CASE_END(TableGrow) + +DELEGATE_FIELD_CASE_START(TableFill) DELEGATE_FIELD_CHILD(TableFill, size); DELEGATE_FIELD_CHILD(TableFill, value); DELEGATE_FIELD_CHILD(TableFill, dest); DELEGATE_FIELD_NAME_KIND(TableFill, table, ModuleItemKind::Table); - DELEGATE_END(TableFill); - break; - } - case Expression::Id::TableCopyId: { - DELEGATE_START(TableCopy); +DELEGATE_FIELD_CASE_END(TableFill) + +DELEGATE_FIELD_CASE_START(TableCopy) DELEGATE_FIELD_CHILD(TableCopy, size); DELEGATE_FIELD_CHILD(TableCopy, source); DELEGATE_FIELD_CHILD(TableCopy, dest); DELEGATE_FIELD_NAME_KIND(TableCopy, sourceTable, ModuleItemKind::Table); DELEGATE_FIELD_NAME_KIND(TableCopy, destTable, ModuleItemKind::Table); - DELEGATE_END(TableCopy); - break; - } - case Expression::Id::TryId: { - DELEGATE_START(Try); +DELEGATE_FIELD_CASE_END(TableCopy) + +DELEGATE_FIELD_CASE_START(Try) DELEGATE_FIELD_SCOPE_NAME_USE(Try, delegateTarget); DELEGATE_FIELD_CHILD_VECTOR(Try, catchBodies); DELEGATE_FIELD_NAME_KIND_VECTOR(Try, catchTags, ModuleItemKind::Tag); DELEGATE_FIELD_SCOPE_NAME_DEF(Try, name); DELEGATE_FIELD_CHILD(Try, body); - DELEGATE_END(Try); - break; - } - case Expression::Id::TryTableId: { - DELEGATE_START(TryTable); +DELEGATE_FIELD_CASE_END(Try) + +DELEGATE_FIELD_CASE_START(TryTable) DELEGATE_FIELD_TYPE_VECTOR(TryTable, sentTypes); DELEGATE_FIELD_INT_VECTOR(TryTable, catchRefs); DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(TryTable, catchDests); DELEGATE_FIELD_NAME_KIND_VECTOR(TryTable, catchTags, ModuleItemKind::Tag); DELEGATE_FIELD_CHILD(TryTable, body); - DELEGATE_END(TryTable); - break; - } - case Expression::Id::ThrowId: { - DELEGATE_START(Throw); +DELEGATE_FIELD_CASE_END(TryTable) + +DELEGATE_FIELD_CASE_START(Throw) DELEGATE_FIELD_CHILD_VECTOR(Throw, operands); DELEGATE_FIELD_NAME_KIND(Throw, tag, ModuleItemKind::Tag); - DELEGATE_END(Throw); - break; - } - case Expression::Id::RethrowId: { - DELEGATE_START(Rethrow); +DELEGATE_FIELD_CASE_END(Throw) + +DELEGATE_FIELD_CASE_START(Rethrow) DELEGATE_FIELD_SCOPE_NAME_USE(Rethrow, target); - DELEGATE_END(Rethrow); - break; - } - case Expression::Id::ThrowRefId: { - DELEGATE_START(ThrowRef); +DELEGATE_FIELD_CASE_END(Rethrow) + +DELEGATE_FIELD_CASE_START(ThrowRef) DELEGATE_FIELD_CHILD(ThrowRef, exnref); - DELEGATE_END(ThrowRef); - break; - } - case Expression::Id::NopId: { - DELEGATE_START(Nop); - DELEGATE_END(Nop); - break; - } - case Expression::Id::UnreachableId: { - DELEGATE_START(Unreachable); - DELEGATE_END(Unreachable); - break; - } - case Expression::Id::PopId: { - DELEGATE_START(Pop); - DELEGATE_END(Pop); - break; - } - case Expression::Id::TupleMakeId: { - DELEGATE_START(TupleMake); +DELEGATE_FIELD_CASE_END(ThrowRef) + +DELEGATE_FIELD_CASE_START(Nop) +DELEGATE_FIELD_CASE_END(Nop) + +DELEGATE_FIELD_CASE_START(Unreachable) +DELEGATE_FIELD_CASE_END(Unreachable) + +DELEGATE_FIELD_CASE_START(Pop) +DELEGATE_FIELD_CASE_END(Pop) + +DELEGATE_FIELD_CASE_START(TupleMake) DELEGATE_FIELD_CHILD_VECTOR(Tuple, operands); - DELEGATE_END(TupleMake); - break; - } - case Expression::Id::TupleExtractId: { - DELEGATE_START(TupleExtract); +DELEGATE_FIELD_CASE_END(TupleMake) + +DELEGATE_FIELD_CASE_START(TupleExtract) DELEGATE_FIELD_CHILD(TupleExtract, tuple); DELEGATE_FIELD_INT(TupleExtract, index); - DELEGATE_END(TupleExtract); - break; - } - case Expression::Id::RefI31Id: { - DELEGATE_START(RefI31); +DELEGATE_FIELD_CASE_END(TupleExtract) + +DELEGATE_FIELD_CASE_START(RefI31) DELEGATE_FIELD_CHILD(RefI31, value); - DELEGATE_END(RefI31); - break; - } - case Expression::Id::I31GetId: { - DELEGATE_START(I31Get); +DELEGATE_FIELD_CASE_END(RefI31) + +DELEGATE_FIELD_CASE_START(I31Get) DELEGATE_FIELD_CHILD(I31Get, i31); DELEGATE_FIELD_INT(I31Get, signed_); - DELEGATE_END(I31Get); - break; - } - case Expression::Id::CallRefId: { - DELEGATE_START(CallRef); +DELEGATE_FIELD_CASE_END(I31Get) + +DELEGATE_FIELD_CASE_START(CallRef) DELEGATE_FIELD_CHILD(CallRef, target); DELEGATE_FIELD_CHILD_VECTOR(CallRef, operands); DELEGATE_FIELD_INT(CallRef, isReturn); - DELEGATE_END(CallRef); - break; - } - case Expression::Id::RefTestId: { - DELEGATE_START(RefTest); +DELEGATE_FIELD_CASE_END(CallRef) + +DELEGATE_FIELD_CASE_START(RefTest) DELEGATE_FIELD_TYPE(RefTest, castType); DELEGATE_FIELD_CHILD(RefTest, ref); - DELEGATE_END(RefTest); - break; - } - case Expression::Id::RefCastId: { - DELEGATE_START(RefCast); +DELEGATE_FIELD_CASE_END(RefTest) + +DELEGATE_FIELD_CASE_START(RefCast) DELEGATE_FIELD_CHILD(RefCast, ref); - DELEGATE_END(RefCast); - break; - } - case Expression::Id::BrOnId: { - DELEGATE_START(BrOn); +DELEGATE_FIELD_CASE_END(RefCast) + +DELEGATE_FIELD_CASE_START(BrOn) DELEGATE_FIELD_INT(BrOn, op); DELEGATE_FIELD_SCOPE_NAME_USE(BrOn, name); DELEGATE_FIELD_TYPE(BrOn, castType); DELEGATE_FIELD_CHILD(BrOn, ref); - DELEGATE_END(BrOn); - break; - } - case Expression::Id::StructNewId: { - DELEGATE_START(StructNew); +DELEGATE_FIELD_CASE_END(BrOn) + +DELEGATE_FIELD_CASE_START(StructNew) DELEGATE_FIELD_CHILD_VECTOR(StructNew, operands); - DELEGATE_END(StructNew); - break; - } - case Expression::Id::StructGetId: { - DELEGATE_START(StructGet); +DELEGATE_FIELD_CASE_END(StructNew) + +DELEGATE_FIELD_CASE_START(StructGet) DELEGATE_FIELD_INT(StructGet, index); DELEGATE_FIELD_CHILD(StructGet, ref); DELEGATE_FIELD_INT(StructGet, signed_); - DELEGATE_END(StructGet); - break; - } - case Expression::Id::StructSetId: { - DELEGATE_START(StructSet); +DELEGATE_FIELD_CASE_END(StructGet) + +DELEGATE_FIELD_CASE_START(StructSet) DELEGATE_FIELD_INT(StructSet, index); DELEGATE_FIELD_CHILD(StructSet, value); DELEGATE_FIELD_CHILD(StructSet, ref); - DELEGATE_END(StructSet); - break; - } - case Expression::Id::ArrayNewId: { - DELEGATE_START(ArrayNew); +DELEGATE_FIELD_CASE_END(StructSet) + +DELEGATE_FIELD_CASE_START(ArrayNew) DELEGATE_FIELD_CHILD(ArrayNew, size); DELEGATE_FIELD_OPTIONAL_CHILD(ArrayNew, init); - DELEGATE_END(ArrayNew); - break; - } - case Expression::Id::ArrayNewDataId: { - DELEGATE_START(ArrayNewData); +DELEGATE_FIELD_CASE_END(ArrayNew) + +DELEGATE_FIELD_CASE_START(ArrayNewData) DELEGATE_FIELD_NAME_KIND(ArrayNewData, segment, ModuleItemKind::DataSegment); DELEGATE_FIELD_CHILD(ArrayNewData, size); DELEGATE_FIELD_CHILD(ArrayNewData, offset); - DELEGATE_END(ArrayNewData); - break; - } - case Expression::Id::ArrayNewElemId: { - DELEGATE_START(ArrayNewElem); +DELEGATE_FIELD_CASE_END(ArrayNewData) + +DELEGATE_FIELD_CASE_START(ArrayNewElem) DELEGATE_FIELD_NAME_KIND(ArrayNewElem, segment, ModuleItemKind::ElementSegment); DELEGATE_FIELD_CHILD(ArrayNewElem, size); DELEGATE_FIELD_CHILD(ArrayNewElem, offset); - DELEGATE_END(ArrayNewElem); - break; - } - case Expression::Id::ArrayNewFixedId: { - DELEGATE_START(ArrayNewFixed); +DELEGATE_FIELD_CASE_END(ArrayNewElem) + +DELEGATE_FIELD_CASE_START(ArrayNewFixed) DELEGATE_FIELD_CHILD_VECTOR(ArrayNewFixed, values); - DELEGATE_END(ArrayNewFixed); - break; - } - case Expression::Id::ArrayGetId: { - DELEGATE_START(ArrayGet); +DELEGATE_FIELD_CASE_END(ArrayNewFixed) + +DELEGATE_FIELD_CASE_START(ArrayGet) DELEGATE_FIELD_CHILD(ArrayGet, index); DELEGATE_FIELD_CHILD(ArrayGet, ref); DELEGATE_FIELD_INT(ArrayGet, signed_); - DELEGATE_END(ArrayGet); - break; - } - case Expression::Id::ArraySetId: { - DELEGATE_START(ArraySet); +DELEGATE_FIELD_CASE_END(ArrayGet) + +DELEGATE_FIELD_CASE_START(ArraySet) DELEGATE_FIELD_CHILD(ArrayGet, value); DELEGATE_FIELD_CHILD(ArrayGet, index); DELEGATE_FIELD_CHILD(ArrayGet, ref); - DELEGATE_END(ArraySet); - break; - } - case Expression::Id::ArrayLenId: { - DELEGATE_START(ArrayLen); +DELEGATE_FIELD_CASE_END(ArraySet) + +DELEGATE_FIELD_CASE_START(ArrayLen) DELEGATE_FIELD_CHILD(ArrayLen, ref); - DELEGATE_END(ArrayLen); - break; - } - case Expression::Id::ArrayCopyId: { - DELEGATE_START(ArrayCopy); +DELEGATE_FIELD_CASE_END(ArrayLen) + +DELEGATE_FIELD_CASE_START(ArrayCopy) DELEGATE_FIELD_CHILD(ArrayCopy, length); DELEGATE_FIELD_CHILD(ArrayCopy, srcIndex); DELEGATE_FIELD_CHILD(ArrayCopy, srcRef); DELEGATE_FIELD_CHILD(ArrayCopy, destIndex); DELEGATE_FIELD_CHILD(ArrayCopy, destRef); - DELEGATE_END(ArrayCopy); - break; - } - case Expression::Id::ArrayFillId: { - DELEGATE_START(ArrayFill); +DELEGATE_FIELD_CASE_END(ArrayCopy) + +DELEGATE_FIELD_CASE_START(ArrayFill) DELEGATE_FIELD_CHILD(ArrayFill, size); DELEGATE_FIELD_CHILD(ArrayFill, value); DELEGATE_FIELD_CHILD(ArrayFill, index); DELEGATE_FIELD_CHILD(ArrayFill, ref); - DELEGATE_END(ArrayFill); - break; - } - case Expression::Id::ArrayInitDataId: { - DELEGATE_START(ArrayInitData); +DELEGATE_FIELD_CASE_END(ArrayFill) + +DELEGATE_FIELD_CASE_START(ArrayInitData) DELEGATE_FIELD_NAME_KIND(ArrayInitData, segment, ModuleItemKind::DataSegment); DELEGATE_FIELD_CHILD(ArrayInitData, size); DELEGATE_FIELD_CHILD(ArrayInitData, offset); DELEGATE_FIELD_CHILD(ArrayInitData, index); DELEGATE_FIELD_CHILD(ArrayInitData, ref); - DELEGATE_END(ArrayInitData); - break; - } - case Expression::Id::ArrayInitElemId: { - DELEGATE_START(ArrayInitElem); +DELEGATE_FIELD_CASE_END(ArrayInitData) + +DELEGATE_FIELD_CASE_START(ArrayInitElem) DELEGATE_FIELD_NAME_KIND(ArrayInitElem, segment, ModuleItemKind::ElementSegment); DELEGATE_FIELD_CHILD(ArrayInitElem, size); DELEGATE_FIELD_CHILD(ArrayInitElem, offset); DELEGATE_FIELD_CHILD(ArrayInitElem, index); DELEGATE_FIELD_CHILD(ArrayInitElem, ref); - DELEGATE_END(ArrayInitElem); - break; - } - case Expression::Id::RefAsId: { - DELEGATE_START(RefAs); +DELEGATE_FIELD_CASE_END(ArrayInitElem) + +DELEGATE_FIELD_CASE_START(RefAs) DELEGATE_FIELD_INT(RefAs, op); DELEGATE_FIELD_CHILD(RefAs, value); - DELEGATE_END(RefAs); - break; - } - case Expression::Id::StringNewId: { - DELEGATE_START(StringNew); +DELEGATE_FIELD_CASE_END(RefAs) + +DELEGATE_FIELD_CASE_START(StringNew) DELEGATE_FIELD_INT(StringNew, op); DELEGATE_FIELD_INT(StringNew, try_); DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, end); DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, start); DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, length); DELEGATE_FIELD_CHILD(StringNew, ptr); - DELEGATE_END(StringNew); - break; - } - case Expression::Id::StringConstId: { - DELEGATE_START(StringConst); +DELEGATE_FIELD_CASE_END(StringNew) + +DELEGATE_FIELD_CASE_START(StringConst) DELEGATE_FIELD_NAME(StringConst, string); - DELEGATE_END(StringConst); - break; - } - case Expression::Id::StringMeasureId: { - DELEGATE_START(StringMeasure); +DELEGATE_FIELD_CASE_END(StringConst) + +DELEGATE_FIELD_CASE_START(StringMeasure) DELEGATE_FIELD_INT(StringMeasure, op); DELEGATE_FIELD_CHILD(StringMeasure, ref); - DELEGATE_END(StringMeasure); - break; - } - case Expression::Id::StringEncodeId: { - DELEGATE_START(StringEncode); +DELEGATE_FIELD_CASE_END(StringMeasure) + +DELEGATE_FIELD_CASE_START(StringEncode) DELEGATE_FIELD_INT(StringEncode, op); DELEGATE_FIELD_OPTIONAL_CHILD(StringEncode, start); DELEGATE_FIELD_CHILD(StringEncode, ptr); DELEGATE_FIELD_CHILD(StringEncode, ref); - DELEGATE_END(StringEncode); - break; - } - case Expression::Id::StringConcatId: { - DELEGATE_START(StringConcat); +DELEGATE_FIELD_CASE_END(StringEncode) + +DELEGATE_FIELD_CASE_START(StringConcat) DELEGATE_FIELD_CHILD(StringConcat, right); DELEGATE_FIELD_CHILD(StringConcat, left); - DELEGATE_END(StringConcat); - break; - } - case Expression::Id::StringEqId: { - DELEGATE_START(StringEq); +DELEGATE_FIELD_CASE_END(StringConcat) + +DELEGATE_FIELD_CASE_START(StringEq) DELEGATE_FIELD_INT(StringEq, op); DELEGATE_FIELD_CHILD(StringEq, right); DELEGATE_FIELD_CHILD(StringEq, left); - DELEGATE_END(StringEq); - break; - } - case Expression::Id::StringAsId: { - DELEGATE_START(StringAs); +DELEGATE_FIELD_CASE_END(StringEq) + +DELEGATE_FIELD_CASE_START(StringAs) DELEGATE_FIELD_INT(StringAs, op); DELEGATE_FIELD_CHILD(StringAs, ref); - DELEGATE_END(StringAs); - break; - } - case Expression::Id::StringWTF8AdvanceId: { - DELEGATE_START(StringWTF8Advance); +DELEGATE_FIELD_CASE_END(StringAs) + +DELEGATE_FIELD_CASE_START(StringWTF8Advance) DELEGATE_FIELD_CHILD(StringWTF8Advance, bytes); DELEGATE_FIELD_CHILD(StringWTF8Advance, pos); DELEGATE_FIELD_CHILD(StringWTF8Advance, ref); - DELEGATE_END(StringWTF8Advance); - break; - } - case Expression::Id::StringWTF16GetId: { - DELEGATE_START(StringWTF16Get); +DELEGATE_FIELD_CASE_END(StringWTF8Advance) + +DELEGATE_FIELD_CASE_START(StringWTF16Get) DELEGATE_FIELD_CHILD(StringWTF16Get, pos); DELEGATE_FIELD_CHILD(StringWTF16Get, ref); - DELEGATE_END(StringWTF16Get); - break; - } - case Expression::Id::StringIterNextId: { - DELEGATE_START(StringIterNext); +DELEGATE_FIELD_CASE_END(StringWTF16Get) + +DELEGATE_FIELD_CASE_START(StringIterNext) DELEGATE_FIELD_CHILD(StringIterNext, ref); - DELEGATE_END(StringIterNext); - break; - } - case Expression::Id::StringIterMoveId: { - DELEGATE_START(StringIterMove); +DELEGATE_FIELD_CASE_END(StringIterNext) + +DELEGATE_FIELD_CASE_START(StringIterMove) DELEGATE_FIELD_INT(StringIterMove, op); DELEGATE_FIELD_CHILD(StringIterMove, num); DELEGATE_FIELD_CHILD(StringIterMove, ref); - DELEGATE_END(StringIterMove); - break; - } - case Expression::Id::StringSliceWTFId: { - DELEGATE_START(StringSliceWTF); +DELEGATE_FIELD_CASE_END(StringIterMove) + +DELEGATE_FIELD_CASE_START(StringSliceWTF) DELEGATE_FIELD_INT(StringSliceWTF, op); DELEGATE_FIELD_CHILD(StringSliceWTF, end); DELEGATE_FIELD_CHILD(StringSliceWTF, start); DELEGATE_FIELD_CHILD(StringSliceWTF, ref); - DELEGATE_END(StringSliceWTF); - break; - } - case Expression::Id::StringSliceIterId: { - DELEGATE_START(StringSliceIter); +DELEGATE_FIELD_CASE_END(StringSliceWTF) + +DELEGATE_FIELD_CASE_START(StringSliceIter) DELEGATE_FIELD_CHILD(StringSliceIter, num); DELEGATE_FIELD_CHILD(StringSliceIter, ref); - DELEGATE_END(StringSliceIter); - break; - } +DELEGATE_FIELD_CASE_END(StringSliceIter) - case Expression::Id::ContBindId: { - DELEGATE_START(ContBind); DELEGATE_FIELD_CHILD(ContBind, cont); DELEGATE_FIELD_CHILD_VECTOR(ContBind, operands); DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeAfter); DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeBefore); - DELEGATE_END(ContBind); - break; - } - case Expression::Id::ContNewId: { - DELEGATE_START(ContNew); +DELEGATE_FIELD_CASE_END(ContBind) + +DELEGATE_FIELD_CASE_START(ContNew) DELEGATE_FIELD_CHILD(ContNew, func); DELEGATE_FIELD_HEAPTYPE(ContNew, contType); - DELEGATE_END(ContNew); - break; - } - case Expression::Id::ResumeId: { - DELEGATE_START(Resume); +DELEGATE_FIELD_CASE_END(ContNew) + +DELEGATE_FIELD_CASE_START(Resume) DELEGATE_FIELD_TYPE_VECTOR(Resume, sentTypes); DELEGATE_FIELD_CHILD(Resume, cont); DELEGATE_FIELD_CHILD_VECTOR(Resume, operands); DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Resume, handlerBlocks); DELEGATE_FIELD_NAME_KIND_VECTOR(Resume, handlerTags, ModuleItemKind::Tag); DELEGATE_FIELD_HEAPTYPE(Resume, contType); - DELEGATE_END(Resume); - break; - } - case Expression::Id::SuspendId: { - DELEGATE_START(Suspend); +DELEGATE_FIELD_CASE_END(Resume) + +DELEGATE_FIELD_CASE_START(Suspend) DELEGATE_FIELD_CHILD_VECTOR(Suspend, operands); DELEGATE_FIELD_NAME_KIND(Suspend, tag, ModuleItemKind::Tag); - DELEGATE_END(Suspend); - break; - } -} +DELEGATE_FIELD_CASE_END(Suspend) + +DELEGATE_FIELD_MAIN_END #undef DELEGATE_ID #undef DELEGATE_START @@ -1004,3 +838,9 @@ switch (DELEGATE_ID) { #undef DELEGATE_FIELD_HEAPTYPE #undef DELEGATE_FIELD_ADDRESS #undef DELEGATE_GET_FIELD + +#undef DELEGATE_FIELD_MAIN_START +#undef DELEGATE_FIELD_MAIN_END +#undef DELEGATE_FIELD_CASE_START +#undef DELEGATE_FIELD_CASE_END + diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index c37fd986693..02cb51dc714 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -55,6 +55,9 @@ binaryenFactory().then((binaryen) => { ) `); + // Clean up. XXX new HeapType etc. are all unneeded and also leaked! + module.delete(); + console.log('success.'); }); From 3a3076f7c77f500cb926524bafa6f64e7fbd08a9 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 14:11:57 -0700 Subject: [PATCH 24/36] yikes --- src/binaryen-embind.cpp | 3 ++- src/wasm-delegations-fields.def | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 3ed4a39afa4..7a9c9690a51 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -82,7 +82,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_>("Nop"); - +#if 0 #define DELEGATE_ID id @@ -121,6 +121,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { ; #include "wasm-delegations.def" +#endif diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index ef89fcea6f8..1f9fa0154ba 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -246,12 +246,12 @@ switch (DELEGATE_ID) { \ #ifndef DELEGATE_FIELD_CASE_START #define DELEGATE_FIELD_CASE_START(id) \ - case Expression::Id::id#Id: { \ + case Expression::Id::id##Id: { \ DELEGATE_START(id); #endif #ifndef DELEGATE_FIELD_CASE_END -#define DELEGATE_FIELD_CASE_END \ +#define DELEGATE_FIELD_CASE_END(id) \ DELEGATE_END(id); \ break; \ } @@ -789,6 +789,7 @@ DELEGATE_FIELD_CASE_START(StringSliceIter) DELEGATE_FIELD_CHILD(StringSliceIter, ref); DELEGATE_FIELD_CASE_END(StringSliceIter) +DELEGATE_FIELD_CASE_START(ContBind) DELEGATE_FIELD_CHILD(ContBind, cont); DELEGATE_FIELD_CHILD_VECTOR(ContBind, operands); DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeAfter); From 4c84f27083f8d040508263cddc8a92cdb1d086c3 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 14:34:29 -0700 Subject: [PATCH 25/36] wprk --- src/binaryen-embind.cpp | 74 ++++++++++++++++++--------------- src/wasm-delegations-fields.def | 11 ++--- 2 files changed, 46 insertions(+), 39 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 7a9c9690a51..73cb4e609a7 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -79,10 +79,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Expression") .property("type", &Expression::type); - class_>("Nop"); - - -#if 0 + // Expression types, autogenerated. #define DELEGATE_ID id @@ -91,40 +88,49 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_END(id) std::cout << '\n'; #define DELEGATE_FIELD_CHILD(id, field) \ - std::cout << "BINARYEN_API BinaryenExpressionRef Binaryen" << #id << "Get" \ - << #field << "(BinaryenExpressionRef expr);\n"; - + .property(#field, &id::field); #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ - std::cout << "BINARYEN_API BinaryenExpressionRef Binaryen" << #id << "Get" \ - << #field \ - << "At(BinaryenExpressionRef expr, BinaryenIndex index);\n"; - -// TODO -#define DELEGATE_FIELD_TYPE(id, field) -#define DELEGATE_FIELD_HEAPTYPE(id, field) -#define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) -#define DELEGATE_FIELD_INT(id, field) -#define DELEGATE_FIELD_LITERAL(id, field) -#define DELEGATE_FIELD_NAME(id, field) -#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) -#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) -#define DELEGATE_FIELD_ADDRESS(id, field) -#define DELEGATE_FIELD_INT_ARRAY(id, field) -#define DELEGATE_FIELD_INT_VECTOR(id, field) -#define DELEGATE_FIELD_NAME_VECTOR(id, field) -#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) -#define DELEGATE_FIELD_TYPE_VECTOR(id, field) - -#define DELEGATE(clazz) \ - class_>(#clazz) -#include "wasm-delegations-fields.def" + .property(#field, &id::field); +#define DELEGATE_FIELD_TYPE(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_HEAPTYPE(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_INT(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_LITERAL(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_NAME(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_ADDRESS(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_INT_ARRAY(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_INT_VECTOR(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_NAME_VECTOR(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ + .property(#field, &id::field); +#define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ + .property(#field, &id::field); + +#define DELEGATE_FIELD_MAIN_START + +#define DELEGATE_FIELD_CASE_START(id) \ + class_>(#id) + +#define DELEGATE_FIELD_CASE_END(id) \ ; -#include "wasm-delegations.def" -#endif - - +#define DELEGATE_FIELD_MAIN_END +#include "wasm-delegations-fields.def" // Module-level constructs. diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index 1f9fa0154ba..71fac83a985 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -230,6 +230,7 @@ // By default we emit a switch and cases, but that can be customized using the // following: + #ifndef DELEGATE_FIELD_MAIN_START #define DELEGATE_FIELD_MAIN_START \ switch (DELEGATE_ID) { \ @@ -239,11 +240,6 @@ switch (DELEGATE_ID) { \ } #endif -#ifndef DELEGATE_FIELD_MAIN_END -#define DELEGATE_FIELD_MAIN_END \ -} -#endif - #ifndef DELEGATE_FIELD_CASE_START #define DELEGATE_FIELD_CASE_START(id) \ case Expression::Id::id##Id: { \ @@ -257,6 +253,11 @@ switch (DELEGATE_ID) { \ } #endif +#ifndef DELEGATE_FIELD_MAIN_END +#define DELEGATE_FIELD_MAIN_END \ +} +#endif + DELEGATE_FIELD_MAIN_START DELEGATE_FIELD_CASE_START(Block) From 4c63949625cfad936a6f2c58ee40f5f27233148d Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 14:36:13 -0700 Subject: [PATCH 26/36] wprk --- src/binaryen-embind.cpp | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 73cb4e609a7..7e4378d9175 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -88,37 +88,37 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_END(id) std::cout << '\n'; #define DELEGATE_FIELD_CHILD(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_TYPE(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_HEAPTYPE(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_INT(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_LITERAL(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_NAME(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_ADDRESS(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_INT_ARRAY(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_INT_VECTOR(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ - .property(#field, &id::field); + .property(#field, &id::field) #define DELEGATE_FIELD_MAIN_START From 625655d1291ebe00976dcffc4790908a24cdcc42 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 14:38:33 -0700 Subject: [PATCH 27/36] work --- src/wasm-delegations-fields.def | 542 ++++++++++++++++---------------- 1 file changed, 271 insertions(+), 271 deletions(-) diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index 71fac83a985..aeb9dec7e93 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -261,321 +261,321 @@ switch (DELEGATE_ID) { \ DELEGATE_FIELD_MAIN_START DELEGATE_FIELD_CASE_START(Block) - DELEGATE_FIELD_CHILD_VECTOR(Block, list); - DELEGATE_FIELD_SCOPE_NAME_DEF(Block, name); + DELEGATE_FIELD_CHILD_VECTOR(Block, list) + DELEGATE_FIELD_SCOPE_NAME_DEF(Block, name) DELEGATE_FIELD_CASE_END(Block) DELEGATE_FIELD_CASE_START(If) - DELEGATE_FIELD_OPTIONAL_CHILD(If, ifFalse); - DELEGATE_FIELD_CHILD(If, ifTrue); - DELEGATE_FIELD_CHILD(If, condition); + DELEGATE_FIELD_OPTIONAL_CHILD(If, ifFalse) + DELEGATE_FIELD_CHILD(If, ifTrue) + DELEGATE_FIELD_CHILD(If, condition) DELEGATE_FIELD_CASE_END(If) DELEGATE_FIELD_CASE_START(Loop) - DELEGATE_FIELD_CHILD(Loop, body); - DELEGATE_FIELD_SCOPE_NAME_DEF(Loop, name); + DELEGATE_FIELD_CHILD(Loop, body) + DELEGATE_FIELD_SCOPE_NAME_DEF(Loop, name) DELEGATE_FIELD_CASE_END(Loop) DELEGATE_FIELD_CASE_START(Break) - DELEGATE_FIELD_OPTIONAL_CHILD(Break, condition); - DELEGATE_FIELD_OPTIONAL_CHILD(Break, value); - DELEGATE_FIELD_SCOPE_NAME_USE(Break, name); + DELEGATE_FIELD_OPTIONAL_CHILD(Break, condition) + DELEGATE_FIELD_OPTIONAL_CHILD(Break, value) + DELEGATE_FIELD_SCOPE_NAME_USE(Break, name) DELEGATE_FIELD_CASE_END(Break) DELEGATE_FIELD_CASE_START(Switch) - DELEGATE_FIELD_CHILD(Switch, condition); - DELEGATE_FIELD_OPTIONAL_CHILD(Switch, value); - DELEGATE_FIELD_SCOPE_NAME_USE(Switch, default_); - DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Switch, targets); + DELEGATE_FIELD_CHILD(Switch, condition) + DELEGATE_FIELD_OPTIONAL_CHILD(Switch, value) + DELEGATE_FIELD_SCOPE_NAME_USE(Switch, default_) + DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Switch, targets) DELEGATE_FIELD_CASE_END(Switch) DELEGATE_FIELD_CASE_START(Call) - DELEGATE_FIELD_CHILD_VECTOR(Call, operands); - DELEGATE_FIELD_NAME_KIND(Call, target, ModuleItemKind::Function); - DELEGATE_FIELD_INT(Call, isReturn); + DELEGATE_FIELD_CHILD_VECTOR(Call, operands) + DELEGATE_FIELD_NAME_KIND(Call, target, ModuleItemKind::Function) + DELEGATE_FIELD_INT(Call, isReturn) DELEGATE_FIELD_CASE_END(Call) DELEGATE_FIELD_CASE_START(CallIndirect) - DELEGATE_FIELD_CHILD(CallIndirect, target); - DELEGATE_FIELD_NAME_KIND(CallIndirect, table, ModuleItemKind::Table); - DELEGATE_FIELD_CHILD_VECTOR(CallIndirect, operands); - DELEGATE_FIELD_HEAPTYPE(CallIndirect, heapType); - DELEGATE_FIELD_INT(CallIndirect, isReturn); + DELEGATE_FIELD_CHILD(CallIndirect, target) + DELEGATE_FIELD_NAME_KIND(CallIndirect, table, ModuleItemKind::Table) + DELEGATE_FIELD_CHILD_VECTOR(CallIndirect, operands) + DELEGATE_FIELD_HEAPTYPE(CallIndirect, heapType) + DELEGATE_FIELD_INT(CallIndirect, isReturn) DELEGATE_FIELD_CASE_END(CallIndirect) DELEGATE_FIELD_CASE_START(LocalGet) - DELEGATE_FIELD_INT(LocalGet, index); + DELEGATE_FIELD_INT(LocalGet, index) DELEGATE_FIELD_CASE_END(LocalGet) DELEGATE_FIELD_CASE_START(LocalSet) - DELEGATE_FIELD_CHILD(LocalSet, value); - DELEGATE_FIELD_INT(LocalSet, index); + DELEGATE_FIELD_CHILD(LocalSet, value) + DELEGATE_FIELD_INT(LocalSet, index) DELEGATE_FIELD_CASE_END(LocalSet) DELEGATE_FIELD_CASE_START(GlobalGet) - DELEGATE_FIELD_NAME_KIND(GlobalGet, name, ModuleItemKind::Global); + DELEGATE_FIELD_NAME_KIND(GlobalGet, name, ModuleItemKind::Global) DELEGATE_FIELD_CASE_END(GlobalGet) DELEGATE_FIELD_CASE_START(GlobalSet) - DELEGATE_FIELD_CHILD(GlobalSet, value); - DELEGATE_FIELD_NAME_KIND(GlobalSet, name, ModuleItemKind::Global); + DELEGATE_FIELD_CHILD(GlobalSet, value) + DELEGATE_FIELD_NAME_KIND(GlobalSet, name, ModuleItemKind::Global) DELEGATE_FIELD_CASE_END(GlobalSet) DELEGATE_FIELD_CASE_START(Load) - DELEGATE_FIELD_CHILD(Load, ptr); - DELEGATE_FIELD_INT(Load, bytes); - DELEGATE_FIELD_INT(Load, signed_); - DELEGATE_FIELD_ADDRESS(Load, offset); - DELEGATE_FIELD_ADDRESS(Load, align); - DELEGATE_FIELD_INT(Load, isAtomic); - DELEGATE_FIELD_NAME_KIND(Load, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(Load, ptr) + DELEGATE_FIELD_INT(Load, bytes) + DELEGATE_FIELD_INT(Load, signed_) + DELEGATE_FIELD_ADDRESS(Load, offset) + DELEGATE_FIELD_ADDRESS(Load, align) + DELEGATE_FIELD_INT(Load, isAtomic) + DELEGATE_FIELD_NAME_KIND(Load, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(Load) DELEGATE_FIELD_CASE_START(Store) - DELEGATE_FIELD_CHILD(Store, value); - DELEGATE_FIELD_CHILD(Store, ptr); - DELEGATE_FIELD_INT(Store, bytes); - DELEGATE_FIELD_ADDRESS(Store, offset); - DELEGATE_FIELD_ADDRESS(Store, align); - DELEGATE_FIELD_INT(Store, isAtomic); - DELEGATE_FIELD_TYPE(Store, valueType); - DELEGATE_FIELD_NAME_KIND(Store, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(Store, value) + DELEGATE_FIELD_CHILD(Store, ptr) + DELEGATE_FIELD_INT(Store, bytes) + DELEGATE_FIELD_ADDRESS(Store, offset) + DELEGATE_FIELD_ADDRESS(Store, align) + DELEGATE_FIELD_INT(Store, isAtomic) + DELEGATE_FIELD_TYPE(Store, valueType) + DELEGATE_FIELD_NAME_KIND(Store, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(Store) DELEGATE_FIELD_CASE_START(AtomicRMW) - DELEGATE_FIELD_CHILD(AtomicRMW, value); - DELEGATE_FIELD_CHILD(AtomicRMW, ptr); - DELEGATE_FIELD_INT(AtomicRMW, op); - DELEGATE_FIELD_INT(AtomicRMW, bytes); - DELEGATE_FIELD_ADDRESS(AtomicRMW, offset); - DELEGATE_FIELD_NAME_KIND(AtomicRMW, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(AtomicRMW, value) + DELEGATE_FIELD_CHILD(AtomicRMW, ptr) + DELEGATE_FIELD_INT(AtomicRMW, op) + DELEGATE_FIELD_INT(AtomicRMW, bytes) + DELEGATE_FIELD_ADDRESS(AtomicRMW, offset) + DELEGATE_FIELD_NAME_KIND(AtomicRMW, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(AtomicRMW) DELEGATE_FIELD_CASE_START(AtomicCmpxchg) - DELEGATE_FIELD_CHILD(AtomicCmpxchg, replacement); - DELEGATE_FIELD_CHILD(AtomicCmpxchg, expected); - DELEGATE_FIELD_CHILD(AtomicCmpxchg, ptr); - DELEGATE_FIELD_INT(AtomicCmpxchg, bytes); - DELEGATE_FIELD_ADDRESS(AtomicCmpxchg, offset); - DELEGATE_FIELD_NAME_KIND(AtomicCmpxchg, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(AtomicCmpxchg, replacement) + DELEGATE_FIELD_CHILD(AtomicCmpxchg, expected) + DELEGATE_FIELD_CHILD(AtomicCmpxchg, ptr) + DELEGATE_FIELD_INT(AtomicCmpxchg, bytes) + DELEGATE_FIELD_ADDRESS(AtomicCmpxchg, offset) + DELEGATE_FIELD_NAME_KIND(AtomicCmpxchg, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(AtomicCmpxchg) DELEGATE_FIELD_CASE_START(AtomicWait) - DELEGATE_FIELD_CHILD(AtomicWait, timeout); - DELEGATE_FIELD_CHILD(AtomicWait, expected); - DELEGATE_FIELD_CHILD(AtomicWait, ptr); - DELEGATE_FIELD_ADDRESS(AtomicWait, offset); - DELEGATE_FIELD_TYPE(AtomicWait, expectedType); - DELEGATE_FIELD_NAME_KIND(AtomicWait, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(AtomicWait, timeout) + DELEGATE_FIELD_CHILD(AtomicWait, expected) + DELEGATE_FIELD_CHILD(AtomicWait, ptr) + DELEGATE_FIELD_ADDRESS(AtomicWait, offset) + DELEGATE_FIELD_TYPE(AtomicWait, expectedType) + DELEGATE_FIELD_NAME_KIND(AtomicWait, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(AtomicWait) DELEGATE_FIELD_CASE_START(AtomicNotify) - DELEGATE_FIELD_CHILD(AtomicNotify, notifyCount); - DELEGATE_FIELD_CHILD(AtomicNotify, ptr); - DELEGATE_FIELD_ADDRESS(AtomicNotify, offset); - DELEGATE_FIELD_NAME_KIND(AtomicNotify, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(AtomicNotify, notifyCount) + DELEGATE_FIELD_CHILD(AtomicNotify, ptr) + DELEGATE_FIELD_ADDRESS(AtomicNotify, offset) + DELEGATE_FIELD_NAME_KIND(AtomicNotify, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(AtomicNotify) DELEGATE_FIELD_CASE_START(AtomicFence) - DELEGATE_FIELD_INT(AtomicFence, order); + DELEGATE_FIELD_INT(AtomicFence, order) DELEGATE_FIELD_CASE_END(AtomicFence) DELEGATE_FIELD_CASE_START(SIMDExtract) - DELEGATE_FIELD_CHILD(SIMDExtract, vec); - DELEGATE_FIELD_INT(SIMDExtract, op); - DELEGATE_FIELD_INT(SIMDExtract, index); + DELEGATE_FIELD_CHILD(SIMDExtract, vec) + DELEGATE_FIELD_INT(SIMDExtract, op) + DELEGATE_FIELD_INT(SIMDExtract, index) DELEGATE_FIELD_CASE_END(SIMDExtract) DELEGATE_FIELD_CASE_START(SIMDReplace) - DELEGATE_FIELD_CHILD(SIMDReplace, value); - DELEGATE_FIELD_CHILD(SIMDReplace, vec); - DELEGATE_FIELD_INT(SIMDReplace, op); - DELEGATE_FIELD_INT(SIMDReplace, index); + DELEGATE_FIELD_CHILD(SIMDReplace, value) + DELEGATE_FIELD_CHILD(SIMDReplace, vec) + DELEGATE_FIELD_INT(SIMDReplace, op) + DELEGATE_FIELD_INT(SIMDReplace, index) DELEGATE_FIELD_CASE_END(SIMDReplace) DELEGATE_FIELD_CASE_START(SIMDShuffle) - DELEGATE_FIELD_CHILD(SIMDShuffle, right); - DELEGATE_FIELD_CHILD(SIMDShuffle, left); - DELEGATE_FIELD_INT_ARRAY(SIMDShuffle, mask); + DELEGATE_FIELD_CHILD(SIMDShuffle, right) + DELEGATE_FIELD_CHILD(SIMDShuffle, left) + DELEGATE_FIELD_INT_ARRAY(SIMDShuffle, mask) DELEGATE_FIELD_CASE_END(SIMDShuffle) DELEGATE_FIELD_CASE_START(SIMDTernary) - DELEGATE_FIELD_CHILD(SIMDTernary, c); - DELEGATE_FIELD_CHILD(SIMDTernary, b); - DELEGATE_FIELD_CHILD(SIMDTernary, a); - DELEGATE_FIELD_INT(SIMDTernary, op); + DELEGATE_FIELD_CHILD(SIMDTernary, c) + DELEGATE_FIELD_CHILD(SIMDTernary, b) + DELEGATE_FIELD_CHILD(SIMDTernary, a) + DELEGATE_FIELD_INT(SIMDTernary, op) DELEGATE_FIELD_CASE_END(SIMDTernary) DELEGATE_FIELD_CASE_START(SIMDShift) - DELEGATE_FIELD_CHILD(SIMDShift, shift); - DELEGATE_FIELD_CHILD(SIMDShift, vec); - DELEGATE_FIELD_INT(SIMDShift, op); + DELEGATE_FIELD_CHILD(SIMDShift, shift) + DELEGATE_FIELD_CHILD(SIMDShift, vec) + DELEGATE_FIELD_INT(SIMDShift, op) DELEGATE_FIELD_CASE_END(SIMDShift) DELEGATE_FIELD_CASE_START(SIMDLoad) - DELEGATE_FIELD_CHILD(SIMDLoad, ptr); - DELEGATE_FIELD_INT(SIMDLoad, op); - DELEGATE_FIELD_ADDRESS(SIMDLoad, offset); - DELEGATE_FIELD_ADDRESS(SIMDLoad, align); - DELEGATE_FIELD_NAME_KIND(SIMDLoad, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(SIMDLoad, ptr) + DELEGATE_FIELD_INT(SIMDLoad, op) + DELEGATE_FIELD_ADDRESS(SIMDLoad, offset) + DELEGATE_FIELD_ADDRESS(SIMDLoad, align) + DELEGATE_FIELD_NAME_KIND(SIMDLoad, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(SIMDLoad) DELEGATE_FIELD_CASE_START(SIMDLoadStoreLane) - DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, vec); - DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, ptr); - DELEGATE_FIELD_INT(SIMDLoadStoreLane, op); - DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, offset); - DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, align); - DELEGATE_FIELD_INT(SIMDLoadStoreLane, index); - DELEGATE_FIELD_NAME_KIND(SIMDLoadStoreLane, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, vec) + DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, ptr) + DELEGATE_FIELD_INT(SIMDLoadStoreLane, op) + DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, offset) + DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, align) + DELEGATE_FIELD_INT(SIMDLoadStoreLane, index) + DELEGATE_FIELD_NAME_KIND(SIMDLoadStoreLane, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(SIMDLoadStoreLane) DELEGATE_FIELD_CASE_START(MemoryInit) - DELEGATE_FIELD_CHILD(MemoryInit, size); - DELEGATE_FIELD_CHILD(MemoryInit, offset); - DELEGATE_FIELD_CHILD(MemoryInit, dest); - DELEGATE_FIELD_NAME_KIND(MemoryInit, segment, ModuleItemKind::DataSegment); - DELEGATE_FIELD_NAME_KIND(MemoryInit, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(MemoryInit, size) + DELEGATE_FIELD_CHILD(MemoryInit, offset) + DELEGATE_FIELD_CHILD(MemoryInit, dest) + DELEGATE_FIELD_NAME_KIND(MemoryInit, segment, ModuleItemKind::DataSegment) + DELEGATE_FIELD_NAME_KIND(MemoryInit, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(MemoryInit) DELEGATE_FIELD_CASE_START(DataDrop) - DELEGATE_FIELD_NAME_KIND(DataDrop, segment, ModuleItemKind::DataSegment); + DELEGATE_FIELD_NAME_KIND(DataDrop, segment, ModuleItemKind::DataSegment) DELEGATE_FIELD_CASE_END(DataDrop) DELEGATE_FIELD_CASE_START(MemoryCopy) - DELEGATE_FIELD_CHILD(MemoryCopy, size); - DELEGATE_FIELD_CHILD(MemoryCopy, source); - DELEGATE_FIELD_CHILD(MemoryCopy, dest); - DELEGATE_FIELD_NAME_KIND(MemoryCopy, sourceMemory, ModuleItemKind::Memory); - DELEGATE_FIELD_NAME_KIND(MemoryCopy, destMemory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(MemoryCopy, size) + DELEGATE_FIELD_CHILD(MemoryCopy, source) + DELEGATE_FIELD_CHILD(MemoryCopy, dest) + DELEGATE_FIELD_NAME_KIND(MemoryCopy, sourceMemory, ModuleItemKind::Memory) + DELEGATE_FIELD_NAME_KIND(MemoryCopy, destMemory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(MemoryCopy) DELEGATE_FIELD_CASE_START(MemoryFill) - DELEGATE_FIELD_CHILD(MemoryFill, size); - DELEGATE_FIELD_CHILD(MemoryFill, value); - DELEGATE_FIELD_CHILD(MemoryFill, dest); - DELEGATE_FIELD_NAME_KIND(MemoryFill, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_CHILD(MemoryFill, size) + DELEGATE_FIELD_CHILD(MemoryFill, value) + DELEGATE_FIELD_CHILD(MemoryFill, dest) + DELEGATE_FIELD_NAME_KIND(MemoryFill, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(MemoryFill) DELEGATE_FIELD_CASE_START(Const) - DELEGATE_FIELD_LITERAL(Const, value); + DELEGATE_FIELD_LITERAL(Const, value) DELEGATE_FIELD_CASE_END(Const) DELEGATE_FIELD_CASE_START(Unary) - DELEGATE_FIELD_CHILD(Unary, value); - DELEGATE_FIELD_INT(Unary, op); + DELEGATE_FIELD_CHILD(Unary, value) + DELEGATE_FIELD_INT(Unary, op) DELEGATE_FIELD_CASE_END(Unary) DELEGATE_FIELD_CASE_START(Binary) - DELEGATE_FIELD_CHILD(Binary, right); - DELEGATE_FIELD_CHILD(Binary, left); - DELEGATE_FIELD_INT(Binary, op); + DELEGATE_FIELD_CHILD(Binary, right) + DELEGATE_FIELD_CHILD(Binary, left) + DELEGATE_FIELD_INT(Binary, op) DELEGATE_FIELD_CASE_END(Binary) DELEGATE_FIELD_CASE_START(Select) - DELEGATE_FIELD_CHILD(Select, condition); - DELEGATE_FIELD_CHILD(Select, ifFalse); - DELEGATE_FIELD_CHILD(Select, ifTrue); + DELEGATE_FIELD_CHILD(Select, condition) + DELEGATE_FIELD_CHILD(Select, ifFalse) + DELEGATE_FIELD_CHILD(Select, ifTrue) DELEGATE_FIELD_CASE_END(Select) DELEGATE_FIELD_CASE_START(Drop) - DELEGATE_FIELD_CHILD(Drop, value); + DELEGATE_FIELD_CHILD(Drop, value) DELEGATE_FIELD_CASE_END(Drop) DELEGATE_FIELD_CASE_START(Return) - DELEGATE_FIELD_OPTIONAL_CHILD(Return, value); + DELEGATE_FIELD_OPTIONAL_CHILD(Return, value) DELEGATE_FIELD_CASE_END(Return) DELEGATE_FIELD_CASE_START(MemorySize) - DELEGATE_FIELD_TYPE(MemorySize, ptrType); - DELEGATE_FIELD_NAME_KIND(MemorySize, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_TYPE(MemorySize, ptrType) + DELEGATE_FIELD_NAME_KIND(MemorySize, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(MemorySize) DELEGATE_FIELD_CASE_START(MemoryGrow) - DELEGATE_FIELD_TYPE(MemoryGrow, ptrType); - DELEGATE_FIELD_CHILD(MemoryGrow, delta); - DELEGATE_FIELD_NAME_KIND(MemoryGrow, memory, ModuleItemKind::Memory); + DELEGATE_FIELD_TYPE(MemoryGrow, ptrType) + DELEGATE_FIELD_CHILD(MemoryGrow, delta) + DELEGATE_FIELD_NAME_KIND(MemoryGrow, memory, ModuleItemKind::Memory) DELEGATE_FIELD_CASE_END(MemoryGrow) DELEGATE_FIELD_CASE_START(RefNull) DELEGATE_FIELD_CASE_END(RefNull) DELEGATE_FIELD_CASE_START(RefIsNull) - DELEGATE_FIELD_CHILD(RefIsNull, value); + DELEGATE_FIELD_CHILD(RefIsNull, value) DELEGATE_FIELD_CASE_END(RefIsNull) DELEGATE_FIELD_CASE_START(RefFunc) - DELEGATE_FIELD_NAME_KIND(RefFunc, func, ModuleItemKind::Function); + DELEGATE_FIELD_NAME_KIND(RefFunc, func, ModuleItemKind::Function) DELEGATE_FIELD_CASE_END(RefFunc) DELEGATE_FIELD_CASE_START(RefEq) - DELEGATE_FIELD_CHILD(RefEq, right); - DELEGATE_FIELD_CHILD(RefEq, left); + DELEGATE_FIELD_CHILD(RefEq, right) + DELEGATE_FIELD_CHILD(RefEq, left) DELEGATE_FIELD_CASE_END(RefEq) DELEGATE_FIELD_CASE_START(TableGet) - DELEGATE_FIELD_CHILD(TableGet, index); - DELEGATE_FIELD_NAME_KIND(TableGet, table, ModuleItemKind::Table); + DELEGATE_FIELD_CHILD(TableGet, index) + DELEGATE_FIELD_NAME_KIND(TableGet, table, ModuleItemKind::Table) DELEGATE_FIELD_CASE_END(TableGet) DELEGATE_FIELD_CASE_START(TableSet) - DELEGATE_FIELD_CHILD(TableSet, value); - DELEGATE_FIELD_CHILD(TableSet, index); - DELEGATE_FIELD_NAME_KIND(TableSet, table, ModuleItemKind::Table); + DELEGATE_FIELD_CHILD(TableSet, value) + DELEGATE_FIELD_CHILD(TableSet, index) + DELEGATE_FIELD_NAME_KIND(TableSet, table, ModuleItemKind::Table) DELEGATE_FIELD_CASE_END(TableSet) DELEGATE_FIELD_CASE_START(TableSize) - DELEGATE_FIELD_NAME_KIND(TableSize, table, ModuleItemKind::Table); + DELEGATE_FIELD_NAME_KIND(TableSize, table, ModuleItemKind::Table) DELEGATE_FIELD_CASE_END(TableSize) DELEGATE_FIELD_CASE_START(TableGrow) - DELEGATE_FIELD_CHILD(TableGrow, delta); - DELEGATE_FIELD_CHILD(TableGrow, value); - DELEGATE_FIELD_NAME_KIND(TableGrow, table, ModuleItemKind::Table); + DELEGATE_FIELD_CHILD(TableGrow, delta) + DELEGATE_FIELD_CHILD(TableGrow, value) + DELEGATE_FIELD_NAME_KIND(TableGrow, table, ModuleItemKind::Table) DELEGATE_FIELD_CASE_END(TableGrow) DELEGATE_FIELD_CASE_START(TableFill) - DELEGATE_FIELD_CHILD(TableFill, size); - DELEGATE_FIELD_CHILD(TableFill, value); - DELEGATE_FIELD_CHILD(TableFill, dest); - DELEGATE_FIELD_NAME_KIND(TableFill, table, ModuleItemKind::Table); + DELEGATE_FIELD_CHILD(TableFill, size) + DELEGATE_FIELD_CHILD(TableFill, value) + DELEGATE_FIELD_CHILD(TableFill, dest) + DELEGATE_FIELD_NAME_KIND(TableFill, table, ModuleItemKind::Table) DELEGATE_FIELD_CASE_END(TableFill) DELEGATE_FIELD_CASE_START(TableCopy) - DELEGATE_FIELD_CHILD(TableCopy, size); - DELEGATE_FIELD_CHILD(TableCopy, source); - DELEGATE_FIELD_CHILD(TableCopy, dest); - DELEGATE_FIELD_NAME_KIND(TableCopy, sourceTable, ModuleItemKind::Table); - DELEGATE_FIELD_NAME_KIND(TableCopy, destTable, ModuleItemKind::Table); + DELEGATE_FIELD_CHILD(TableCopy, size) + DELEGATE_FIELD_CHILD(TableCopy, source) + DELEGATE_FIELD_CHILD(TableCopy, dest) + DELEGATE_FIELD_NAME_KIND(TableCopy, sourceTable, ModuleItemKind::Table) + DELEGATE_FIELD_NAME_KIND(TableCopy, destTable, ModuleItemKind::Table) DELEGATE_FIELD_CASE_END(TableCopy) DELEGATE_FIELD_CASE_START(Try) - DELEGATE_FIELD_SCOPE_NAME_USE(Try, delegateTarget); - DELEGATE_FIELD_CHILD_VECTOR(Try, catchBodies); - DELEGATE_FIELD_NAME_KIND_VECTOR(Try, catchTags, ModuleItemKind::Tag); - DELEGATE_FIELD_SCOPE_NAME_DEF(Try, name); - DELEGATE_FIELD_CHILD(Try, body); + DELEGATE_FIELD_SCOPE_NAME_USE(Try, delegateTarget) + DELEGATE_FIELD_CHILD_VECTOR(Try, catchBodies) + DELEGATE_FIELD_NAME_KIND_VECTOR(Try, catchTags, ModuleItemKind::Tag) + DELEGATE_FIELD_SCOPE_NAME_DEF(Try, name) + DELEGATE_FIELD_CHILD(Try, body) DELEGATE_FIELD_CASE_END(Try) DELEGATE_FIELD_CASE_START(TryTable) - DELEGATE_FIELD_TYPE_VECTOR(TryTable, sentTypes); - DELEGATE_FIELD_INT_VECTOR(TryTable, catchRefs); - DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(TryTable, catchDests); - DELEGATE_FIELD_NAME_KIND_VECTOR(TryTable, catchTags, ModuleItemKind::Tag); - DELEGATE_FIELD_CHILD(TryTable, body); + DELEGATE_FIELD_TYPE_VECTOR(TryTable, sentTypes) + DELEGATE_FIELD_INT_VECTOR(TryTable, catchRefs) + DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(TryTable, catchDests) + DELEGATE_FIELD_NAME_KIND_VECTOR(TryTable, catchTags, ModuleItemKind::Tag) + DELEGATE_FIELD_CHILD(TryTable, body) DELEGATE_FIELD_CASE_END(TryTable) DELEGATE_FIELD_CASE_START(Throw) - DELEGATE_FIELD_CHILD_VECTOR(Throw, operands); - DELEGATE_FIELD_NAME_KIND(Throw, tag, ModuleItemKind::Tag); + DELEGATE_FIELD_CHILD_VECTOR(Throw, operands) + DELEGATE_FIELD_NAME_KIND(Throw, tag, ModuleItemKind::Tag) DELEGATE_FIELD_CASE_END(Throw) DELEGATE_FIELD_CASE_START(Rethrow) - DELEGATE_FIELD_SCOPE_NAME_USE(Rethrow, target); + DELEGATE_FIELD_SCOPE_NAME_USE(Rethrow, target) DELEGATE_FIELD_CASE_END(Rethrow) DELEGATE_FIELD_CASE_START(ThrowRef) - DELEGATE_FIELD_CHILD(ThrowRef, exnref); + DELEGATE_FIELD_CHILD(ThrowRef, exnref) DELEGATE_FIELD_CASE_END(ThrowRef) DELEGATE_FIELD_CASE_START(Nop) @@ -588,232 +588,232 @@ DELEGATE_FIELD_CASE_START(Pop) DELEGATE_FIELD_CASE_END(Pop) DELEGATE_FIELD_CASE_START(TupleMake) - DELEGATE_FIELD_CHILD_VECTOR(Tuple, operands); + DELEGATE_FIELD_CHILD_VECTOR(Tuple, operands) DELEGATE_FIELD_CASE_END(TupleMake) DELEGATE_FIELD_CASE_START(TupleExtract) - DELEGATE_FIELD_CHILD(TupleExtract, tuple); - DELEGATE_FIELD_INT(TupleExtract, index); + DELEGATE_FIELD_CHILD(TupleExtract, tuple) + DELEGATE_FIELD_INT(TupleExtract, index) DELEGATE_FIELD_CASE_END(TupleExtract) DELEGATE_FIELD_CASE_START(RefI31) - DELEGATE_FIELD_CHILD(RefI31, value); + DELEGATE_FIELD_CHILD(RefI31, value) DELEGATE_FIELD_CASE_END(RefI31) DELEGATE_FIELD_CASE_START(I31Get) - DELEGATE_FIELD_CHILD(I31Get, i31); - DELEGATE_FIELD_INT(I31Get, signed_); + DELEGATE_FIELD_CHILD(I31Get, i31) + DELEGATE_FIELD_INT(I31Get, signed_) DELEGATE_FIELD_CASE_END(I31Get) DELEGATE_FIELD_CASE_START(CallRef) - DELEGATE_FIELD_CHILD(CallRef, target); - DELEGATE_FIELD_CHILD_VECTOR(CallRef, operands); - DELEGATE_FIELD_INT(CallRef, isReturn); + DELEGATE_FIELD_CHILD(CallRef, target) + DELEGATE_FIELD_CHILD_VECTOR(CallRef, operands) + DELEGATE_FIELD_INT(CallRef, isReturn) DELEGATE_FIELD_CASE_END(CallRef) DELEGATE_FIELD_CASE_START(RefTest) - DELEGATE_FIELD_TYPE(RefTest, castType); - DELEGATE_FIELD_CHILD(RefTest, ref); + DELEGATE_FIELD_TYPE(RefTest, castType) + DELEGATE_FIELD_CHILD(RefTest, ref) DELEGATE_FIELD_CASE_END(RefTest) DELEGATE_FIELD_CASE_START(RefCast) - DELEGATE_FIELD_CHILD(RefCast, ref); + DELEGATE_FIELD_CHILD(RefCast, ref) DELEGATE_FIELD_CASE_END(RefCast) DELEGATE_FIELD_CASE_START(BrOn) - DELEGATE_FIELD_INT(BrOn, op); - DELEGATE_FIELD_SCOPE_NAME_USE(BrOn, name); - DELEGATE_FIELD_TYPE(BrOn, castType); - DELEGATE_FIELD_CHILD(BrOn, ref); + DELEGATE_FIELD_INT(BrOn, op) + DELEGATE_FIELD_SCOPE_NAME_USE(BrOn, name) + DELEGATE_FIELD_TYPE(BrOn, castType) + DELEGATE_FIELD_CHILD(BrOn, ref) DELEGATE_FIELD_CASE_END(BrOn) DELEGATE_FIELD_CASE_START(StructNew) - DELEGATE_FIELD_CHILD_VECTOR(StructNew, operands); + DELEGATE_FIELD_CHILD_VECTOR(StructNew, operands) DELEGATE_FIELD_CASE_END(StructNew) DELEGATE_FIELD_CASE_START(StructGet) - DELEGATE_FIELD_INT(StructGet, index); - DELEGATE_FIELD_CHILD(StructGet, ref); - DELEGATE_FIELD_INT(StructGet, signed_); + DELEGATE_FIELD_INT(StructGet, index) + DELEGATE_FIELD_CHILD(StructGet, ref) + DELEGATE_FIELD_INT(StructGet, signed_) DELEGATE_FIELD_CASE_END(StructGet) DELEGATE_FIELD_CASE_START(StructSet) - DELEGATE_FIELD_INT(StructSet, index); - DELEGATE_FIELD_CHILD(StructSet, value); - DELEGATE_FIELD_CHILD(StructSet, ref); + DELEGATE_FIELD_INT(StructSet, index) + DELEGATE_FIELD_CHILD(StructSet, value) + DELEGATE_FIELD_CHILD(StructSet, ref) DELEGATE_FIELD_CASE_END(StructSet) DELEGATE_FIELD_CASE_START(ArrayNew) - DELEGATE_FIELD_CHILD(ArrayNew, size); - DELEGATE_FIELD_OPTIONAL_CHILD(ArrayNew, init); + DELEGATE_FIELD_CHILD(ArrayNew, size) + DELEGATE_FIELD_OPTIONAL_CHILD(ArrayNew, init) DELEGATE_FIELD_CASE_END(ArrayNew) DELEGATE_FIELD_CASE_START(ArrayNewData) - DELEGATE_FIELD_NAME_KIND(ArrayNewData, segment, ModuleItemKind::DataSegment); - DELEGATE_FIELD_CHILD(ArrayNewData, size); - DELEGATE_FIELD_CHILD(ArrayNewData, offset); + DELEGATE_FIELD_NAME_KIND(ArrayNewData, segment, ModuleItemKind::DataSegment) + DELEGATE_FIELD_CHILD(ArrayNewData, size) + DELEGATE_FIELD_CHILD(ArrayNewData, offset) DELEGATE_FIELD_CASE_END(ArrayNewData) DELEGATE_FIELD_CASE_START(ArrayNewElem) - DELEGATE_FIELD_NAME_KIND(ArrayNewElem, segment, ModuleItemKind::ElementSegment); - DELEGATE_FIELD_CHILD(ArrayNewElem, size); - DELEGATE_FIELD_CHILD(ArrayNewElem, offset); + DELEGATE_FIELD_NAME_KIND(ArrayNewElem, segment, ModuleItemKind::ElementSegment) + DELEGATE_FIELD_CHILD(ArrayNewElem, size) + DELEGATE_FIELD_CHILD(ArrayNewElem, offset) DELEGATE_FIELD_CASE_END(ArrayNewElem) DELEGATE_FIELD_CASE_START(ArrayNewFixed) - DELEGATE_FIELD_CHILD_VECTOR(ArrayNewFixed, values); + DELEGATE_FIELD_CHILD_VECTOR(ArrayNewFixed, values) DELEGATE_FIELD_CASE_END(ArrayNewFixed) DELEGATE_FIELD_CASE_START(ArrayGet) - DELEGATE_FIELD_CHILD(ArrayGet, index); - DELEGATE_FIELD_CHILD(ArrayGet, ref); - DELEGATE_FIELD_INT(ArrayGet, signed_); + DELEGATE_FIELD_CHILD(ArrayGet, index) + DELEGATE_FIELD_CHILD(ArrayGet, ref) + DELEGATE_FIELD_INT(ArrayGet, signed_) DELEGATE_FIELD_CASE_END(ArrayGet) DELEGATE_FIELD_CASE_START(ArraySet) - DELEGATE_FIELD_CHILD(ArrayGet, value); - DELEGATE_FIELD_CHILD(ArrayGet, index); - DELEGATE_FIELD_CHILD(ArrayGet, ref); + DELEGATE_FIELD_CHILD(ArrayGet, value) + DELEGATE_FIELD_CHILD(ArrayGet, index) + DELEGATE_FIELD_CHILD(ArrayGet, ref) DELEGATE_FIELD_CASE_END(ArraySet) DELEGATE_FIELD_CASE_START(ArrayLen) - DELEGATE_FIELD_CHILD(ArrayLen, ref); + DELEGATE_FIELD_CHILD(ArrayLen, ref) DELEGATE_FIELD_CASE_END(ArrayLen) DELEGATE_FIELD_CASE_START(ArrayCopy) - DELEGATE_FIELD_CHILD(ArrayCopy, length); - DELEGATE_FIELD_CHILD(ArrayCopy, srcIndex); - DELEGATE_FIELD_CHILD(ArrayCopy, srcRef); - DELEGATE_FIELD_CHILD(ArrayCopy, destIndex); - DELEGATE_FIELD_CHILD(ArrayCopy, destRef); + DELEGATE_FIELD_CHILD(ArrayCopy, length) + DELEGATE_FIELD_CHILD(ArrayCopy, srcIndex) + DELEGATE_FIELD_CHILD(ArrayCopy, srcRef) + DELEGATE_FIELD_CHILD(ArrayCopy, destIndex) + DELEGATE_FIELD_CHILD(ArrayCopy, destRef) DELEGATE_FIELD_CASE_END(ArrayCopy) DELEGATE_FIELD_CASE_START(ArrayFill) - DELEGATE_FIELD_CHILD(ArrayFill, size); - DELEGATE_FIELD_CHILD(ArrayFill, value); - DELEGATE_FIELD_CHILD(ArrayFill, index); - DELEGATE_FIELD_CHILD(ArrayFill, ref); + DELEGATE_FIELD_CHILD(ArrayFill, size) + DELEGATE_FIELD_CHILD(ArrayFill, value) + DELEGATE_FIELD_CHILD(ArrayFill, index) + DELEGATE_FIELD_CHILD(ArrayFill, ref) DELEGATE_FIELD_CASE_END(ArrayFill) DELEGATE_FIELD_CASE_START(ArrayInitData) - DELEGATE_FIELD_NAME_KIND(ArrayInitData, segment, ModuleItemKind::DataSegment); - DELEGATE_FIELD_CHILD(ArrayInitData, size); - DELEGATE_FIELD_CHILD(ArrayInitData, offset); - DELEGATE_FIELD_CHILD(ArrayInitData, index); - DELEGATE_FIELD_CHILD(ArrayInitData, ref); + DELEGATE_FIELD_NAME_KIND(ArrayInitData, segment, ModuleItemKind::DataSegment) + DELEGATE_FIELD_CHILD(ArrayInitData, size) + DELEGATE_FIELD_CHILD(ArrayInitData, offset) + DELEGATE_FIELD_CHILD(ArrayInitData, index) + DELEGATE_FIELD_CHILD(ArrayInitData, ref) DELEGATE_FIELD_CASE_END(ArrayInitData) DELEGATE_FIELD_CASE_START(ArrayInitElem) - DELEGATE_FIELD_NAME_KIND(ArrayInitElem, segment, ModuleItemKind::ElementSegment); - DELEGATE_FIELD_CHILD(ArrayInitElem, size); - DELEGATE_FIELD_CHILD(ArrayInitElem, offset); - DELEGATE_FIELD_CHILD(ArrayInitElem, index); - DELEGATE_FIELD_CHILD(ArrayInitElem, ref); + DELEGATE_FIELD_NAME_KIND(ArrayInitElem, segment, ModuleItemKind::ElementSegment) + DELEGATE_FIELD_CHILD(ArrayInitElem, size) + DELEGATE_FIELD_CHILD(ArrayInitElem, offset) + DELEGATE_FIELD_CHILD(ArrayInitElem, index) + DELEGATE_FIELD_CHILD(ArrayInitElem, ref) DELEGATE_FIELD_CASE_END(ArrayInitElem) DELEGATE_FIELD_CASE_START(RefAs) - DELEGATE_FIELD_INT(RefAs, op); - DELEGATE_FIELD_CHILD(RefAs, value); + DELEGATE_FIELD_INT(RefAs, op) + DELEGATE_FIELD_CHILD(RefAs, value) DELEGATE_FIELD_CASE_END(RefAs) DELEGATE_FIELD_CASE_START(StringNew) - DELEGATE_FIELD_INT(StringNew, op); - DELEGATE_FIELD_INT(StringNew, try_); - DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, end); - DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, start); - DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, length); - DELEGATE_FIELD_CHILD(StringNew, ptr); + DELEGATE_FIELD_INT(StringNew, op) + DELEGATE_FIELD_INT(StringNew, try_) + DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, end) + DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, start) + DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, length) + DELEGATE_FIELD_CHILD(StringNew, ptr) DELEGATE_FIELD_CASE_END(StringNew) DELEGATE_FIELD_CASE_START(StringConst) - DELEGATE_FIELD_NAME(StringConst, string); + DELEGATE_FIELD_NAME(StringConst, string) DELEGATE_FIELD_CASE_END(StringConst) DELEGATE_FIELD_CASE_START(StringMeasure) - DELEGATE_FIELD_INT(StringMeasure, op); - DELEGATE_FIELD_CHILD(StringMeasure, ref); + DELEGATE_FIELD_INT(StringMeasure, op) + DELEGATE_FIELD_CHILD(StringMeasure, ref) DELEGATE_FIELD_CASE_END(StringMeasure) DELEGATE_FIELD_CASE_START(StringEncode) - DELEGATE_FIELD_INT(StringEncode, op); - DELEGATE_FIELD_OPTIONAL_CHILD(StringEncode, start); - DELEGATE_FIELD_CHILD(StringEncode, ptr); - DELEGATE_FIELD_CHILD(StringEncode, ref); + DELEGATE_FIELD_INT(StringEncode, op) + DELEGATE_FIELD_OPTIONAL_CHILD(StringEncode, start) + DELEGATE_FIELD_CHILD(StringEncode, ptr) + DELEGATE_FIELD_CHILD(StringEncode, ref) DELEGATE_FIELD_CASE_END(StringEncode) DELEGATE_FIELD_CASE_START(StringConcat) - DELEGATE_FIELD_CHILD(StringConcat, right); - DELEGATE_FIELD_CHILD(StringConcat, left); + DELEGATE_FIELD_CHILD(StringConcat, right) + DELEGATE_FIELD_CHILD(StringConcat, left) DELEGATE_FIELD_CASE_END(StringConcat) DELEGATE_FIELD_CASE_START(StringEq) - DELEGATE_FIELD_INT(StringEq, op); - DELEGATE_FIELD_CHILD(StringEq, right); - DELEGATE_FIELD_CHILD(StringEq, left); + DELEGATE_FIELD_INT(StringEq, op) + DELEGATE_FIELD_CHILD(StringEq, right) + DELEGATE_FIELD_CHILD(StringEq, left) DELEGATE_FIELD_CASE_END(StringEq) DELEGATE_FIELD_CASE_START(StringAs) - DELEGATE_FIELD_INT(StringAs, op); - DELEGATE_FIELD_CHILD(StringAs, ref); + DELEGATE_FIELD_INT(StringAs, op) + DELEGATE_FIELD_CHILD(StringAs, ref) DELEGATE_FIELD_CASE_END(StringAs) DELEGATE_FIELD_CASE_START(StringWTF8Advance) - DELEGATE_FIELD_CHILD(StringWTF8Advance, bytes); - DELEGATE_FIELD_CHILD(StringWTF8Advance, pos); - DELEGATE_FIELD_CHILD(StringWTF8Advance, ref); + DELEGATE_FIELD_CHILD(StringWTF8Advance, bytes) + DELEGATE_FIELD_CHILD(StringWTF8Advance, pos) + DELEGATE_FIELD_CHILD(StringWTF8Advance, ref) DELEGATE_FIELD_CASE_END(StringWTF8Advance) DELEGATE_FIELD_CASE_START(StringWTF16Get) - DELEGATE_FIELD_CHILD(StringWTF16Get, pos); - DELEGATE_FIELD_CHILD(StringWTF16Get, ref); + DELEGATE_FIELD_CHILD(StringWTF16Get, pos) + DELEGATE_FIELD_CHILD(StringWTF16Get, ref) DELEGATE_FIELD_CASE_END(StringWTF16Get) DELEGATE_FIELD_CASE_START(StringIterNext) - DELEGATE_FIELD_CHILD(StringIterNext, ref); + DELEGATE_FIELD_CHILD(StringIterNext, ref) DELEGATE_FIELD_CASE_END(StringIterNext) DELEGATE_FIELD_CASE_START(StringIterMove) - DELEGATE_FIELD_INT(StringIterMove, op); - DELEGATE_FIELD_CHILD(StringIterMove, num); - DELEGATE_FIELD_CHILD(StringIterMove, ref); + DELEGATE_FIELD_INT(StringIterMove, op) + DELEGATE_FIELD_CHILD(StringIterMove, num) + DELEGATE_FIELD_CHILD(StringIterMove, ref) DELEGATE_FIELD_CASE_END(StringIterMove) DELEGATE_FIELD_CASE_START(StringSliceWTF) - DELEGATE_FIELD_INT(StringSliceWTF, op); - DELEGATE_FIELD_CHILD(StringSliceWTF, end); - DELEGATE_FIELD_CHILD(StringSliceWTF, start); - DELEGATE_FIELD_CHILD(StringSliceWTF, ref); + DELEGATE_FIELD_INT(StringSliceWTF, op) + DELEGATE_FIELD_CHILD(StringSliceWTF, end) + DELEGATE_FIELD_CHILD(StringSliceWTF, start) + DELEGATE_FIELD_CHILD(StringSliceWTF, ref) DELEGATE_FIELD_CASE_END(StringSliceWTF) DELEGATE_FIELD_CASE_START(StringSliceIter) - DELEGATE_FIELD_CHILD(StringSliceIter, num); - DELEGATE_FIELD_CHILD(StringSliceIter, ref); + DELEGATE_FIELD_CHILD(StringSliceIter, num) + DELEGATE_FIELD_CHILD(StringSliceIter, ref) DELEGATE_FIELD_CASE_END(StringSliceIter) DELEGATE_FIELD_CASE_START(ContBind) - DELEGATE_FIELD_CHILD(ContBind, cont); - DELEGATE_FIELD_CHILD_VECTOR(ContBind, operands); - DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeAfter); - DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeBefore); + DELEGATE_FIELD_CHILD(ContBind, cont) + DELEGATE_FIELD_CHILD_VECTOR(ContBind, operands) + DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeAfter) + DELEGATE_FIELD_HEAPTYPE(ContBind, contTypeBefore) DELEGATE_FIELD_CASE_END(ContBind) DELEGATE_FIELD_CASE_START(ContNew) - DELEGATE_FIELD_CHILD(ContNew, func); - DELEGATE_FIELD_HEAPTYPE(ContNew, contType); + DELEGATE_FIELD_CHILD(ContNew, func) + DELEGATE_FIELD_HEAPTYPE(ContNew, contType) DELEGATE_FIELD_CASE_END(ContNew) DELEGATE_FIELD_CASE_START(Resume) - DELEGATE_FIELD_TYPE_VECTOR(Resume, sentTypes); - DELEGATE_FIELD_CHILD(Resume, cont); - DELEGATE_FIELD_CHILD_VECTOR(Resume, operands); - DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Resume, handlerBlocks); - DELEGATE_FIELD_NAME_KIND_VECTOR(Resume, handlerTags, ModuleItemKind::Tag); - DELEGATE_FIELD_HEAPTYPE(Resume, contType); + DELEGATE_FIELD_TYPE_VECTOR(Resume, sentTypes) + DELEGATE_FIELD_CHILD(Resume, cont) + DELEGATE_FIELD_CHILD_VECTOR(Resume, operands) + DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Resume, handlerBlocks) + DELEGATE_FIELD_NAME_KIND_VECTOR(Resume, handlerTags, ModuleItemKind::Tag) + DELEGATE_FIELD_HEAPTYPE(Resume, contType) DELEGATE_FIELD_CASE_END(Resume) DELEGATE_FIELD_CASE_START(Suspend) - DELEGATE_FIELD_CHILD_VECTOR(Suspend, operands); - DELEGATE_FIELD_NAME_KIND(Suspend, tag, ModuleItemKind::Tag); + DELEGATE_FIELD_CHILD_VECTOR(Suspend, operands) + DELEGATE_FIELD_NAME_KIND(Suspend, tag, ModuleItemKind::Tag) DELEGATE_FIELD_CASE_END(Suspend) DELEGATE_FIELD_MAIN_END From b3ba1edf0d2cc1f7c3d4a7f12da80d0f0227597d Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 15:47:14 -0700 Subject: [PATCH 28/36] work --- src/binaryen-embind.cpp | 20 ++++++++------------ src/ir/ExpressionAnalyzer.cpp | 2 +- src/ir/branch-utils.h | 2 +- src/wasm-delegations-fields.def | 20 ++++++++++---------- 4 files changed, 20 insertions(+), 24 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 7e4378d9175..89e8bf6830f 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -80,17 +80,13 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property("type", &Expression::type); // Expression types, autogenerated. - +#if 0 #define DELEGATE_ID id -#define DELEGATE_START(id) std::cout << "// " #id << '\n'; - -#define DELEGATE_END(id) std::cout << '\n'; - #define DELEGATE_FIELD_CHILD(id, field) \ - .property(#field, &id::field) + .property(#field, &id::field, allow_raw_pointers()) #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ - .property(#field, &id::field) + // TODO .property(#field, &id::field) #define DELEGATE_FIELD_TYPE(id, field) \ .property(#field, &id::field) #define DELEGATE_FIELD_HEAPTYPE(id, field) \ @@ -112,13 +108,13 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_FIELD_INT_ARRAY(id, field) \ .property(#field, &id::field) #define DELEGATE_FIELD_INT_VECTOR(id, field) \ - .property(#field, &id::field) + // TODO .property(#field, &id::field) #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ - .property(#field, &id::field) + // TODO .property(#field, &id::field) #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ - .property(#field, &id::field) + // TODO .property(#field, &id::field) #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ - .property(#field, &id::field) + // TODO .property(#field, &id::field) #define DELEGATE_FIELD_MAIN_START @@ -131,7 +127,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_FIELD_MAIN_END #include "wasm-delegations-fields.def" - +#endif // Module-level constructs. class_("Named") diff --git a/src/ir/ExpressionAnalyzer.cpp b/src/ir/ExpressionAnalyzer.cpp index a75abd6ce9f..a6f11a7c4be 100644 --- a/src/ir/ExpressionAnalyzer.cpp +++ b/src/ir/ExpressionAnalyzer.cpp @@ -319,7 +319,7 @@ struct Hasher { #define DELEGATE_FIELD_INT(id, field) HASH_FIELD(field) #define DELEGATE_FIELD_LITERAL(id, field) HASH_FIELD(field) -#define DELEGATE_FIELD_NAME(id, field) visitNonScopeName(cast->field) +#define DELEGATE_FIELD_NAME(id, field) visitNonScopeName(cast->field); #define DELEGATE_FIELD_TYPE(id, field) visitType(cast->field); #define DELEGATE_FIELD_HEAPTYPE(id, field) visitHeapType(cast->field); #define DELEGATE_FIELD_ADDRESS(id, field) visitAddress(cast->field); diff --git a/src/ir/branch-utils.h b/src/ir/branch-utils.h index 28e29ede402..d90f3a1947d 100644 --- a/src/ir/branch-utils.h +++ b/src/ir/branch-utils.h @@ -132,7 +132,7 @@ template void operateOnScopeNameDefs(Expression* expr, T func) { #define DELEGATE_GET_FIELD(id, field) cast->field -#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) func(cast->field) +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) func(cast->field); #define DELEGATE_FIELD_CHILD(id, field) #define DELEGATE_FIELD_INT(id, field) diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index aeb9dec7e93..9877b6f3679 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -117,7 +117,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ for (int i = int((DELEGATE_GET_FIELD(id, field)).size()) - 1; i >= 0; i--) { \ - DELEGATE_FIELD_CHILD(id, field[i]); \ + DELEGATE_FIELD_CHILD(id, field[i]) \ } #else #error please define DELEGATE_FIELD_CHILD_VECTOR(id, field) @@ -132,7 +132,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_INT_ARRAY(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_INT(id, field[i]); \ + DELEGATE_FIELD_INT(id, field[i]) \ } #else #error please define DELEGATE_FIELD_INT_ARRAY(id, field) @@ -143,7 +143,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_INT_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_INT(id, field[i]); \ + DELEGATE_FIELD_INT(id, field[i]) \ } #else #error please define DELEGATE_FIELD_INT_VECTOR(id, field) @@ -162,7 +162,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_NAME(id, field[i]); \ + DELEGATE_FIELD_NAME(id, field[i]) \ } #else #error please define DELEGATE_FIELD_NAME_VECTOR(id, field) @@ -181,7 +181,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_SCOPE_NAME_USE(id, field[i]); \ + DELEGATE_FIELD_SCOPE_NAME_USE(id, field[i]) \ } #else #error please define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) @@ -190,14 +190,14 @@ #ifndef DELEGATE_FIELD_NAME_KIND #define DELEGATE_FIELD_NAME_KIND(id, field, kind) \ - DELEGATE_FIELD_NAME(id, field); + DELEGATE_FIELD_NAME(id, field) #endif #ifndef DELEGATE_FIELD_NAME_KIND_VECTOR #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_NAME_KIND(id, field[i], kind); \ + DELEGATE_FIELD_NAME_KIND(id, field[i], kind) \ } #else #define DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) \ @@ -213,7 +213,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_TYPE(id, field[i]); \ + DELEGATE_FIELD_TYPE(id, field[i]) \ } #else #error please define DELEGATE_FIELD_TYPE_VECTOR(id, field) @@ -243,12 +243,12 @@ switch (DELEGATE_ID) { \ #ifndef DELEGATE_FIELD_CASE_START #define DELEGATE_FIELD_CASE_START(id) \ case Expression::Id::id##Id: { \ - DELEGATE_START(id); + DELEGATE_START(id) #endif #ifndef DELEGATE_FIELD_CASE_END #define DELEGATE_FIELD_CASE_END(id) \ - DELEGATE_END(id); \ + DELEGATE_END(id) \ break; \ } #endif From e2e3148b7bf05053e502f091221a1ffd83198b2b Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Tue, 2 Apr 2024 16:04:20 -0700 Subject: [PATCH 29/36] work --- src/binaryen-embind.cpp | 8 +++----- src/wasm-delegations-fields.def | 6 +++--- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 89e8bf6830f..4433efb0536 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -80,19 +80,17 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property("type", &Expression::type); // Expression types, autogenerated. -#if 0 + #define DELEGATE_ID id #define DELEGATE_FIELD_CHILD(id, field) \ - .property(#field, &id::field, allow_raw_pointers()) + .property(#field, &id::field, allow_raw_pointers()) // errors due to https://github.com/emscripten-core/emscripten/issues/6492 #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ // TODO .property(#field, &id::field) #define DELEGATE_FIELD_TYPE(id, field) \ .property(#field, &id::field) #define DELEGATE_FIELD_HEAPTYPE(id, field) \ .property(#field, &id::field) -#define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) \ - .property(#field, &id::field) #define DELEGATE_FIELD_INT(id, field) \ .property(#field, &id::field) #define DELEGATE_FIELD_LITERAL(id, field) \ @@ -127,7 +125,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_FIELD_MAIN_END #include "wasm-delegations-fields.def" -#endif + // Module-level constructs. class_("Named") diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index 9877b6f3679..f620b8ac535 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -671,9 +671,9 @@ DELEGATE_FIELD_CASE_START(ArrayGet) DELEGATE_FIELD_CASE_END(ArrayGet) DELEGATE_FIELD_CASE_START(ArraySet) - DELEGATE_FIELD_CHILD(ArrayGet, value) - DELEGATE_FIELD_CHILD(ArrayGet, index) - DELEGATE_FIELD_CHILD(ArrayGet, ref) + DELEGATE_FIELD_CHILD(ArraySet, value) + DELEGATE_FIELD_CHILD(ArraySet, index) + DELEGATE_FIELD_CHILD(ArraySet, ref) DELEGATE_FIELD_CASE_END(ArraySet) DELEGATE_FIELD_CASE_START(ArrayLen) From 53ec85f312a66fa195322bf57f48b47716004a3f Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Thu, 23 Jan 2025 11:10:53 -0800 Subject: [PATCH 30/36] format --- src/wasm-delegations-fields.def | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index f620b8ac535..7bf342ffa75 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -117,7 +117,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ for (int i = int((DELEGATE_GET_FIELD(id, field)).size()) - 1; i >= 0; i--) { \ - DELEGATE_FIELD_CHILD(id, field[i]) \ + DELEGATE_FIELD_CHILD(id, field[i]) \ } #else #error please define DELEGATE_FIELD_CHILD_VECTOR(id, field) @@ -132,7 +132,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_INT_ARRAY(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_INT(id, field[i]) \ + DELEGATE_FIELD_INT(id, field[i]) \ } #else #error please define DELEGATE_FIELD_INT_ARRAY(id, field) @@ -143,7 +143,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_INT_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_INT(id, field[i]) \ + DELEGATE_FIELD_INT(id, field[i]) \ } #else #error please define DELEGATE_FIELD_INT_VECTOR(id, field) @@ -162,7 +162,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_NAME(id, field[i]) \ + DELEGATE_FIELD_NAME(id, field[i]) \ } #else #error please define DELEGATE_FIELD_NAME_VECTOR(id, field) @@ -181,7 +181,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_SCOPE_NAME_USE(id, field[i]) \ + DELEGATE_FIELD_SCOPE_NAME_USE(id, field[i]) \ } #else #error please define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) @@ -197,7 +197,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_NAME_KIND(id, field[i], kind) \ + DELEGATE_FIELD_NAME_KIND(id, field[i], kind) \ } #else #define DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) \ @@ -213,7 +213,7 @@ #ifdef DELEGATE_GET_FIELD #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ - DELEGATE_FIELD_TYPE(id, field[i]) \ + DELEGATE_FIELD_TYPE(id, field[i]) \ } #else #error please define DELEGATE_FIELD_TYPE_VECTOR(id, field) From 4134007bf82fc9592095b15cf26c1c726616765a Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Thu, 23 Jan 2025 11:43:12 -0800 Subject: [PATCH 31/36] testpass --- CMakeLists.txt | 2 ++ src/binaryen-embind.cpp | 1 - test/binaryen-embind.js/basics.js | 16 ++++++++-------- 3 files changed, 10 insertions(+), 9 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 65c54fff41a..dd7a31ca668 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -357,6 +357,8 @@ if(EMSCRIPTEN) add_compile_flag("-sDISABLE_EXCEPTION_CATCHING=0") add_link_flag("-sDISABLE_EXCEPTION_CATCHING=0") endif() + # TODO: only for binaryen.js? + add_compile_flag("-DEMSCRIPTEN_HAS_UNBOUND_TYPE_NAMES=0") if(EMSCRIPTEN_ENABLE_PTHREADS) add_compile_flag("-pthread") add_link_flag("-pthread") diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 4433efb0536..e9cde1db2c8 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -57,7 +57,6 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("isSignature", &Type::isSignature) .function("isStruct", &Type::isStruct) .function("isArray", &Type::isArray) - .function("isException", &Type::isException) .function("isString", &Type::isString) .function("isDefaultable", &Type::isDefaultable) .function("getHeapType", &Type::getHeapType) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 02cb51dc714..87b6c9c12ca 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -46,14 +46,14 @@ binaryenFactory().then((binaryen) => { // Check the function prints out ok. normEqual(binaryen.stringify(module), - ` - (module - (type $0 (func (param i32) (result i32))) - (func $foo (param $0 i32) (result i32) - (nop) - ) - ) - `); + ` + (module + (type $0 (func (param i32) (result i32))) + (func $foo (param $0 i32) (result i32) + (nop) + ) + ) + `); // Clean up. XXX new HeapType etc. are all unneeded and also leaked! module.delete(); From 68a2fb6d2947c83f29301089a244d1a7f915c948 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Thu, 23 Jan 2025 11:50:42 -0800 Subject: [PATCH 32/36] hmm --- src/binaryen-embind.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index e9cde1db2c8..f702e2f93ea 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -105,13 +105,13 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_FIELD_INT_ARRAY(id, field) \ .property(#field, &id::field) #define DELEGATE_FIELD_INT_VECTOR(id, field) \ - // TODO .property(#field, &id::field) + .property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ - // TODO .property(#field, &id::field) + .property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ - // TODO .property(#field, &id::field) + .property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ - // TODO .property(#field, &id::field) + .property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_MAIN_START From f316a0e34a9995735756feef93351c975262f5be Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Thu, 23 Jan 2025 11:51:00 -0800 Subject: [PATCH 33/36] format --- src/binaryen-embind.cpp | 114 +++++++++++++++++----------------------- 1 file changed, 47 insertions(+), 67 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index f702e2f93ea..0763bf5ff5f 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -20,8 +20,8 @@ #include -#include "wasm.h" #include "wasm-builder.h" +#include "wasm.h" using namespace wasm; using namespace emscripten; @@ -41,9 +41,7 @@ EMSCRIPTEN_BINDINGS(Binaryen) { function("stringify", &stringify); - enum_("BasicType") - .value("i32", Type::BasicType::i32) - ; + enum_("BasicType").value("i32", Type::BasicType::i32); class_("Type") .constructor() @@ -59,67 +57,54 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .function("isArray", &Type::isArray) .function("isString", &Type::isString) .function("isDefaultable", &Type::isDefaultable) - .function("getHeapType", &Type::getHeapType) - ; + .function("getHeapType", &Type::getHeapType); register_vector("TypeVec"); value_object("Signature") .field("params", &Signature::params) - .field("results", &Signature::results) - ; + .field("results", &Signature::results); - class_("HeapType") - .constructor() - ; + class_("HeapType").constructor(); - class_("Name") - .constructor(); + class_("Name").constructor(); - class_("Expression") - .property("type", &Expression::type); + class_("Expression").property("type", &Expression::type); // Expression types, autogenerated. #define DELEGATE_ID id #define DELEGATE_FIELD_CHILD(id, field) \ - .property(#field, &id::field, allow_raw_pointers()) // errors due to https://github.com/emscripten-core/emscripten/issues/6492 + .property( \ + #field, \ + &id::field, \ + allow_raw_pointers()) // errors due to + // https://github.com/emscripten-core/emscripten/issues/6492 #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ - // TODO .property(#field, &id::field) -#define DELEGATE_FIELD_TYPE(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_HEAPTYPE(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_INT(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_LITERAL(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_NAME(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_ADDRESS(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_INT_ARRAY(id, field) \ - .property(#field, &id::field) -#define DELEGATE_FIELD_INT_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) -#define DELEGATE_FIELD_NAME_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) -#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) -#define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) + // TODO .property(#field, &id::field) +#define DELEGATE_FIELD_TYPE(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_HEAPTYPE(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_INT(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_LITERAL(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_NAME(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_ADDRESS(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_INT_ARRAY(id, field) .property(#field, &id::field) +#define DELEGATE_FIELD_INT_VECTOR(id, field) \ + .property(#field, &id::field, return_value_policy::reference()) +#define DELEGATE_FIELD_NAME_VECTOR(id, field) \ + .property(#field, &id::field, return_value_policy::reference()) +#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ + .property(#field, &id::field, return_value_policy::reference()) +#define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ + .property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_MAIN_START -#define DELEGATE_FIELD_CASE_START(id) \ - class_>(#id) +#define DELEGATE_FIELD_CASE_START(id) class_>(#id) -#define DELEGATE_FIELD_CASE_END(id) \ - ; +#define DELEGATE_FIELD_CASE_END(id) ; #define DELEGATE_FIELD_MAIN_END @@ -127,43 +112,38 @@ EMSCRIPTEN_BINDINGS(Binaryen) { // Module-level constructs. - class_("Named") - .property("name", &Named::name); + class_("Named").property("name", &Named::name); class_("Importable") .property("module", &Importable::module) - .property("base", &Importable::base) - ; + .property("base", &Importable::base); - class_("Function") - ; + class_("Function"); class_("NameType") .constructor() .property("name", &NameType::name) - .property("type", &NameType::type) - ; + .property("type", &NameType::type); register_vector("NameTypeVec"); class_("Builder") .constructor() .class_function("makeFunction", - select_overload (Name, - HeapType, - std::vector&& vars, - Expression*) - >(&Builder::makeFunction), allow_raw_pointers()) + select_overload( + Name, HeapType, std::vector && vars, Expression*)>( + &Builder::makeFunction), + allow_raw_pointers()) - // TODO All Expression classes... - .function("makeNop", &Builder::makeNop, allow_raw_pointers()) - ; + // TODO All Expression classes... + .function("makeNop", &Builder::makeNop, allow_raw_pointers()); class_("Module") .smart_ptr_constructor("Module", &std::make_shared) .property("start", &Module::start) .function("getFunction", &Module::getFunction, allow_raw_pointers()) - .function("getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) - .function("addFunction", select_overload(&Module::addFunction), allow_raw_pointers()) - ; - + .function( + "getFunctionOrNull", &Module::getFunctionOrNull, allow_raw_pointers()) + .function("addFunction", + select_overload(&Module::addFunction), + allow_raw_pointers()); } From 9b3b87ce15963f7041c780d24c46116b380bd081 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 24 Jan 2025 12:52:49 -0800 Subject: [PATCH 34/36] fixes --- CMakeLists.txt | 2 +- src/binaryen-embind.cpp | 32 +++++++++++++++++++------------ src/wasm-delegations-fields.def | 2 +- test/binaryen-embind.js/basics.js | 4 +++- 4 files changed, 25 insertions(+), 15 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index dd7a31ca668..68142f895a7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -386,7 +386,7 @@ if(EMSCRIPTEN) add_link_flag("-sNODERAWFS") endif() # in opt builds, LTO helps so much (>20%) it's worth slow compile times - add_nondebug_compile_flag("-flto") + # add_nondebug_compile_flag("-flto") if(EMSCRIPTEN_ENABLE_WASM64) add_compile_flag("-sMEMORY64 -Wno-experimental") add_link_flag("-sMEMORY64") diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index 0763bf5ff5f..c6866cf3c53 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -35,13 +35,23 @@ std::string stringify(Module& wasm) { return str.str(); } +// Embind generates getters and setters for properties like +// DELEGATE_FIELD_CHILD_VECTOR. The setter in those cases needs a copy +// constructor, which we intentionally do not have for ArenaVectors etc. To +// work around this, we define a getter +//struct VecWrapper + } // anonymous namespace EMSCRIPTEN_BINDINGS(Binaryen) { function("stringify", &stringify); - enum_("BasicType").value("i32", Type::BasicType::i32); + enum_("BasicType") + .value("i32", Type::BasicType::i32) + .value("i64", Type::BasicType::i64) + .value("f32", Type::BasicType::f32) + .value("f64", Type::BasicType::f64); class_("Type") .constructor() @@ -78,10 +88,9 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .property( \ #field, \ &id::field, \ - allow_raw_pointers()) // errors due to - // https://github.com/emscripten-core/emscripten/issues/6492 + allow_raw_pointers()) #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ - // TODO .property(#field, &id::field) + .function("get_" #field, +[](id& curr) { return &curr.field; }, return_value_policy::reference()) #define DELEGATE_FIELD_TYPE(id, field) .property(#field, &id::field) #define DELEGATE_FIELD_HEAPTYPE(id, field) .property(#field, &id::field) #define DELEGATE_FIELD_INT(id, field) .property(#field, &id::field) @@ -92,13 +101,13 @@ EMSCRIPTEN_BINDINGS(Binaryen) { #define DELEGATE_FIELD_ADDRESS(id, field) .property(#field, &id::field) #define DELEGATE_FIELD_INT_ARRAY(id, field) .property(#field, &id::field) #define DELEGATE_FIELD_INT_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) + //.property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) + //.property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) + //.property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ - .property(#field, &id::field, return_value_policy::reference()) + //.property(#field, &id::field, return_value_policy::reference()) #define DELEGATE_FIELD_MAIN_START @@ -120,10 +129,9 @@ EMSCRIPTEN_BINDINGS(Binaryen) { class_("Function"); - class_("NameType") - .constructor() - .property("name", &NameType::name) - .property("type", &NameType::type); + value_object("NameType") + .field("name", &NameType::name) + .field("type", &NameType::type); register_vector("NameTypeVec"); class_("Builder") diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index 623ccbd397e..ab8b6aac96e 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -592,7 +592,7 @@ DELEGATE_FIELD_CASE_START(Pop) DELEGATE_FIELD_CASE_END(Pop) DELEGATE_FIELD_CASE_START(TupleMake) -DELEGATE_FIELD_CHILD_VECTOR(Tuple, operands) +DELEGATE_FIELD_CHILD_VECTOR(TupleMake, operands) DELEGATE_FIELD_CASE_END(TupleMake) DELEGATE_FIELD_CASE_START(TupleExtract) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 87b6c9c12ca..b1f346c2c30 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -36,6 +36,7 @@ binaryenFactory().then((binaryen) => { }; const func_ii = new binaryen.HeapType(sig); const vars = new binaryen.TypeVec(); + vars.push_back(binaryen.BasicType.f64); const func = binaryen.Builder.makeFunction( new binaryen.Name("foo"), func_ii, @@ -50,12 +51,13 @@ binaryenFactory().then((binaryen) => { (module (type $0 (func (param i32) (result i32))) (func $foo (param $0 i32) (result i32) + (local $temp f64) (nop) ) ) `); - // Clean up. XXX new HeapType etc. are all unneeded and also leaked! + // Clean up. TODO: |new HeapType| etc. above are leaked atm. module.delete(); console.log('success.'); From 91e1029d3782abd62873e81878f521bfc064ff22 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 24 Jan 2025 12:59:12 -0800 Subject: [PATCH 35/36] test.passes --- src/binaryen-embind.cpp | 2 ++ test/binaryen-embind.js/basics.js | 5 +++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index c6866cf3c53..af35a8d3445 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -53,6 +53,8 @@ EMSCRIPTEN_BINDINGS(Binaryen) { .value("f32", Type::BasicType::f32) .value("f64", Type::BasicType::f64); + // TODO: make a "type factory" that produces types, so we can use + // value_object for Type? class_("Type") .constructor() .function("isTuple", &Type::isTuple) diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index b1f346c2c30..05cb8ffdefd 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -30,13 +30,14 @@ binaryenFactory().then((binaryen) => { // Generate a function and everything we need for that. const i32 = new binaryen.Type(binaryen.BasicType.i32); + const f64 = new binaryen.Type(binaryen.BasicType.f64); const sig = { params: i32, results: i32 }; const func_ii = new binaryen.HeapType(sig); const vars = new binaryen.TypeVec(); - vars.push_back(binaryen.BasicType.f64); + vars.push_back(f64); const func = binaryen.Builder.makeFunction( new binaryen.Name("foo"), func_ii, @@ -51,7 +52,7 @@ binaryenFactory().then((binaryen) => { (module (type $0 (func (param i32) (result i32))) (func $foo (param $0 i32) (result i32) - (local $temp f64) + (local $1 f64) (nop) ) ) From 9c7144ade408efd8070d455408a184a93b867da4 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 24 Jan 2025 13:16:07 -0800 Subject: [PATCH 36/36] work [ci skip] --- src/binaryen-embind.cpp | 12 +- src/wasm-delegations.def | 188 +++++++++++++++--------------- src/wasm-traversal.h | 2 +- test/binaryen-embind.js/basics.js | 2 +- 4 files changed, 106 insertions(+), 98 deletions(-) diff --git a/src/binaryen-embind.cpp b/src/binaryen-embind.cpp index af35a8d3445..d1bff33f617 100644 --- a/src/binaryen-embind.cpp +++ b/src/binaryen-embind.cpp @@ -144,8 +144,16 @@ EMSCRIPTEN_BINDINGS(Binaryen) { &Builder::makeFunction), allow_raw_pointers()) - // TODO All Expression classes... - .function("makeNop", &Builder::makeNop, allow_raw_pointers()); + // Create constructors for all classes. +//#define DELEGATE(id) \ +// .function("make" #id, &Builder::make##id, allow_raw_pointers()) +//#include "wasm-delegations.def" +// The above can't naively work. Nop will, on the one hand: +.function("make" "Nop", &Builder::makeNop, allow_raw_pointers()) +// but Block has overloads, and we'd need to manually write one out, like this, +// which avoids fully automating things. +.function("make" "Block", +[](Builder& builder) { return builder.makeBlock(..); }, allow_raw_pointers()) + ; class_("Module") .smart_ptr_constructor("Module", &std::make_shared) diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def index eb24feb7b83..413901eb70b 100644 --- a/src/wasm-delegations.def +++ b/src/wasm-delegations.def @@ -1,7 +1,7 @@ /* * Copyright 2020 WebAssembly Community Group participants * - * Licensed under the Apache License, Version 2.0 (the "License"); + * Licensed under the Apache License, Version 2.0 (the "License") * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * @@ -14,98 +14,98 @@ * limitations under the License. */ -DELEGATE(Nop); -DELEGATE(Block); -DELEGATE(If); -DELEGATE(Loop); -DELEGATE(Break); -DELEGATE(Switch); -DELEGATE(Call); -DELEGATE(CallIndirect); -DELEGATE(LocalGet); -DELEGATE(LocalSet); -DELEGATE(GlobalGet); -DELEGATE(GlobalSet); -DELEGATE(Load); -DELEGATE(Store); -DELEGATE(AtomicRMW); -DELEGATE(AtomicCmpxchg); -DELEGATE(AtomicWait); -DELEGATE(AtomicNotify); -DELEGATE(AtomicFence); -DELEGATE(SIMDExtract); -DELEGATE(SIMDReplace); -DELEGATE(SIMDShuffle); -DELEGATE(SIMDTernary); -DELEGATE(SIMDShift); -DELEGATE(SIMDLoad); -DELEGATE(SIMDLoadStoreLane); -DELEGATE(MemoryInit); -DELEGATE(DataDrop); -DELEGATE(MemoryCopy); -DELEGATE(MemoryFill); -DELEGATE(Const); -DELEGATE(Unary); -DELEGATE(Binary); -DELEGATE(Select); -DELEGATE(Drop); -DELEGATE(Return); -DELEGATE(MemorySize); -DELEGATE(MemoryGrow); -DELEGATE(Unreachable); -DELEGATE(Pop); -DELEGATE(RefNull); -DELEGATE(RefIsNull); -DELEGATE(RefFunc); -DELEGATE(RefEq); -DELEGATE(TableGet); -DELEGATE(TableSet); -DELEGATE(TableSize); -DELEGATE(TableGrow); -DELEGATE(TableFill); -DELEGATE(TableCopy); -DELEGATE(TableInit); -DELEGATE(Try); -DELEGATE(TryTable); -DELEGATE(Throw); -DELEGATE(Rethrow); -DELEGATE(ThrowRef); -DELEGATE(TupleMake); -DELEGATE(TupleExtract); -DELEGATE(RefI31); -DELEGATE(I31Get); -DELEGATE(CallRef); -DELEGATE(RefTest); -DELEGATE(RefCast); -DELEGATE(BrOn); -DELEGATE(StructNew); -DELEGATE(StructGet); -DELEGATE(StructSet); -DELEGATE(StructRMW); -DELEGATE(StructCmpxchg); -DELEGATE(ArrayNew); -DELEGATE(ArrayNewData); -DELEGATE(ArrayNewElem); -DELEGATE(ArrayNewFixed); -DELEGATE(ArrayGet); -DELEGATE(ArraySet); -DELEGATE(ArrayLen); -DELEGATE(ArrayCopy); -DELEGATE(ArrayFill); -DELEGATE(ArrayInitData); -DELEGATE(ArrayInitElem); -DELEGATE(RefAs); -DELEGATE(StringNew); -DELEGATE(StringConst); -DELEGATE(StringMeasure); -DELEGATE(StringEncode); -DELEGATE(StringConcat); -DELEGATE(StringEq); -DELEGATE(StringWTF16Get); -DELEGATE(StringSliceWTF); -DELEGATE(ContBind); -DELEGATE(ContNew); -DELEGATE(Resume); -DELEGATE(Suspend); +DELEGATE(Nop) +DELEGATE(Block) +DELEGATE(If) +DELEGATE(Loop) +DELEGATE(Break) +DELEGATE(Switch) +DELEGATE(Call) +DELEGATE(CallIndirect) +DELEGATE(LocalGet) +DELEGATE(LocalSet) +DELEGATE(GlobalGet) +DELEGATE(GlobalSet) +DELEGATE(Load) +DELEGATE(Store) +DELEGATE(AtomicRMW) +DELEGATE(AtomicCmpxchg) +DELEGATE(AtomicWait) +DELEGATE(AtomicNotify) +DELEGATE(AtomicFence) +DELEGATE(SIMDExtract) +DELEGATE(SIMDReplace) +DELEGATE(SIMDShuffle) +DELEGATE(SIMDTernary) +DELEGATE(SIMDShift) +DELEGATE(SIMDLoad) +DELEGATE(SIMDLoadStoreLane) +DELEGATE(MemoryInit) +DELEGATE(DataDrop) +DELEGATE(MemoryCopy) +DELEGATE(MemoryFill) +DELEGATE(Const) +DELEGATE(Unary) +DELEGATE(Binary) +DELEGATE(Select) +DELEGATE(Drop) +DELEGATE(Return) +DELEGATE(MemorySize) +DELEGATE(MemoryGrow) +DELEGATE(Unreachable) +DELEGATE(Pop) +DELEGATE(RefNull) +DELEGATE(RefIsNull) +DELEGATE(RefFunc) +DELEGATE(RefEq) +DELEGATE(TableGet) +DELEGATE(TableSet) +DELEGATE(TableSize) +DELEGATE(TableGrow) +DELEGATE(TableFill) +DELEGATE(TableCopy) +DELEGATE(TableInit) +DELEGATE(Try) +DELEGATE(TryTable) +DELEGATE(Throw) +DELEGATE(Rethrow) +DELEGATE(ThrowRef) +DELEGATE(TupleMake) +DELEGATE(TupleExtract) +DELEGATE(RefI31) +DELEGATE(I31Get) +DELEGATE(CallRef) +DELEGATE(RefTest) +DELEGATE(RefCast) +DELEGATE(BrOn) +DELEGATE(StructNew) +DELEGATE(StructGet) +DELEGATE(StructSet) +DELEGATE(StructRMW) +DELEGATE(StructCmpxchg) +DELEGATE(ArrayNew) +DELEGATE(ArrayNewData) +DELEGATE(ArrayNewElem) +DELEGATE(ArrayNewFixed) +DELEGATE(ArrayGet) +DELEGATE(ArraySet) +DELEGATE(ArrayLen) +DELEGATE(ArrayCopy) +DELEGATE(ArrayFill) +DELEGATE(ArrayInitData) +DELEGATE(ArrayInitElem) +DELEGATE(RefAs) +DELEGATE(StringNew) +DELEGATE(StringConst) +DELEGATE(StringMeasure) +DELEGATE(StringEncode) +DELEGATE(StringConcat) +DELEGATE(StringEq) +DELEGATE(StringWTF16Get) +DELEGATE(StringSliceWTF) +DELEGATE(ContBind) +DELEGATE(ContNew) +DELEGATE(Resume) +DELEGATE(Suspend) #undef DELEGATE diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h index db9d1c1c4f9..6f610cd91a8 100644 --- a/src/wasm-traversal.h +++ b/src/wasm-traversal.h @@ -62,7 +62,7 @@ template struct Visitor { #define DELEGATE(CLASS_TO_VISIT) \ case Expression::Id::CLASS_TO_VISIT##Id: \ return static_cast(this)->visit##CLASS_TO_VISIT( \ - static_cast(curr)) + static_cast(curr)); #include "wasm-delegations.def" diff --git a/test/binaryen-embind.js/basics.js b/test/binaryen-embind.js/basics.js index 05cb8ffdefd..49963768259 100644 --- a/test/binaryen-embind.js/basics.js +++ b/test/binaryen-embind.js/basics.js @@ -42,7 +42,7 @@ binaryenFactory().then((binaryen) => { new binaryen.Name("foo"), func_ii, vars, - builder.makeNop() + builder.makeBinary(10, builder.makeNop(), builder.makeNop()) ); module.addFunction(func);