@grain/binaryen.ml 0.34.0 → 0.36.0

binaryen-archive/src/expression.js

@@ -101,6 +101,28 @@ function caml_binaryen_call_indirect__bytecode() {
   );
 }
 
+//Provides: caml_binaryen_call_ref
+//Requires: caml_jsstring_of_string
+//Requires: caml_list_to_js_array
+function caml_binaryen_call_ref(wasm_mod, target, params, typ) {
+  return wasm_mod.call_ref(
+    target,
+    caml_list_to_js_array(params),
+    typ
+  ); 
+}
+
+//Provides: caml_binaryen_return_call_ref
+//Requires: caml_jsstring_of_string
+//Requires: caml_list_to_js_array
+function caml_binaryen_return_call_ref(wasm_mod, target, params, typ) {
+  return wasm_mod.return_call_ref(
+    target,
+    caml_list_to_js_array(params),
+    typ
+  );
+}
+
 //Provides: caml_binaryen_return_call
 //Requires: caml_jsstring_of_string
 //Requires: caml_list_to_js_array
@@ -547,6 +569,32 @@ function caml_binaryen_ref_i31(wasm_mod, typ) {
   return wasm_mod.ref.i31(typ);
 }
 
+//Provides: caml_binaryen_ref_test
+function caml_binaryen_ref_test(wasm_mod, ref, typ) {
+  return wasm_mod.ref.test(ref, typ);
+}
+
+//Provides: caml_binaryen_ref_cast
+function caml_binaryen_ref_cast(wasm_mod, ref, typ) {
+  return wasm_mod.ref.cast(ref, typ);
+}
+
+//Provides: caml_binaryen_br_on
+//Requires: caml_jsstring_of_string
+//Requires: Binaryen
+function caml_binaryen_br_on(wasm_mod, op, name, ref, typ) {
+  switch (op) {
+    case Binaryen.BrOnNull:
+      return wasm_mod.br_on_null(caml_jsstring_of_string(name), ref);
+    case Binaryen.BrOnNonNull:
+      return wasm_mod.br_on_non_null(caml_jsstring_of_string(name), ref);
+    case Binaryen.BrOnCast:
+      return wasm_mod.br_on_cast(caml_jsstring_of_string(name), ref, typ);
+    case Binaryen.BrOnCastFail:
+      return wasm_mod.br_on_cast_fail(caml_jsstring_of_string(name), ref, typ);
+  }
+}
+
 //Provides: caml_binaryen_i31_get
 function caml_binaryen_i31_get(wasm_mod, typ, signed) {
   if (signed) {
@@ -882,14 +930,10 @@ function caml_binaryen_expression_id_array_len() {
 
 //Provides: caml_binaryen_expression_print
 //Requires: Binaryen
-//Requires: caml_sys_fds
-//Requires: caml_string_of_jsstring
-//Requires: caml_ml_output, caml_ml_string_length
+//Requires: caml_ml_output_str_stdout
 function caml_binaryen_expression_print(expr) {
   var text = Binaryen.emitText(expr);
-  var chanid = caml_sys_fds[1].chanid; // stdout
-  var s = caml_string_of_jsstring(text);
-  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+  caml_ml_output_str_stdout(text);
 }
 
 //Provides: caml_binaryen_expression_finalize
@@ -1296,6 +1340,68 @@ function caml_binaryen_call_indirect_set_return(exp, isReturn) {
   return Binaryen.CallIndirect.setReturn(exp, caml_js_from_bool(isReturn));
 }
 
+//Provides: caml_binaryen_call_ref_get_target
+//Requires: Binaryen
+function caml_binaryen_call_ref_get_target(exp) {
+  return Binaryen.CallRef.getTarget(exp);
+}
+
+//Provides: caml_binaryen_call_ref_set_target
+//Requires: Binaryen
+function caml_binaryen_call_ref_set_target(exp, target) {
+  return Binaryen.CallRef.setTarget(exp, target);
+}
+
+//Provides: caml_binaryen_call_ref_get_num_operands
+//Requires: Binaryen
+function caml_binaryen_call_ref_get_num_operands(exp) {
+  return Binaryen.CallRef.getNumOperands(exp);
+}
+
+//Provides: caml_binaryen_call_ref_get_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_get_operand_at(exp, index) {
+  return Binaryen.CallRef.getOperandAt(exp, index);
+}
+
+//Provides: caml_binaryen_call_ref_set_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_set_operand_at(exp, index, operand) {
+  return Binaryen.CallRef.setOperandAt(exp, index, operand);
+}
+
+//Provides: caml_binaryen_call_ref_append_operand
+//Requires: Binaryen
+function caml_binaryen_call_ref_append_operand(exp, operand) {
+  return Binaryen.CallRef.appendOperand(exp, operand);
+}
+
+//Provides: caml_binaryen_call_ref_insert_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_insert_operand_at(exp, index, operand) {
+  return Binaryen.CallRef.insertOperandAt(exp, index, operand);
+}
+
+//Provides: caml_binaryen_call_ref_remove_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_remove_operand_at(exp, index) {
+  return Binaryen.CallRef.removeOperandAt(exp, index);
+}
+
+//Provides: caml_binaryen_call_ref_is_return
+//Requires: Binaryen
+//Requires: caml_js_to_bool
+function caml_binaryen_call_ref_is_return(exp) {
+  return caml_js_to_bool(Binaryen.CallRef.isReturn(exp));
+}
+
+//Provides: caml_binaryen_call_ref_set_return
+//Requires: Binaryen
+//Requires: caml_js_from_bool
+function caml_binaryen_call_ref_set_return(exp, isReturn) {
+  return Binaryen.CallRef.setReturn(exp, caml_js_from_bool(isReturn));
+}
+
 //Provides: caml_binaryen_local_set_get_value
 //Requires: Binaryen
 function caml_binaryen_local_set_get_value(exp) {
@@ -1704,7 +1810,317 @@ function caml_binaryen_ref_func(wasm_mod, name, typ) {
 
 //Provides: caml_binaryen_ref_eq
 function caml_binaryen_ref_eq(wasm_mod, left, right) {
-  return wasm_mod.ref.func(left, right);
+  return wasm_mod.ref.eq(left, right);
+}
+
+// Struct operations
+
+//Provides: caml_binaryen_struct_new
+//Requires: caml_list_to_js_array
+function caml_binaryen_struct_new(wasm_mod, operands, type) {
+  return wasm_mod.struct.new(
+    operands ? caml_list_to_js_array(operands[1]) : null,
+    type
+  );
+}
+
+//Provides: caml_binaryen_struct_get
+//Requires: caml_js_from_bool
+function caml_binaryen_struct_get(wasm_mod, index, ref, type, signed) {
+  return wasm_mod.struct.get(index, ref, type, caml_js_from_bool(signed));
+}
+
+//Provides: caml_binaryen_struct_set
+function caml_binaryen_struct_set(wasm_mod, index, ref, value) {
+  return wasm_mod.struct.set(index, ref, value);
+}
+
+// Array operations
+
+//Provides: caml_binaryen_array_new
+function caml_binaryen_array_new(wasm_mod, type, size, init) {
+  return wasm_mod.array.new(type, size, init);
+}
+
+//Provides: caml_binaryen_array_new_data
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_new_data(wasm_mod, type, name, offset, size) {
+  return wasm_mod.array.new_data(
+    type,
+    caml_jsstring_of_string(name),
+    offset,
+    size
+  );
+}
+
+//Provides: caml_binaryen_array_new_elem
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_new_elem(wasm_mod, type, name, offset, size) {
+  return wasm_mod.array.new_elem(
+    type,
+    caml_jsstring_of_string(name),
+    offset,
+    size
+  );
+}
+
+//Provides: caml_binaryen_array_new_fixed
+//Requires: caml_list_to_js_array
+function caml_binaryen_array_new_fixed(wasm_mod, type, values) {
+  return wasm_mod.array.new_fixed(type, caml_list_to_js_array(values));
+}
+
+//Provides: caml_binaryen_array_get
+//Requires: caml_js_from_bool
+function caml_binaryen_array_get(wasm_mod, ref, index, type, signed) {
+  return wasm_mod.array.get(ref, index, type, caml_js_from_bool(signed));
+}
+
+//Provides: caml_binaryen_array_set
+function caml_binaryen_array_set(wasm_mod, ref, index, value) {
+  return wasm_mod.array.set(ref, index, value);
+}
+
+//Provides: caml_binaryen_array_len
+function caml_binaryen_array_len(wasm_mod, ref) {
+  return wasm_mod.array.len(ref);
+}
+
+//Provides: caml_binaryen_array_fill
+function caml_binaryen_array_fill(wasm_mod, ref, index, value, size) {
+  return wasm_mod.array.fill(ref, index, value, size);
+}
+
+//Provides: caml_binaryen_array_copy
+function caml_binaryen_array_copy(
+  wasm_mod,
+  destRef,
+  destIndex,
+  srcRef,
+  srcIndex,
+  length
+) {
+  return wasm_mod.array.copy(destRef, destIndex, srcRef, srcIndex, length);
+}
+
+//Provides: caml_binaryen_array_init_data
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_init_data(wasm_mod, name, ref, index, offset, size) {
+  return wasm_mod.array.init_data(caml_jsstring_of_string(name), ref, index, offset, size);
+}
+
+//Provides: caml_binaryen_array_init_data__bytecode
+//Requires: caml_binaryen_array_init_data
+function caml_binaryen_array_init_data__bytecode() {
+  return caml_binaryen_array_init_data(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
+}
+
+//Provides: caml_binaryen_array_init_elem
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_init_elem(wasm_mod, name, ref, index, offset, size) {
+  return wasm_mod.array.init_elem(caml_jsstring_of_string(name), ref, index, offset, size);
+}
+
+//Provides: caml_binaryen_array_copy__bytecode
+//Requires: caml_binaryen_array_copy
+function caml_binaryen_array_copy__bytecode() {
+  return caml_binaryen_array_copy(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
+}
+
+// Exception handling operations
+
+//Provides: caml_binaryen_try
+//Requires: caml_jsstring_of_string, caml_list_to_js_array
+function caml_binaryen_try(wasm_mod, name, body, catch_tags, catch_bodies, delegate_target) {
+  return wasm_mod.try(
+    name ? caml_jsstring_of_string(name[1]) : null,
+    body,
+    caml_list_to_js_array(catch_tags).map(caml_jsstring_of_string),
+    caml_list_to_js_array(catch_bodies),
+    delegate_target ? caml_jsstring_of_string(delegate_target[1]) : null,
+  );
+}
+
+//Provides: caml_binaryen_try__bytecode
+//Requires: caml_binaryen_try
+function caml_binaryen_try__bytecode() {
+  return caml_binaryen_try(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
+}
+
+//Provides: caml_binaryen_throw
+//Requires: caml_jsstring_of_string, caml_list_to_js_array
+function caml_binaryen_throw(wasm_mod, tag, operands) {
+  return wasm_mod.throw(
+    caml_jsstring_of_string(tag),
+    caml_list_to_js_array(operands),
+  );
+}
+
+//Provides: caml_binaryen_try_get_name
+//Requires: Binaryen, caml_string_of_jsstring, to_option
+function caml_binaryen_try_get_name(expr) {
+  var name = Binaryen.Try.getName(expr);
+  var str = name != null ? caml_string_of_jsstring(name) : null;
+  return to_option(str);
+}
+
+//Provides: caml_binaryen_try_set_name
+//Requires: Binaryen, caml_jsstring_of_string
+function caml_binaryen_try_set_name(expr, name) {
+  Binaryen.Try.setName(expr, caml_jsstring_of_string(name));
+}
+
+//Provides: caml_binaryen_try_get_body
+//Requires: Binaryen
+function caml_binaryen_try_get_body(expr) {
+  return Binaryen.Try.getBody(expr);
+}
+
+//Provides: caml_binaryen_try_set_body
+//Requires: Binaryen
+function caml_binaryen_try_set_body(expr, bodyExpr) {
+  Binaryen.Try.setBody(expr, bodyExpr);
+}
+
+//Provides: caml_binaryen_try_get_num_catch_tags
+//Requires: Binaryen
+function caml_binaryen_try_get_num_catch_tags(expr) {
+  return Binaryen.Try.getNumCatchTags(expr);
+}
+
+//Provides: caml_binaryen_try_get_num_catch_bodies
+//Requires: Binaryen
+function caml_binaryen_try_get_num_catch_bodies(expr) {
+  return Binaryen.Try.getNumCatchBodies(expr);
+}
+
+//Provides: caml_binaryen_try_get_catch_tag_at
+//Requires: Binaryen, caml_string_of_jsstring
+function caml_binaryen_try_get_catch_tag_at(expr, index) {
+  return caml_string_of_jsstring(Binaryen.Try.getCatchTagAt(expr, index));
+}
+
+//Provides: caml_binaryen_try_set_catch_tag_at
+//Requires: Binaryen, caml_jsstring_of_string
+function caml_binaryen_try_set_catch_tag_at(expr, index, catchTag) {
+  Binaryen.Try.setCatchTagAt(expr, index, caml_jsstring_of_string(catchTag));
+}
+
+//Provides: caml_binaryen_try_append_catch_tag
+//Requires: Binaryen, caml_jsstring_of_string
+function caml_binaryen_try_append_catch_tag(expr, catchTag) {
+  return Binaryen.Try.appendCatchTag(expr, caml_jsstring_of_string(catchTag));
+}
+
+//Provides: caml_binaryen_try_insert_catch_tag_at
+//Requires: Binaryen, caml_jsstring_of_string
+function caml_binaryen_try_insert_catch_tag_at(expr, index, catchTag) {
+  Binaryen.Try.insertCatchTagAt(expr, index, caml_jsstring_of_string(catchTag));
+}
+
+//Provides: caml_binaryen_try_remove_catch_tag_at
+//Requires: Binaryen, caml_string_of_jsstring
+function caml_binaryen_try_remove_catch_tag_at(expr, index) {
+  return caml_string_of_jsstring(Binaryen.Try.removeCatchTagAt(expr, index));
+}
+
+//Provides: caml_binaryen_try_get_catch_body_at
+//Requires: Binaryen
+function caml_binaryen_try_get_catch_body_at(expr, index) {
+  return Binaryen.Try.getCatchBodyAt(expr, index);
+}
+
+//Provides: caml_binaryen_try_set_catch_body_at
+//Requires: Binaryen
+function caml_binaryen_try_set_catch_body_at(expr, index, catchExpr) {
+  Binaryen.Try.setCatchBodyAt(expr, index, catchExpr);
+}
+
+//Provides: caml_binaryen_try_append_catch_body
+//Requires: Binaryen
+function caml_binaryen_try_append_catch_body(expr, catchExpr) {
+  return Binaryen.Try.appendCatchBody(expr, catchExpr);
+}
+
+//Provides: caml_binaryen_try_insert_catch_body_at
+//Requires: Binaryen
+function caml_binaryen_try_insert_catch_body_at(expr, index, catchExpr) {
+  Binaryen.Try.insertCatchBodyAt(expr, index, catchExpr);
+}
+
+//Provides: caml_binaryen_try_remove_catch_body_at
+//Requires: Binaryen
+function caml_binaryen_try_remove_catch_body_at(expr, index) {
+  return Binaryen.Try.removeCatchBodyAt(expr, index);
+}
+
+//Provides: caml_binaryen_try_has_catch_all
+//Requires: Binaryen
+//Requires: caml_js_to_bool
+function caml_binaryen_try_has_catch_all(expr) {
+  return caml_js_to_bool(Binaryen.Try.hasCatchAll(expr));
+}
+
+//Provides: caml_binaryen_throw_get_tag
+//Requires: Binaryen, caml_string_of_jsstring
+function caml_binaryen_throw_get_tag(expr) {
+  return caml_string_of_jsstring(Binaryen.Throw.getTag(expr));
+}
+
+//Provides: caml_binaryen_throw_set_tag
+//Requires: Binaryen, caml_jsstring_of_string
+function caml_binaryen_throw_set_tag(expr, tagName) {
+  Binaryen.Throw.setTag(expr, caml_jsstring_of_string(tagName));
+}
+
+//Provides: caml_binaryen_throw_get_num_operands
+//Requires: Binaryen
+function caml_binaryen_throw_get_num_operands(expr) {
+  return Binaryen.Throw.getNumOperands(expr);
+}
+
+//Provides: caml_binaryen_throw_get_operand_at
+//Requires: Binaryen
+function caml_binaryen_throw_get_operand_at(expr, index) {
+  return Binaryen.Throw.getOperandAt(expr, index);
+}
+
+//Provides: caml_binaryen_throw_set_operand_at
+//Requires: Binaryen
+function caml_binaryen_throw_set_operand_at(expr, index, operandExpr) {
+  Binaryen.Throw.setOperandAt(expr, index, operandExpr);
+}
+
+//Provides: caml_binaryen_throw_append_operand
+//Requires: Binaryen
+function caml_binaryen_throw_append_operand(expr, operandExpr) {
+  return Binaryen.Throw.appendOperand(expr, operandExpr);
+}
+
+//Provides: caml_binaryen_throw_insert_operand_at
+//Requires: Binaryen
+function caml_binaryen_throw_insert_operand_at(expr, index, operandExpr) {
+  Binaryen.Throw.insertOperandAt(expr, index, operandExpr);
+}
+
+//Provides: caml_binaryen_throw_remove_operand_at
+//Requires: Binaryen
+function caml_binaryen_throw_remove_operand_at(expr, index) {
+  return Binaryen.Throw.removeOperandAt(expr, index);
 }
 
 // Table operations

binaryen-archive/src/expression.ml

@@ -583,6 +583,44 @@ module Call_indirect = struct
     = "caml_binaryen_call_indirect_set_return"
 end
 
+module Call_ref = struct
+  external make : Module.t -> t -> t list -> Type.t -> t
+    = "caml_binaryen_call_ref"
+
+  (** Module, function value, params, type. *)
+  let make mod_ target params typ = make mod_ target params typ
+
+  external make_return : Module.t -> t -> t list -> Type.t -> t
+    = "caml_binaryen_return_call_ref"
+
+  (** Module, function value, params, type. *)
+  let make_return mod_ target params typ = make_return mod_ target params typ
+
+  external get_target : t -> t = "caml_binaryen_call_ref_get_target"
+  external set_target : t -> t -> unit = "caml_binaryen_call_ref_set_target"
+
+  external get_num_operands : t -> int
+    = "caml_binaryen_call_ref_get_num_operands"
+
+  external get_operand_at : t -> int -> t
+    = "caml_binaryen_call_ref_get_operand_at"
+
+  external set_operand_at : t -> int -> t -> unit
+    = "caml_binaryen_call_ref_set_operand_at"
+
+  external append_operand : t -> t -> int
+    = "caml_binaryen_call_ref_append_operand"
+
+  external insert_operand_at : t -> int -> t -> unit
+    = "caml_binaryen_call_ref_insert_operand_at"
+
+  external remove_operand_at : t -> int -> t
+    = "caml_binaryen_call_ref_remove_operand_at"
+
+  external is_return : t -> bool = "caml_binaryen_call_ref_is_return"
+  external set_return : t -> bool -> unit = "caml_binaryen_call_ref_set_return"
+end
+
 module Local_get = struct
   external make : Module.t -> int -> Type.t -> t = "caml_binaryen_local_get"
   (** Module, slot, type. *)
@@ -830,6 +868,192 @@ module Ref = struct
 
   external eq : Module.t -> t -> t -> t = "caml_binaryen_ref_eq"
   (** Module, left, right *)
+
+  external test : Module.t -> t -> Type.t -> t = "caml_binaryen_ref_test"
+  (** Module, value, type *)
+
+  external cast : Module.t -> t -> Type.t -> t = "caml_binaryen_ref_cast"
+  (** Module, value, type *)
+end
+
+module BrOn = struct
+  external make : Module.t -> Op.t -> string -> t -> Type.t -> t
+    = "caml_binaryen_br_on"
+  (** Module, op, label, value, type *)
+end
+
+module Struct = struct
+  external new_ : Module.t -> t list option -> Heap_type.t -> t
+    = "caml_binaryen_struct_new"
+  (** Mdoule, operands, type *)
+
+  external get : Module.t -> int -> t -> Type.t -> bool -> t
+    = "caml_binaryen_struct_get"
+  (** Module, index, struct, type, signed *)
+
+  external set : Module.t -> int -> t -> t -> t = "caml_binaryen_struct_set"
+  (** Module, index, struct, value *)
+end
+
+module Array = struct
+  external new_ : Module.t -> Heap_type.t -> t -> t -> t
+    = "caml_binaryen_array_new"
+  (** Module, type, size, init *)
+
+  external new_data : Module.t -> Heap_type.t -> string -> t -> t -> t
+    = "caml_binaryen_array_new_data"
+  (** Module, type, data name, offset, size *)
+
+  external new_elem : Module.t -> Heap_type.t -> string -> t -> t -> t
+    = "caml_binaryen_array_new_elem"
+  (** Module, type, seg, offset, size *)
+
+  external new_fixed : Module.t -> Heap_type.t -> t list -> t
+    = "caml_binaryen_array_new_fixed"
+  (** Module, type, values *)
+
+  external get : Module.t -> t -> t -> Type.t -> bool -> t
+    = "caml_binaryen_array_get"
+  (** Module, array, index, type, signed *)
+
+  external set : Module.t -> t -> t -> t -> t = "caml_binaryen_array_set"
+  (** Module, array, index, value *)
+
+  external len : Module.t -> t -> t = "caml_binaryen_array_len"
+  (** Module, array *)
+
+  external fill : Module.t -> t -> t -> t -> t -> t = "caml_binaryen_array_fill"
+  (** Module, array, index, value, offset *)
+
+  external copy : Module.t -> t -> t -> t -> t -> t -> t
+    = "caml_binaryen_array_copy__bytecode" "caml_binaryen_array_copy"
+  (** Module, dest, dest index, src, src index, length *)
+
+  external init_data : Module.t -> string -> t -> t -> t -> t -> t
+    = "caml_binaryen_array_init_data__bytecode" "caml_binaryen_array_init_data"
+  (** Module, name, ref, index, offset, size *)
+
+  external init_elem : Module.t -> string -> t -> t -> t -> t -> t
+    = "caml_binaryen_array_init_elem__bytecode" "caml_binaryen_array_init_elem"
+  (** Module, seg, ref, index, offset, size *)
+end
+
+(** Bindings for `try_table` instruction. *)
+module Try = struct
+  external make :
+    Module.t ->
+    string option ->
+    t ->
+    string list ->
+    t list ->
+    string option ->
+    t = "caml_binaryen_try__bytecode" "caml_binaryen_try"
+  (** Module, name, body, catch tags, catch bodies, delegate target *)
+
+  (** Module, name, body, catch clauses, catch all *)
+  let make wasm_mod name body catch_clauses catch_all =
+    let catch_tags, catch_bodies = List.split catch_clauses in
+    let catch_bodies =
+      match catch_all with
+      | Some target -> List.append catch_bodies [ target ]
+      | None -> catch_bodies
+    in
+    make wasm_mod name body catch_tags catch_bodies None
+
+  external get_name : t -> string option = "caml_binaryen_try_get_name"
+  (** expr *)
+
+  external set_name : t -> string -> unit = "caml_binaryen_try_set_name"
+  (** expr, name *)
+
+  external get_body : t -> t = "caml_binaryen_try_get_body"
+  (** expr *)
+
+  external set_body : t -> t -> unit = "caml_binaryen_try_set_body"
+  (** expr, bodyExpr *)
+
+  external get_num_catch_tags : t -> int
+    = "caml_binaryen_try_get_num_catch_tags"
+  (** expr *)
+
+  external get_num_catch_bodies : t -> int
+    = "caml_binaryen_try_get_num_catch_bodies"
+  (** expr *)
+
+  external get_catch_tag_at : t -> int -> string
+    = "caml_binaryen_try_get_catch_tag_at"
+  (** expr, index *)
+
+  external set_catch_tag_at : t -> int -> string -> unit
+    = "caml_binaryen_try_set_catch_tag_at"
+  (** expr, index, catchTag *)
+
+  external append_catch_tag : t -> string -> int
+    = "caml_binaryen_try_append_catch_tag"
+  (** expr, catchTag *)
+
+  external insert_catch_tag_at : t -> int -> string -> unit
+    = "caml_binaryen_try_insert_catch_tag_at"
+  (** expr, index, catchTag *)
+
+  external remove_catch_tag_at : t -> int -> string
+    = "caml_binaryen_try_remove_catch_tag_at"
+  (** expr, index *)
+
+  external get_catch_body_at : t -> int -> t
+    = "caml_binaryen_try_get_catch_body_at"
+  (** expr, index *)
+
+  external set_catch_body_at : t -> int -> t -> unit
+    = "caml_binaryen_try_set_catch_body_at"
+  (** expr, index, catchExpr *)
+
+  external append_catch_body : t -> t -> int
+    = "caml_binaryen_try_append_catch_body"
+  (** expr, catchExpr *)
+
+  external insert_catch_body_at : t -> int -> t -> unit
+    = "caml_binaryen_try_insert_catch_body_at"
+  (** expr, index, catchExpr *)
+
+  external remove_catch_body_at : t -> int -> t
+    = "caml_binaryen_try_remove_catch_body_at"
+  (** expr, index *)
+
+  external has_catch_all : t -> bool = "caml_binaryen_try_has_catch_all"
+  (** expr *)
+end
+
+module Throw = struct
+  external make : Module.t -> string -> t list -> t = "caml_binaryen_throw"
+  (** Module, tag, operands *)
+
+  external get_tag : t -> string = "caml_binaryen_throw_get_tag"
+  (** expr *)
+
+  external set_tag : t -> string -> unit = "caml_binaryen_throw_set_tag"
+  (** expr, tagName *)
+
+  external get_num_operands : t -> int = "caml_binaryen_throw_get_num_operands"
+  (** expr *)
+
+  external get_operand_at : t -> int -> t = "caml_binaryen_throw_get_operand_at"
+  (** expr, index *)
+
+  external set_operand_at : t -> int -> t -> unit
+    = "caml_binaryen_throw_set_operand_at"
+  (** expr, index, operandExpr *)
+
+  external append_operand : t -> t -> int = "caml_binaryen_throw_append_operand"
+  (** expr, operandExpr *)
+
+  external insert_operand_at : t -> int -> t -> unit
+    = "caml_binaryen_throw_insert_operand_at"
+  (** expr, index, operandExpr *)
+
+  external remove_operand_at : t -> int -> t
+    = "caml_binaryen_throw_remove_operand_at"
+  (** expr, index *)
 end
 
 module Table = struct