@grain/binaryen.ml 0.9.0 → 0.11.1

binaryen-archive/src/binaryen_stubs_settings.c

@@ -0,0 +1,145 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/alloc.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+CAMLprim value
+caml_binaryen_get_optimize_level(value unit) {
+  CAMLparam1(unit);
+  int res = BinaryenGetOptimizeLevel();
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value
+caml_binaryen_set_optimize_level(value _level) {
+  CAMLparam1(_level);
+  int level = Int_val(_level);
+  BinaryenSetOptimizeLevel(level);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_shrink_level(value unit) {
+  CAMLparam1(unit);
+  int res = BinaryenGetShrinkLevel();
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value
+caml_binaryen_set_shrink_level(value _level) {
+  CAMLparam1(_level);
+  int level = Int_val(_level);
+  BinaryenSetShrinkLevel(level);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_debug_info(value unit) {
+  CAMLparam1(unit);
+  bool res = BinaryenGetDebugInfo();
+  CAMLreturn(Val_bool(res));
+}
+
+CAMLprim value
+caml_binaryen_set_debug_info(value _on) {
+  CAMLparam1(_on);
+  bool on = Bool_val(_on);
+  BinaryenSetDebugInfo(on);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_low_memory_unused(value unit) {
+  CAMLparam1(unit);
+  bool res = BinaryenGetLowMemoryUnused();
+  CAMLreturn(Val_bool(res));
+}
+
+CAMLprim value
+caml_binaryen_set_low_memory_unused(value _on) {
+  CAMLparam1(_on);
+  bool on = Bool_val(_on);
+  BinaryenSetLowMemoryUnused(on);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_pass_argument(value _name) {
+  CAMLparam1(_name);
+  const char* name = Safe_String_val(_name);
+  const char* val = BinaryenGetPassArgument(name);
+  CAMLreturn(caml_copy_string(val));
+}
+
+CAMLprim value
+caml_binaryen_set_pass_argument(value _name, value _val) {
+  CAMLparam2(_name, _val);
+  const char* name = Safe_String_val(_name);
+  const char* val = Safe_String_val(_val);
+  BinaryenSetPassArgument(name, val);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_always_inline_max_size(value unit) {
+  CAMLparam1(unit);
+  int res = BinaryenGetAlwaysInlineMaxSize();
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value
+caml_binaryen_set_always_inline_max_size(value _size) {
+  CAMLparam1(_size);
+  int size = Int_val(_size);
+  BinaryenSetAlwaysInlineMaxSize(size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_flexible_inline_max_size(value unit) {
+  CAMLparam1(unit);
+  int res = BinaryenGetFlexibleInlineMaxSize();
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value
+caml_binaryen_set_flexible_inline_max_size(value _size) {
+  CAMLparam1(_size);
+  int size = Int_val(_size);
+  BinaryenSetFlexibleInlineMaxSize(size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_one_caller_inline_max_size(value unit) {
+  CAMLparam1(unit);
+  int res = BinaryenGetOneCallerInlineMaxSize();
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value
+caml_binaryen_set_one_caller_inline_max_size(value _size) {
+  CAMLparam1(_size);
+  int size = Int_val(_size);
+  BinaryenSetOneCallerInlineMaxSize(size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_set_colors_enabled(value _on) {
+  CAMLparam1(_on);
+  bool on = Bool_val(_on);
+  BinaryenSetColorsEnabled(on);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_are_colors_enabled(value unit) {
+  CAMLparam1(unit);
+  bool res = BinaryenAreColorsEnabled();
+  CAMLreturn(Val_bool(res));
+}

binaryen-archive/src/binaryen_stubs_tables.c

@@ -2,19 +2,52 @@
 #include <caml/mlvalues.h>
 #include <caml/fail.h>
 #include <caml/memory.h>
+#include <caml/alloc.h>
 
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
 
+/* Allocating an OCaml custom block to hold the given BinaryenTableRef */
+static value alloc_BinaryenTableRef(BinaryenTableRef table)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenTableRef), 0, 1);
+  BinaryenTableRef_val(v) = table;
+  return v;
+}
+
+/* Allocating an OCaml custom block to hold the given BinaryenElementSegmentRef */
+static value alloc_BinaryenElementSegmentRef(BinaryenElementSegmentRef elem)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenElementSegmentRef), 0, 1);
+  BinaryenElementSegmentRef_val(v) = elem;
+  return v;
+}
+
+/* Allocating an OCaml custom block to hold the given BinaryenExpressionRef */
+static value alloc_BinaryenExpressionRef(BinaryenExpressionRef exp)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenExpressionRef), 0, 1);
+  BinaryenExpressionRef_val(v) = exp;
+  return v;
+}
+
 CAMLprim value
-caml_binaryen_add_table(value _module, value _name, value _initial, value _maximum, value _funcnames, value _offset) {
-  CAMLparam5(_module, _name, _initial, _maximum, _funcnames);
-  CAMLxparam1(_offset);
+caml_binaryen_add_table(value _module, value _table, value _initial, value _maximum) {
+  CAMLparam4(_module, _table, _initial, _maximum);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  char* name = Safe_String_val(_name);
+  char* table = Safe_String_val(_table);
   BinaryenIndex initial = Int_val(_initial);
   BinaryenIndex maximum = Int_val(_maximum);
+  CAMLreturn(alloc_BinaryenTableRef(BinaryenAddTable(module, table, initial, maximum)));
+}
+
+CAMLprim value
+caml_binaryen_add_active_element_segment(value _module, value _table, value _name, value _funcnames, value _offset) {
+  CAMLparam5(_module, _table, _name, _funcnames, _offset);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* table = Safe_String_val(_table);
+  char* name = Safe_String_val(_name);
   _funcnames = array_of_list(_funcnames);
   int funcnamesLen = array_length(_funcnames);
   const char* funcnames[funcnamesLen];
@@ -22,10 +55,91 @@ caml_binaryen_add_table(value _module, value _name, value _initial, value _maxim
     funcnames[i] = Safe_String_val(Field(_funcnames, i));
   }
   BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
-  BinaryenAddTable(module, name, initial, maximum, funcnames, funcnamesLen, offset);
+  CAMLreturn(alloc_BinaryenElementSegmentRef(BinaryenAddActiveElementSegment(module, table, name, funcnames, funcnamesLen, offset)));
+}
+
+CAMLprim value
+caml_binaryen_remove_element_segment(value _module, value _name) {
+  CAMLparam2(_module, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenRemoveElementSegment(module, name);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_get_num_element_segments(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(Val_int(BinaryenGetNumElementSegments(module)));
+}
+
+CAMLprim value
+caml_binaryen_get_element_segment(value _module, value _name) {
+  CAMLparam2(_module, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  CAMLreturn(alloc_BinaryenElementSegmentRef(BinaryenGetElementSegment(module, name)));
+}
+
+CAMLprim value
+caml_binaryen_get_element_segment_by_index(value _module, value _index) {
+  CAMLparam2(_module, _index);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(alloc_BinaryenElementSegmentRef(BinaryenGetElementSegmentByIndex(module, index)));
+}
+
+CAMLprim value
+caml_binaryen_element_segment_get_name(value _elem) {
+  CAMLparam1(_elem);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  CAMLreturn(caml_copy_string(BinaryenElementSegmentGetName(elem)));
+}
+
+CAMLprim value
+caml_binaryen_element_segment_set_name(value _elem, value _name) {
+  CAMLparam2(_elem, _name);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  char* name = Safe_String_val(_name);
+  BinaryenElementSegmentSetName(elem, name);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_element_segment_get_table(value _elem) {
+  CAMLparam1(_elem);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  CAMLreturn(caml_copy_string(BinaryenElementSegmentGetTable(elem)));
+}
+
+CAMLprim value
+caml_binaryen_element_segment_set_table(value _elem, value _table) {
+  CAMLparam2(_elem, _table);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  char* table = Safe_String_val(_table);
+  BinaryenElementSegmentSetTable(elem, table);
   CAMLreturn(Val_unit);
 }
+
+CAMLprim value
+caml_binaryen_element_segment_get_offset(value _elem) {
+  CAMLparam1(_elem);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  CAMLreturn(alloc_BinaryenExpressionRef(BinaryenElementSegmentGetOffset(elem)));
+}
+
+CAMLprim value
+caml_binaryen_element_segment_get_length(value _elem) {
+  CAMLparam1(_elem);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  CAMLreturn(Val_int(BinaryenElementSegmentGetLength(elem)));
+}
+
 CAMLprim value
-caml_binaryen_add_table__bytecode(value * argv) {
-  return caml_binaryen_add_table(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+caml_binaryen_element_segment_get_data(value _elem, value _index) {
+  CAMLparam2(_elem, _index);
+  BinaryenElementSegmentRef elem = BinaryenElementSegmentRef_val(_elem);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(caml_copy_string(BinaryenElementSegmentGetData(elem, index)));
 }

binaryen-archive/src/binaryen_stubs_types.c

@@ -97,3 +97,21 @@ caml_binaryen_type_create(value tys) {
   BinaryenType newType = BinaryenTypeCreate(valueTypes, len);
   CAMLreturn(alloc_BinaryenType(newType));
 }
+
+CAMLprim value
+caml_binaryen_type_expand(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenType ty = BinaryenType_val(_ty);
+  int arity = BinaryenTypeArity(ty);
+  BinaryenType* buf = malloc(sizeof(BinaryenType) * arity);
+  BinaryenTypeExpand(ty, buf);
+
+  value typeArray = caml_alloc(arity, 0);
+  for (int i = 0; i < arity; i++) {
+    Field(typeArray, i) = alloc_BinaryenType(buf[i]);
+  }
+
+  free(buf);
+
+  CAMLreturn(typeArray);
+}

binaryen-archive/src/dune

@@ -2,52 +2,13 @@
  (name binaryen_native)
  (public_name binaryen.native)
  (implements binaryen)
+ (libraries libbinaryen.c)
  (foreign_stubs
   (language c)
   (names binaryen_stubs_types binaryen_stubs_ops binaryen_stubs_literals
     binaryen_stubs_expressions binaryen_stubs_functions
     binaryen_stubs_imports binaryen_stubs_exports binaryen_stubs_globals
-    binaryen_stubs_function_tables binaryen_stubs_tables
-    binaryen_stubs_memory binaryen_stubs_features binaryen_stubs_modules
-    ocaml_helpers)
-  (flags -O2 -Wall -Wextra))
- (foreign_archives binaryen)
- (library_flags
-  (:include ./config/library_flags.sexp))
- (c_library_flags -lstdc++ -lpthread))
-
-(rule
- (target binaryen-c.h)
- (action
-  (copy ../vendor/binaryen-c.h binaryen-c.h)))
-
-(rule
- (target wasm-delegations.h)
- (action
-  (copy ../vendor/wasm-delegations.h wasm-delegations.h)))
-
-(rule
- (target libbinaryen.a)
- (action
-  (copy ../vendor/%{system}/libbinaryen.a libbinaryen.a)))
-
-(rule
- (target dllbinaryen.so)
- (enabled_if
-  (= %{system} macosx))
- (action
-  (copy ../vendor/%{system}/libbinaryen.dylib dllbinaryen.so)))
-
-(rule
- (target dllbinaryen.so)
- (enabled_if
-  (= %{system} linux))
- (action
-  (copy ../vendor/%{system}/libbinaryen.so dllbinaryen.so)))
-
-(rule
- (target dllbinaryen.dll)
- (enabled_if
-  (= %{system} mingw64))
- (action
-  (copy ../vendor/%{system}/libbinaryen.dll dllbinaryen.dll)))
+    binaryen_stubs_tables binaryen_stubs_memory binaryen_stubs_features
+    binaryen_stubs_modules binaryen_stubs_settings ocaml_helpers)
+  (flags :standard -O2 -Wall -Wextra))
+ (c_library_flags :standard -lstdc++ -lpthread))

binaryen-archive/src/element_segment.ml

@@ -0,0 +1,13 @@
+type t
+
+external get_name : t -> string = "caml_binaryen_element_segment_get_name"
+
+external get_table : t -> string = "caml_binaryen_element_segment_get_table"
+
+external get_offset : t -> Expression.t
+  = "caml_binaryen_element_segment_get_offset"
+
+external get_length : t -> int = "caml_binaryen_element_segment_get_length"
+
+external get_data : t -> int -> string
+  = "caml_binaryen_element_segment_get_data"

binaryen-archive/src/export.ml

@@ -16,6 +16,39 @@ external add_global_export : Module.t -> string -> string -> t
   = "caml_binaryen_add_global_export"
 (** Module, internal name, external name. *)
 
+external get_export : Module.t -> string -> t = "caml_binaryen_get_export"
+
 external remove_export : Module.t -> string -> unit
   = "caml_binaryen_remove_export"
 (** Module, external name. *)
+
+external get_num_exports : Module.t -> int = "caml_binaryen_get_num_exports"
+
+external get_export_by_index : Module.t -> int -> t
+  = "caml_binaryen_get_export_by_index"
+
+external get_name : t -> string = "caml_binaryen_export_get_name"
+
+external get_value : t -> string = "caml_binaryen_export_get_value"
+
+external external_function : unit -> int = "caml_binaryen_external_function"
+
+let external_function = external_function ()
+
+external external_table : unit -> int = "caml_binaryen_external_table"
+
+let external_table = external_table ()
+
+external external_memory : unit -> int = "caml_binaryen_external_memory"
+
+let external_memory = external_memory ()
+
+external external_global : unit -> int = "caml_binaryen_external_global"
+
+let external_global = external_global ()
+
+external external_event : unit -> int = "caml_binaryen_external_event"
+
+let external_event = external_event ()
+
+external export_get_kind : t -> int = "caml_binaryen_export_get_kind"