Initial commit: update CMakeLists and add some basic embind functiona…

…lity

CMakeLists.txt

@@ -528,9 +528,11 @@ endif()
 # Note that we can't emit binaryen.js directly, as there is libbinaryen already
 # declared earlier, so we create binaryen_wasm/js.js, which must then be copied.
 if(EMSCRIPTEN)
+  add_compile_flag("-DEMSCRIPTEN_HAS_UNBOUND_TYPE_NAMES=0")
+
   # binaryen.js WebAssembly variant
-  add_executable(binaryen_wasm ${binaryen_SOURCES})
-  target_link_libraries(binaryen_wasm PRIVATE binaryen)
+  add_executable(binaryen_wasm src/binaryen-embind.cpp)
+  target_link_libraries(binaryen_wasm PRIVATE "-Wl,--whole-archive" binaryen)
   target_link_libraries(binaryen_wasm PRIVATE "-sFILESYSTEM")
   target_link_libraries(binaryen_wasm PRIVATE "-sEXPORT_NAME=Binaryen")
   target_link_libraries(binaryen_wasm PRIVATE "-sNODERAWFS=0")
@@ -542,12 +544,10 @@ if(EMSCRIPTEN)
     target_link_libraries(binaryen_wasm PRIVATE "-sSINGLE_FILE")
   endif()
   target_link_libraries(binaryen_wasm PRIVATE "-sEXPORT_ES6")
-  target_link_libraries(binaryen_wasm PRIVATE "-sEXPORTED_RUNTIME_METHODS=stringToUTF8OnStack,stringToAscii")
-  target_link_libraries(binaryen_wasm PRIVATE "-sEXPORTED_FUNCTIONS=_malloc,_free")
-  target_link_libraries(binaryen_wasm PRIVATE "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js")
+  target_link_libraries(binaryen_wasm PRIVATE "-lembind")
+  target_link_libraries(binaryen_wasm PRIVATE "--emit-tsd binaryen.d.ts")
   target_link_libraries(binaryen_wasm PRIVATE "-msign-ext")
   target_link_libraries(binaryen_wasm PRIVATE "-mbulk-memory")
-  target_link_libraries(binaryen_wasm PRIVATE optimized "--closure=1")
   # TODO: Fix closure warnings! (#5062)
   target_link_libraries(binaryen_wasm PRIVATE optimized "-Wno-error=closure")
   if (BYN_ENABLE_LTO)
@@ -560,8 +560,8 @@ if(EMSCRIPTEN)
   install(TARGETS binaryen_wasm DESTINATION ${CMAKE_INSTALL_BINDIR})
 
   # binaryen.js JavaScript variant
-  add_executable(binaryen_js ${binaryen_SOURCES})
-  target_link_libraries(binaryen_js PRIVATE binaryen)
+  add_executable(binaryen_js src/binaryen-embind.cpp)
+  target_link_libraries(binaryen_js PRIVATE "-Wl,--whole-archive" binaryen)
   target_link_libraries(binaryen_js PRIVATE "-sWASM=0")
   target_link_libraries(binaryen_js PRIVATE "-sWASM_ASYNC_COMPILATION=0")
 
@@ -590,14 +590,12 @@ if(EMSCRIPTEN)
   else()
     target_link_libraries(binaryen_js PRIVATE "-sEXPORT_ES6=1")
   endif()
-  target_link_libraries(binaryen_js PRIVATE "-sEXPORTED_RUNTIME_METHODS=stringToUTF8OnStack,stringToAscii")
-  target_link_libraries(binaryen_js PRIVATE "-sEXPORTED_FUNCTIONS=_malloc,_free")
-  target_link_libraries(binaryen_js PRIVATE "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js")
+  target_link_libraries(binaryen_js PRIVATE "-lembind")
+  target_link_libraries(binaryen_js PRIVATE "--emit-tsd binaryen.d.ts")
   # js_of_ocaml needs a specified variable with special comment to provide the library to consumers
   if(JS_OF_OCAML)
     target_link_libraries(binaryen_js PRIVATE "--extern-pre-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.jsoo-extern-pre.js")
   endif()
-  target_link_libraries(binaryen_js PRIVATE optimized "--closure=1")
   # Currently, js_of_ocaml can only process ES5 code
   if(JS_OF_OCAML)
     target_link_libraries(binaryen_js PRIVATE optimized "--closure-args=\"--language_out=ECMASCRIPT5\"")

src/binaryen-embind.cpp

@@ -0,0 +1,121 @@
+#include "binaryen-c.h"
+#include <emscripten/bind.h>
+
+using namespace emscripten;
+
+namespace {
+
+EMSCRIPTEN_DECLARE_VAL_TYPE(ExpressionList);
+
+EMSCRIPTEN_DECLARE_VAL_TYPE(TypeList);
+
+namespace {
+class ExpressionFactory {
+protected:
+  uintptr_t module;
+
+public:
+  ExpressionFactory(uintptr_t module) : module(module) {}
+};
+} // namespace
+
+class Module {
+public:
+  uintptr_t ptr;
+
+  Module() : Module(reinterpret_cast<uintptr_t>(BinaryenModuleCreate())) {}
+
+  Module(uintptr_t ptr) : ptr(ptr) {}
+
+  uintptr_t
+  block(const std::string& name, ExpressionList children, uintptr_t type) {
+    std::vector<uintptr_t> childrenVec =
+      convertJSArrayToNumberVector<uintptr_t>(children);
+    return reinterpret_cast<uintptr_t>(BinaryenBlock(
+      reinterpret_cast<BinaryenModuleRef>(ptr),
+      name.c_str(),
+      reinterpret_cast<BinaryenExpressionRef*>(childrenVec.begin().base()),
+      childrenVec.size(),
+      type));
+  }
+
+  uintptr_t if_(uintptr_t condition, uintptr_t ifTrue, uintptr_t ifFalse) {
+    return reinterpret_cast<uintptr_t>(
+      BinaryenIf(reinterpret_cast<BinaryenModuleRef>(ptr),
+                 reinterpret_cast<BinaryenExpressionRef>(condition),
+                 reinterpret_cast<BinaryenExpressionRef>(ifTrue),
+                 reinterpret_cast<BinaryenExpressionRef>(ifFalse)));
+  }
+
+  uintptr_t loop(const std::string& label, uintptr_t body) {
+    return reinterpret_cast<uintptr_t>(
+      BinaryenLoop(reinterpret_cast<BinaryenModuleRef>(ptr),
+                   label.c_str(),
+                   reinterpret_cast<BinaryenExpressionRef>(body)));
+  }
+
+  uintptr_t br(const std::string& label, uintptr_t condition, uintptr_t value) {
+    return reinterpret_cast<uintptr_t>(
+      BinaryenBreak(reinterpret_cast<BinaryenModuleRef>(ptr),
+                    label.c_str(),
+                    reinterpret_cast<BinaryenExpressionRef>(condition),
+                    reinterpret_cast<BinaryenExpressionRef>(value)));
+  }
+
+  uintptr_t addFunction(const std::string& name,
+                        BinaryenType params,
+                        BinaryenType results,
+                        TypeList varTypes,
+                        uintptr_t body) {
+    std::vector<uintptr_t> varTypesVec =
+      convertJSArrayToNumberVector<uintptr_t>(varTypes);
+    return reinterpret_cast<uintptr_t>(
+      BinaryenAddFunction(reinterpret_cast<BinaryenModuleRef>(ptr),
+                          name.c_str(),
+                          params,
+                          results,
+                          varTypesVec.begin().base(),
+                          varTypesVec.size(),
+                          reinterpret_cast<BinaryenExpressionRef>(body)));
+  }
+
+  std::string emitText() {
+    char* text = BinaryenModuleAllocateAndWriteText(
+      reinterpret_cast<BinaryenModuleRef>(ptr));
+    std::string str = text;
+    delete text;
+    return str;
+  }
+};
+
+Module* parseText(const std::string& text) {
+  return new Module(
+    reinterpret_cast<uintptr_t>(BinaryenModuleParse(text.c_str())));
+}
+}; // namespace
+
+EMSCRIPTEN_BINDINGS(Binaryen) {
+  constant("none", BinaryenTypeNone());
+  constant("i32", BinaryenTypeInt32());
+  constant("i64", BinaryenTypeInt64());
+
+  class_<Module>("Module")
+    .constructor()
+
+    .function("block", &Module::block)
+    .function("if", &Module::if_)
+    .function("loop", &Module::loop)
+    .function("br", &Module::br)
+    .function("break", &Module::br)
+    .function("br_if", &Module::br)
+
+    .function("addFunction", &Module::addFunction)
+
+    .function("emitText", &Module::emitText);
+
+  function("parseText", parseText, allow_raw_pointer<Module>());
+
+  register_type<ExpressionList>("number[]");
+
+  register_type<TypeList>("number[]");
+}