@grain/binaryen.ml 0.34.0 → 0.35.0

binaryen-archive/src/export.mli

@@ -4,6 +4,7 @@ val add_function_export : Module.t -> string -> string -> t
 val add_table_export : Module.t -> string -> string -> t
 val add_memory_export : Module.t -> string -> string -> t
 val add_global_export : Module.t -> string -> string -> t
+val add_tag_export : Module.t -> string -> string -> t
 val get_export : Module.t -> string -> t
 val remove_export : Module.t -> string -> unit
 val get_num_exports : Module.t -> int

binaryen-archive/src/expression.c

@@ -1883,6 +1883,297 @@ caml_binaryen_ref_eq(value _module, value _left, value _right) {
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
+// Exception handling operations
+CAMLprim value
+caml_binaryen_try(value _module, value _name, value _body, value _catchTags, value _catchBodies, value _delegateTarget) {
+  CAMLparam5(_module, _name, _body, _catchTags, _catchBodies);
+  CAMLxparam1(_delegateTarget);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char *name;
+  if (Is_none(_name)) {
+    name = NULL;
+  } else {
+    name = Safe_String_val(Some_val(_name));
+  }
+  BinaryenExpressionRef body = BinaryenExpressionRef_val(_body);
+  _catchTags = array_of_list(_catchTags);
+  int catchTagsLen = array_length(_catchTags);
+  const char* catchTags[catchTagsLen];
+  for (int i = 0; i < catchTagsLen; i++) {
+    catchTags[i] = Safe_String_val(Field(_catchTags, i));
+  }
+  _catchBodies = array_of_list(_catchBodies);
+  int catchBodiesLen = array_length(_catchBodies);
+  BinaryenExpressionRef catchBodies[catchBodiesLen];
+  for (int i = 0; i < catchBodiesLen; i++) {
+    catchBodies[i] = BinaryenExpressionRef_val(Field(_catchBodies, i));
+  }
+  char *delegateTarget;
+  if (Is_none(_delegateTarget)) {
+    delegateTarget = NULL;
+  } else {
+    delegateTarget = Safe_String_val(Some_val(_delegateTarget));
+  }
+  BinaryenExpressionRef exp = BinaryenTry(
+    module,
+    name,
+    body,
+    catchTags,
+    catchTagsLen,
+    catchBodies,
+    catchBodiesLen,
+    delegateTarget
+  );
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value caml_binaryen_try__bytecode(value * argv) {
+  return caml_binaryen_try(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
+CAMLprim value
+caml_binaryen_throw(value _module, value _tag, value _operands) {
+  CAMLparam3(_module, _tag, _operands);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char *tag = Safe_String_val(_tag);
+  _operands = array_of_list(_operands);
+  int operandsLen = array_length(_operands);
+  BinaryenExpressionRef operands[operandsLen];
+  for (int i = 0; i < operandsLen; i++) {
+    operands[i] = BinaryenExpressionRef_val(Field(_operands, i));
+  }
+  BinaryenExpressionRef exp = BinaryenThrow(module, tag, operands, operandsLen);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_try_get_name(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  const char* name = BinaryenTryGetName(expr);
+  if (name == NULL) {
+    CAMLreturn(Val_none);
+  } else {
+    CAMLreturn(caml_alloc_some(caml_copy_string(name)));
+  }
+}
+
+CAMLprim value
+caml_binaryen_try_set_name(value _expr, value _name) {
+  CAMLparam2(_expr, _name);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  const char* name = Safe_String_val(_name);
+  BinaryenTrySetName(expr, name);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_try_get_body(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenExpressionRef binaryenRetVal = BinaryenTryGetBody(expr);
+  CAMLreturn(alloc_BinaryenExpressionRef(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_set_body(value _expr, value _bodyExpr) {
+  CAMLparam2(_expr, _bodyExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenExpressionRef bodyExpr = BinaryenExpressionRef_val(_bodyExpr);
+  BinaryenTrySetBody(expr, bodyExpr);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_try_get_num_catch_tags(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex binaryenRetVal = BinaryenTryGetNumCatchTags(expr);
+  CAMLreturn(Val_int(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_get_num_catch_bodies(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex binaryenRetVal = BinaryenTryGetNumCatchBodies(expr);
+  CAMLreturn(Val_int(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_get_catch_tag_at(value _expr, value _index) {
+  CAMLparam2(_expr, _index);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  const char* binaryenRetVal = BinaryenTryGetCatchTagAt(expr, index);
+  CAMLreturn(caml_copy_string(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_set_catch_tag_at(value _expr, value _index, value _catchTag) {
+  CAMLparam3(_expr, _index, _catchTag);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  const char* catchTag = Safe_String_val(_catchTag);
+  BinaryenTrySetCatchTagAt(expr, index, catchTag);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_try_append_catch_tag(value _expr, value _catchTag) {
+  CAMLparam2(_expr, _catchTag);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  const char* catchTag = Safe_String_val(_catchTag);
+  BinaryenIndex binaryenRetVal = BinaryenTryAppendCatchTag(expr, catchTag);
+  CAMLreturn(Val_int(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_insert_catch_tag_at(value _expr, value _index, value _catchTag) {
+  CAMLparam3(_expr, _index, _catchTag);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  const char* catchTag = Safe_String_val(_catchTag);
+  BinaryenTryInsertCatchTagAt(expr, index, catchTag);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_try_remove_catch_tag_at(value _expr, value _index) {
+  CAMLparam2(_expr, _index);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  const char* binaryenRetVal = BinaryenTryRemoveCatchTagAt(expr, index);
+  CAMLreturn(caml_copy_string(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_get_catch_body_at(value _expr, value _index) {
+  CAMLparam2(_expr, _index);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef binaryenRetVal = BinaryenTryGetCatchBodyAt(expr, index);
+  CAMLreturn(alloc_BinaryenExpressionRef(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_set_catch_body_at(value _expr, value _index, value _catchExpr) {
+  CAMLparam3(_expr, _index, _catchExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef catchExpr = BinaryenExpressionRef_val(_catchExpr);
+  BinaryenTrySetCatchBodyAt(expr, index, catchExpr);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_try_append_catch_body(value _expr, value _catchExpr) {
+  CAMLparam2(_expr, _catchExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenExpressionRef catchExpr = BinaryenExpressionRef_val(_catchExpr);
+  BinaryenIndex binaryenRetVal = BinaryenTryAppendCatchBody(expr, catchExpr);
+  CAMLreturn(Val_int(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_insert_catch_body_at(value _expr, value _index, value _catchExpr) {
+  CAMLparam3(_expr, _index, _catchExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef catchExpr = BinaryenExpressionRef_val(_catchExpr);
+  BinaryenTryInsertCatchBodyAt(expr, index, catchExpr);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_try_remove_catch_body_at(value _expr, value _index) {
+  CAMLparam2(_expr, _index);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef binaryenRetVal = BinaryenTryRemoveCatchBodyAt(expr, index);
+  CAMLreturn(alloc_BinaryenExpressionRef(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_try_has_catch_all(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  bool binaryenRetVal = BinaryenTryHasCatchAll(expr);
+  CAMLreturn(Val_bool(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_throw_get_tag(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  const char* binaryenRetVal = BinaryenThrowGetTag(expr);
+  CAMLreturn(caml_copy_string(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_throw_set_tag(value _expr, value _tagName) {
+  CAMLparam2(_expr, _tagName);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  const char* tagName = Safe_String_val(_tagName);
+  BinaryenThrowSetTag(expr, tagName);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_throw_get_num_operands(value _expr) {
+  CAMLparam1(_expr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex binaryenRetVal = BinaryenThrowGetNumOperands(expr);
+  CAMLreturn(Val_int(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_throw_get_operand_at(value _expr, value _index) {
+  CAMLparam2(_expr, _index);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef binaryenRetVal = BinaryenThrowGetOperandAt(expr, index);
+  CAMLreturn(alloc_BinaryenExpressionRef(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_throw_set_operand_at(value _expr, value _index, value _operandExpr) {
+  CAMLparam3(_expr, _index, _operandExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef operandExpr = BinaryenExpressionRef_val(_operandExpr);
+  BinaryenThrowSetOperandAt(expr, index, operandExpr);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_throw_append_operand(value _expr, value _operandExpr) {
+  CAMLparam2(_expr, _operandExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenExpressionRef operandExpr = BinaryenExpressionRef_val(_operandExpr);
+  BinaryenIndex binaryenRetVal = BinaryenThrowAppendOperand(expr, operandExpr);
+  CAMLreturn(Val_int(binaryenRetVal));
+}
+
+CAMLprim value
+caml_binaryen_throw_insert_operand_at(value _expr, value _index, value _operandExpr) {
+  CAMLparam3(_expr, _index, _operandExpr);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef operandExpr = BinaryenExpressionRef_val(_operandExpr);
+  BinaryenThrowInsertOperandAt(expr, index, operandExpr);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_throw_remove_operand_at(value _expr, value _index) {
+  CAMLparam2(_expr, _index);
+  BinaryenExpressionRef expr = BinaryenExpressionRef_val(_expr);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef binaryenRetVal = BinaryenThrowRemoveOperandAt(expr, index);
+  CAMLreturn(alloc_BinaryenExpressionRef(binaryenRetVal));
+}
+
 // Table operations
 CAMLprim value
 caml_binaryen_table_get(value _module, value _name, value _index, value _ty) {

binaryen-archive/src/expression.js

@@ -1707,6 +1707,188 @@ function caml_binaryen_ref_eq(wasm_mod, left, right) {
   return wasm_mod.ref.func(left, right);
 }
 
+// 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
 
 //Provides: caml_binaryen_table_get

binaryen-archive/src/expression.ml

@@ -832,6 +832,124 @@ module Ref = struct
   (** Module, left, right *)
 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
   external get : Module.t -> string -> t -> Type.t -> t
     = "caml_binaryen_table_get"