feat: Add bindings for exception handling (try/catch/throw/rethrow)

src/dune

@@ -15,6 +15,7 @@
    export
    global
    table
+   tag
    memory
    module_feature
    module
@@ -37,6 +38,7 @@
    export.js
    global.js
    table.js
+   tag.js
    memory.js
    module_feature.js
    module.js

src/export.c

@@ -48,6 +48,16 @@ caml_binaryen_add_global_export(value _module, value _internalName, value _exter
   CAMLreturn(alloc_BinaryenExportRef(exp));
 }
 
+CAMLprim value
+caml_binaryen_add_tag_export(value _module, value _internalName, value _externalName) {
+  CAMLparam3(_module, _internalName, _externalName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* internalName = Safe_String_val(_internalName);
+  char* externalName = Safe_String_val(_externalName);
+  BinaryenExportRef exp = BinaryenAddTagExport(module, internalName, externalName);
+  CAMLreturn(alloc_BinaryenExportRef(exp));
+}
+
 CAMLprim value
 caml_binaryen_get_export(value _module, value _externalName) {
   CAMLparam2(_module, _externalName);

src/export.js

@@ -50,6 +50,19 @@ function caml_binaryen_add_global_export(
   );
 }
 
+//Provides: caml_binaryen_add_tag_export
+//Requires: caml_jsstring_of_string
+function caml_binaryen_add_tag_export(
+  wasm_mod,
+  internal_name,
+  external_name
+) {
+  return wasm_mod.addTagExport(
+    caml_jsstring_of_string(internal_name),
+    caml_jsstring_of_string(external_name)
+  );
+}
+
 //Provides: caml_binaryen_get_export
 //Requires: caml_jsstring_of_string
 function caml_binaryen_get_export(wasm_mod, external_name) {

src/export.ml

@@ -16,6 +16,10 @@ external add_global_export : Module.t -> string -> string -> t
   = "caml_binaryen_add_global_export"
 (** Module, internal name, external name. *)
 
+external add_tag_export : Module.t -> string -> string -> t
+  = "caml_binaryen_add_tag_export"
+(** Module, internal name, external name. *)
+
 external get_export : Module.t -> string -> t = "caml_binaryen_get_export"
 
 external remove_export : Module.t -> string -> unit

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

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) {