@grain/binaryen.ml 0.34.0 → 0.35.0

binaryen-archive/src/expression.mli

@@ -350,6 +350,93 @@ module Ref : sig
   (** Module, left, right *)
 end
 
+(** Bindings for `try` instruction. *)
+module Try : sig
+  val make :
+    Module.t -> string option -> t -> (string * t) list -> t option -> t
+  (** Module, name, body, catch clauses, catch all *)
+
+  val get_name : t -> string option
+  (** expr *)
+
+  val set_name : t -> string -> unit
+  (** expr, name *)
+
+  val get_body : t -> t
+  (** expr *)
+
+  val set_body : t -> t -> unit
+  (** expr, bodyExpr *)
+
+  val get_num_catch_tags : t -> int
+  (** expr *)
+
+  val get_num_catch_bodies : t -> int
+  (** expr *)
+
+  val get_catch_tag_at : t -> int -> string
+  (** expr, index *)
+
+  val set_catch_tag_at : t -> int -> string -> unit
+  (** expr, index, catchTag *)
+
+  val append_catch_tag : t -> string -> int
+  (** expr, catchTag *)
+
+  val insert_catch_tag_at : t -> int -> string -> unit
+  (** expr, index, catchTag *)
+
+  val remove_catch_tag_at : t -> int -> string
+  (** expr, index *)
+
+  val get_catch_body_at : t -> int -> t
+  (** expr, index *)
+
+  val set_catch_body_at : t -> int -> t -> unit
+  (** expr, index, catchExpr *)
+
+  val append_catch_body : t -> t -> int
+  (** expr, catchExpr *)
+
+  val insert_catch_body_at : t -> int -> t -> unit
+  (** expr, index, catchExpr *)
+
+  val remove_catch_body_at : t -> int -> t
+  (** expr, index *)
+
+  val has_catch_all : t -> bool
+  (** expr *)
+end
+
+module Throw : sig
+  val make : Module.t -> string -> t list -> t
+  (** Module, tag, operands *)
+
+  val get_tag : t -> string
+  (** expr *)
+
+  val set_tag : t -> string -> unit
+  (** expr, tagName *)
+
+  val get_num_operands : t -> int
+  (** expr *)
+
+  val get_operand_at : t -> int -> t
+  (** expr, index *)
+
+  val set_operand_at : t -> int -> t -> unit
+  (** expr, index, operandExpr *)
+
+  val append_operand : t -> t -> int
+  (** expr, operandExpr *)
+
+  val insert_operand_at : t -> int -> t -> unit
+  (** expr, index, operandExpr *)
+
+  val remove_operand_at : t -> int -> t
+  (** expr, index *)
+end
+
 module Table : sig
   val get : Module.t -> string -> t -> Type.t -> t
   (** Module, name, index, type *)

binaryen-archive/src/import.c

@@ -67,6 +67,24 @@ caml_binaryen_add_global_import__bytecode(value * argv) {
   return caml_binaryen_add_global_import(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
 }
 
+CAMLprim value
+caml_binaryen_add_tag_import(value _module, value _internalName, value _externalModuleName, value _externalBaseName, value _paramsty, value _resultsty) {
+  CAMLparam5(_module, _internalName, _externalModuleName, _externalBaseName, _paramsty);
+  CAMLxparam1(_resultsty);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* internalName = Safe_String_val(_internalName);
+  char* externalModuleName = Safe_String_val(_externalModuleName);
+  char* externalBaseName = Safe_String_val(_externalBaseName);
+  BinaryenType paramsty = BinaryenType_val(_paramsty);
+  BinaryenType resultsty = BinaryenType_val(_resultsty);
+  BinaryenAddTagImport(module, internalName, externalModuleName, externalBaseName, paramsty, resultsty);
+  CAMLreturn(Val_unit);
+}
+CAMLprim value
+caml_binaryen_add_tag_import__bytecode(value * argv) {
+  return caml_binaryen_add_tag_import(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
 CAMLprim value
 caml_binaryen_function_import_get_module(value _fun) {
   CAMLparam1(_fun);
@@ -89,6 +107,13 @@ caml_binaryen_global_import_get_module(value _global) {
   CAMLreturn(caml_copy_string(BinaryenGlobalImportGetModule(global)));
 }
 
+CAMLprim value
+caml_binaryen_tag_import_get_module(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  CAMLreturn(caml_copy_string(BinaryenTagImportGetModule(tag)));
+}
+
 CAMLprim value
 caml_binaryen_function_import_get_base(value _fun) {
   CAMLparam1(_fun);
@@ -110,3 +135,10 @@ caml_binaryen_global_import_get_base(value _global) {
   BinaryenGlobalRef global = BinaryenGlobalRef_val(_global);
   CAMLreturn(caml_copy_string(BinaryenGlobalImportGetBase(global)));
 }
+
+CAMLprim value
+caml_binaryen_tag_import_get_base(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  CAMLreturn(caml_copy_string(BinaryenTagImportGetBase(tag)));
+}

binaryen-archive/src/import.js

@@ -92,6 +92,37 @@ function caml_binaryen_add_global_import__bytecode() {
   );
 }
 
+//Provides: caml_binaryen_add_tag_import
+//Requires: caml_jsstring_of_string
+function caml_binaryen_add_tag_import(
+  wasm_mod,
+  internalName,
+  externalModuleName,
+  externalBaseName,
+  paramsty,
+  resultsty
+) {
+  return wasm_mod.addTagImport(
+    caml_jsstring_of_string(internalName),
+    caml_jsstring_of_string(externalModuleName),
+    caml_jsstring_of_string(externalBaseName),
+    paramsty,
+    resultsty
+  );
+}
+//Provides: caml_binaryen_add_tag_import__bytecode
+//Requires: caml_binaryen_add_tag_import
+function caml_binaryen_add_tag_import__bytecode() {
+  return caml_binaryen_add_tag_import(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
+}
+
 //Provides: caml_binaryen_function_import_get_module
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring
@@ -115,6 +146,14 @@ function caml_binaryen_global_import_get_module(global) {
   return caml_string_of_jsstring(global_info.module);
 }
 
+//Provides: caml_binaryen_tag_import_get_module
+//Requires: Binaryen
+//Requires: caml_string_of_jsstring
+function caml_binaryen_tag_import_get_module(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return caml_string_of_jsstring(tag_info.module);
+}
+
 //Provides: caml_binaryen_function_import_get_base
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring
@@ -137,3 +176,11 @@ function caml_binaryen_global_import_get_base(global) {
   var global_info = Binaryen.getGlobalInfo(global);
   return caml_string_of_jsstring(global_info.base);
 }
+
+//Provides: caml_binaryen_tag_import_get_base
+//Requires: Binaryen
+//Requires: caml_string_of_jsstring
+function caml_binaryen_tag_import_get_base(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return caml_string_of_jsstring(tag_info.base);
+}

binaryen-archive/src/import.ml

@@ -21,6 +21,12 @@ external add_global_import :
 (** Module, internal name, external module name, external base name, type,
     mutable. *)
 
+external add_tag_import :
+  Module.t -> string -> string -> string -> Type.t -> Type.t -> unit
+  = "caml_binaryen_add_tag_import__bytecode" "caml_binaryen_add_tag_import"
+(** Module, internal name, external module name, external base name, params
+    type, results type. *)
+
 external function_import_get_module : Function.t -> string
   = "caml_binaryen_function_import_get_module"
 
@@ -30,6 +36,9 @@ external memory_import_get_module : Module.t -> string -> string
 external global_import_get_module : Global.t -> string
   = "caml_binaryen_global_import_get_module"
 
+external tag_import_get_module : Tag.t -> string
+  = "caml_binaryen_tag_import_get_module"
+
 external function_import_get_base : Function.t -> string
   = "caml_binaryen_function_import_get_base"
 
@@ -38,3 +47,6 @@ external memory_import_get_base : Module.t -> string -> string
 
 external global_import_get_base : Global.t -> string
   = "caml_binaryen_global_import_get_base"
+
+external tag_import_get_base : Tag.t -> string
+  = "caml_binaryen_tag_import_get_base"

binaryen-archive/src/import.mli

@@ -7,9 +7,14 @@ val add_memory_import : Module.t -> string -> string -> string -> bool -> unit
 val add_global_import :
   Module.t -> string -> string -> string -> Type.t -> bool -> unit
 
+val add_tag_import :
+  Module.t -> string -> string -> string -> Type.t -> Type.t -> unit
+
 val function_import_get_module : Function.t -> string
 val memory_import_get_module : Module.t -> string -> string
 val global_import_get_module : Global.t -> string
+val tag_import_get_module : Tag.t -> string
 val function_import_get_base : Function.t -> string
 val memory_import_get_base : Module.t -> string -> string
 val global_import_get_base : Global.t -> string
+val tag_import_get_base : Tag.t -> string

binaryen-archive/src/module.js

@@ -122,11 +122,11 @@ function caml_binaryen_module_get_debug_info_filename(wasm_mod, index) {
 }
 
 //Provides: caml_binaryen_add_custom_section
-//Requires: caml_jsstring_of_string, caml_array_of_string
+//Requires: caml_jsstring_of_string, caml_uint8_array_of_string
 function caml_binaryen_add_custom_section(wasm_mod, name, contents) {
   return wasm_mod.addCustomSection(
     caml_jsstring_of_string(name),
-    caml_array_of_string(contents)
+    caml_uint8_array_of_string(contents)
   );
 }
 

binaryen-archive/src/ocaml_helpers.c

@@ -38,6 +38,14 @@ value alloc_BinaryenGlobalRef(BinaryenGlobalRef exp)
   return v;
 }
 
+/* Allocating an OCaml custom block to hold the given BinaryenTagRef */
+value alloc_BinaryenTagRef(BinaryenTagRef exp)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenTagRef), 0, 1);
+  BinaryenTagRef_val(v) = exp;
+  return v;
+}
+
 /* Allocating an OCaml custom block to hold the given BinaryenExportRef */
 value alloc_BinaryenExportRef(BinaryenExportRef exp)
 {

binaryen-archive/src/ocaml_helpers.h

@@ -29,6 +29,7 @@ static struct custom_operations binaryen_ops = {
 #define BinaryenLiteral_val(v) (*((struct BinaryenLiteral*) Data_custom_val(v)))
 #define BinaryenFunctionRef_val(v) (*((BinaryenFunctionRef*) Data_custom_val(v)))
 #define BinaryenGlobalRef_val(v) (*((BinaryenGlobalRef*) Data_custom_val(v)))
+#define BinaryenTagRef_val(v) (*((BinaryenTagRef*) Data_custom_val(v)))
 #define BinaryenExportRef_val(v) (*((BinaryenExportRef*) Data_custom_val(v)))
 #define BinaryenTableRef_val(v) (*((BinaryenTableRef*) Data_custom_val(v)))
 #define BinaryenElementSegmentRef_val(v) (*((BinaryenElementSegmentRef*) Data_custom_val(v)))
@@ -53,6 +54,9 @@ value alloc_BinaryenType(BinaryenType typ);
 /* Allocating an OCaml custom block to hold the given BinaryenGlobalRef */
 value alloc_BinaryenGlobalRef(BinaryenGlobalRef exp);
 
+/* Allocating an OCaml custom block to hold the given BinaryenTagRef */
+value alloc_BinaryenTagRef(BinaryenTagRef exp);
+
 /* Allocating an OCaml custom block to hold the given BinaryenExportRef */
 value alloc_BinaryenExportRef(BinaryenExportRef exp);
 

binaryen-archive/src/passes.ml

@@ -229,13 +229,6 @@ let minify_imports_and_exports_and_modules =
 (** Split types into minimal recursion groups *)
 let minimize_rec_groups = "minimize-rec-groups"
 
-(** apply the assumption that asyncify imports always unwind, and we never
-    rewind *)
-let mod_asyncify_always_and_only_unwind = "mod-asyncify-always-and-only-unwind"
-
-(** apply the assumption that asyncify never unwinds *)
-let mod_asyncify_never_unwind = "mod-asyncify-never-unwind"
-
 (** creates specialized versions of functions *)
 let monomorphize = "monomorphize"
 
@@ -365,6 +358,9 @@ let reorder_globals = "reorder-globals"
 (** sorts locals by access frequency *)
 let reorder_locals = "reorder-locals"
 
+(** sorts private types by access frequency *)
+let reorder_types = "reorder-types"
+
 (** re-optimize control flow using the relooper algorithm *)
 let rereloop = "rereloop"
 

binaryen-archive/src/passes.mli

@@ -225,13 +225,6 @@ val minify_imports_and_exports_and_modules : t
 val minimize_rec_groups : t
 (** Split types into minimal recursion groups *)
 
-val mod_asyncify_always_and_only_unwind : t
-(** apply the assumption that asyncify imports always unwind, and we never
-    rewind *)
-
-val mod_asyncify_never_unwind : t
-(** apply the assumption that asyncify never unwinds *)
-
 val monomorphize : t
 (** creates specialized versions of functions *)
 
@@ -359,6 +352,9 @@ val reorder_globals : t
 val reorder_locals : t
 (** sorts locals by access frequency *)
 
+val reorder_types: t
+(** sorts private types by access frequency *)
+
 val rereloop : t
 (** re-optimize control flow using the relooper algorithm *)
 

binaryen-archive/src/tag.c

@@ -0,0 +1,61 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+#include <caml/alloc.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+CAMLprim value
+caml_binaryen_add_tag(value _module, value _name, value _params, value _results) {
+  CAMLparam4(_module, _name, _params, _results);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenType params = BinaryenType_val(_params);
+  BinaryenType results = BinaryenType_val(_results);
+  BinaryenTagRef tag = BinaryenAddTag(module, name, params, results);
+  CAMLreturn(alloc_BinaryenTagRef(tag));
+}
+
+CAMLprim value
+caml_binaryen_get_tag(value _module, value _name) {
+  CAMLparam2(_module, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenTagRef tag = BinaryenGetTag(module, name);
+  CAMLreturn(alloc_BinaryenTagRef(tag));
+}
+
+CAMLprim value
+caml_binaryen_remove_tag(value _module, value _name) {
+  CAMLparam2(_module, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenRemoveTag(module, name);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_tag_get_name(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  const char* name = BinaryenTagGetName(tag);
+  CAMLreturn(caml_copy_string(name));
+}
+
+CAMLprim value
+caml_binaryen_tag_get_params(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  BinaryenType ty = BinaryenTagGetParams(tag);
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_tag_get_results(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  BinaryenType ty = BinaryenTagGetResults(tag);
+  CAMLreturn(alloc_BinaryenType(ty));
+}

binaryen-archive/src/tag.js

@@ -0,0 +1,43 @@
+//Provides: caml_binaryen_add_tag
+//Requires: caml_jsstring_of_string
+function caml_binaryen_add_tag(wasm_mod, name, params, results) {
+  return wasm_mod.addTag(
+    caml_jsstring_of_string(name),
+    params,
+    results,
+  );
+}
+
+//Provides: caml_binaryen_get_tag
+//Requires: caml_jsstring_of_string
+function caml_binaryen_get_tag(wasm_mod, name) {
+  return wasm_mod.getTag(caml_jsstring_of_string(name));
+}
+
+//Provides: caml_binaryen_remove_tag
+//Requires: caml_jsstring_of_string
+function caml_binaryen_remove_tag(wasm_mod, name) {
+  return wasm_mod.removeTag(caml_jsstring_of_string(name));
+}
+
+//Provides: caml_binaryen_tag_get_name
+//Requires: Binaryen
+//Requires: caml_string_of_jsstring
+function caml_binaryen_tag_get_name(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return caml_string_of_jsstring(tag_info.name);
+}
+
+//Provides: caml_binaryen_tag_get_params
+//Requires: Binaryen
+function caml_binaryen_tag_get_params(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return tag_info.params;
+}
+
+//Provides: caml_binaryen_tag_get_results
+//Requires: Binaryen
+function caml_binaryen_tag_get_results(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return tag_info.results;
+}

binaryen-archive/src/tag.ml

@@ -0,0 +1,11 @@
+type t
+
+external add_tag : Module.t -> string -> Type.t -> Type.t -> t
+  = "caml_binaryen_add_tag"
+(** Module, name, params, result *)
+
+external get_tag : Module.t -> string -> t = "caml_binaryen_get_tag"
+external remove_tag : Module.t -> string -> unit = "caml_binaryen_remove_tag"
+external get_name : t -> string = "caml_binaryen_tag_get_name"
+external get_params : t -> Type.t = "caml_binaryen_tag_get_params"
+external get_results : t -> Type.t = "caml_binaryen_tag_get_results"

binaryen-archive/src/tag.mli

@@ -0,0 +1,8 @@
+type t
+
+val add_tag : Module.t -> string -> Type.t -> Type.t -> t
+val get_tag : Module.t -> string -> t
+val remove_tag : Module.t -> string -> unit
+val get_name : t -> string
+val get_params : t -> Type.t
+val get_results : t -> Type.t

binaryen-archive/src/type.js

@@ -67,7 +67,7 @@ function caml_binaryen_type_structref() {
 //Provides: caml_binaryen_type_arrayref
 //Requires: Binaryen
 function caml_binaryen_type_arrayref() {
-  // TODO: Binaryen v111 didn't expose this directly
+  // TODO: Binaryen v125 doesn't expose this directly
   return Binaryen._BinaryenTypeArrayref();
 }
 
@@ -80,22 +80,19 @@ function caml_binaryen_type_stringref() {
 //Provides: caml_binaryen_type_nullref
 //Requires: Binaryen
 function caml_binaryen_type_nullref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeNullref();
+  return Binaryen.nullref;
 }
 
 //Provides: caml_binaryen_type_null_externref
 //Requires: Binaryen
 function caml_binaryen_type_null_externref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeNullExternref();
+  return Binaryen.nullexternref;
 }
 
 //Provides: caml_binaryen_type_null_funcref
 //Requires: Binaryen
 function caml_binaryen_type_null_funcref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeNullFuncref();
+  return Binaryen.nullfuncref;
 }
 
 //Provides: caml_binaryen_type_unreachable