@grain/binaryen.ml 0.34.0 → 0.36.0

binaryen-archive/src/expression.c

@@ -124,6 +124,38 @@ caml_binaryen_call_indirect__bytecode(value * argv) {
   return caml_binaryen_call_indirect(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
 }
 
+CAMLprim value
+caml_binaryen_call_ref(value _module, value _target, value _params, value _ty) {
+  CAMLparam4(_module, _target, _params, _ty);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef target = BinaryenExpressionRef_val(_target);
+  _params = array_of_list(_params);
+  int paramsLen = array_length(_params);
+  BinaryenExpressionRef params[paramsLen];
+  for (int i = 0; i < paramsLen; i++) {
+    params[i] = BinaryenExpressionRef_val(Field(_params, i));
+  }
+  BinaryenType ty = BinaryenType_val(_ty);
+  BinaryenExpressionRef exp = BinaryenCallRef(module, target, params, paramsLen, ty);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_return_call_ref(value _module, value _target, value _params, value _ty) {
+  CAMLparam4(_module, _target, _params, _ty);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef target = BinaryenExpressionRef_val(_target);
+  _params = array_of_list(_params);
+  int paramsLen = array_length(_params);
+  BinaryenExpressionRef params[paramsLen];
+  for (int i = 0; i < paramsLen; i++) {
+    params[i] = BinaryenExpressionRef_val(Field(_params, i));
+  }
+  BinaryenType ty = BinaryenType_val(_ty);
+  BinaryenExpressionRef exp = BinaryenReturnCallRef(module, target, params, paramsLen, ty);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
 CAMLprim value
 caml_binaryen_return_call(value _module, value _name, value _params, value _retty) {
   CAMLparam4(_module, _name, _params, _retty);
@@ -459,6 +491,38 @@ caml_binaryen_i31_get(value _module, value _val, value _signed) {
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
+CAMLprim value
+caml_binaryen_ref_test(value _module, value _ref, value _castType) {
+  CAMLparam3(_module, _ref, _castType);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenType castType = BinaryenType_val(_castType);
+  BinaryenExpressionRef exp = BinaryenRefTest(module, ref, castType);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_ref_cast(value _module, value _ref, value _castType) {
+  CAMLparam3(_module, _ref, _castType);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenType castType = BinaryenType_val(_castType);
+  BinaryenExpressionRef exp = BinaryenRefCast(module, ref, castType);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_br_on(value _module, value _op, value _name, value _ref, value _castType) {
+  CAMLparam5(_module, _op, _name, _ref, _castType);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenOp op = BinaryenOp_val(_op);
+  char* name = Safe_String_val(_name);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenType castType = BinaryenType_val(_castType);
+  BinaryenExpressionRef exp = BinaryenBrOn(module, op, name, ref, castType);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
 CAMLprim value
 caml_binaryen_expression_id_invalid(value unit) {
   CAMLparam1(unit);
@@ -1328,6 +1392,90 @@ caml_binaryen_call_indirect_set_return(value _exp, value _isReturn) {
   CAMLreturn(Val_unit);
 }
 
+CAMLprim value
+caml_binaryen_call_ref_get_target(value _exp) {
+  CAMLparam1(_exp);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenExpressionRef target = BinaryenCallRefGetTarget(exp);
+  CAMLreturn(alloc_BinaryenExpressionRef(target));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_set_target(value _exp, value _target) {
+  CAMLparam2(_exp, _target);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenExpressionRef target = BinaryenExpressionRef_val(_target);
+  BinaryenCallRefSetTarget(exp, target);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_call_ref_get_num_operands(value _exp) {
+  CAMLparam1(_exp);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  CAMLreturn(Val_int(BinaryenCallRefGetNumOperands(exp)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_get_operand_at(value _exp, value _index) {
+  CAMLparam2(_exp, _index);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(alloc_BinaryenExpressionRef(BinaryenCallRefGetOperandAt(exp, index)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_set_operand_at(value _exp, value _index, value _operand) {
+  CAMLparam3(_exp, _index, _operand);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef operand = BinaryenExpressionRef_val(_operand);
+  BinaryenCallRefSetOperandAt(exp, index, operand);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_call_ref_append_operand(value _exp, value _operand) {
+  CAMLparam2(_exp, _operand);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenExpressionRef operand = BinaryenExpressionRef_val(_operand);
+  CAMLreturn(Val_int(BinaryenCallRefAppendOperand(exp, operand)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_insert_operand_at(value _exp, value _index, value _operand) {
+  CAMLparam3(_exp, _index, _operand);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef operand = BinaryenExpressionRef_val(_operand);
+  BinaryenCallRefInsertOperandAt(exp, index, operand);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_call_ref_remove_operand_at(value _exp, value _index) {
+  CAMLparam2(_exp, _index);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(alloc_BinaryenExpressionRef(BinaryenCallRefRemoveOperandAt(exp, index)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_is_return(value _exp) {
+  CAMLparam1(_exp);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  CAMLreturn(Val_bool(BinaryenCallRefIsReturn(exp)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_set_return(value _exp, value _isReturn) {
+  CAMLparam2(_exp, _isReturn);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  int isReturn = Bool_val(_isReturn);
+  BinaryenCallRefSetReturn(exp, isReturn);
+  CAMLreturn(Val_unit);
+}
+
 CAMLprim value
 caml_binaryen_local_set_get_value(value _exp) {
   CAMLparam1(_exp);
@@ -1883,6 +2031,494 @@ caml_binaryen_ref_eq(value _module, value _left, value _right) {
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
+// Struct operations
+
+CAMLprim value
+caml_binaryen_struct_new(value _module, value _operands, value _type) {
+  CAMLparam3(_module, _operands, _type);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType type = BinaryenHeapType_val(_type);
+  if (Is_some(_operands)) {
+    _operands = array_of_list(Some_val(_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 = BinaryenStructNew(module, operands, operandsLen, type);
+    CAMLreturn(alloc_BinaryenExpressionRef(exp));
+  } else {
+    BinaryenExpressionRef exp = BinaryenStructNew(module, NULL, 0, type);
+    CAMLreturn(alloc_BinaryenExpressionRef(exp));
+  }
+}
+
+CAMLprim value
+caml_binaryen_struct_get(value _module, value _index, value _ref, value _type, value _signed) {
+  CAMLparam5(_module, _index, _ref, _type, _signed);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenType type = BinaryenType_val(_type);
+  bool signed_ = Bool_val(_signed);
+  BinaryenExpressionRef exp = BinaryenStructGet(module, index, ref, type, signed_);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_struct_set(value _module, value _index, value _ref, value _value) {
+  CAMLparam4(_module, _index, _ref, _value);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef value_ = BinaryenExpressionRef_val(_value);
+  BinaryenExpressionRef exp = BinaryenStructSet(module, index, ref, value_);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+// Array operations
+
+CAMLprim value
+caml_binaryen_array_new(value _module, value _type, value _size, value _init) {
+  CAMLparam4(_module, _type, _size, _init);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType type = BinaryenHeapType_val(_type);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef init = BinaryenExpressionRef_val(_init);
+  BinaryenExpressionRef exp = BinaryenArrayNew(module, type, size, init);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_new_data(value _module, value _type, value _name, value _offset, value _size) {
+  CAMLparam5(_module, _type, _name, _offset, _size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType type = BinaryenHeapType_val(_type);
+  char* name = Safe_String_val(_name);
+  BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayNewData(module, type, name, offset, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_new_elem(value _module, value _type, value _seg, value _offset, value _size) {
+  CAMLparam5(_module, _type, _seg, _offset, _size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType type = BinaryenHeapType_val(_type);
+  char* seg = Safe_String_val(_seg);
+  BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayNewElem(module, type, seg, offset, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_new_fixed(value _module, value _type, value _values) {
+  CAMLparam3(_module, _type, _values);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType type = BinaryenHeapType_val(_type);
+  _values = array_of_list(_values);
+  int valuesLen = array_length(_values);
+  BinaryenExpressionRef values[valuesLen];
+  for (int i = 0; i < valuesLen; i++) {
+    values[i] = BinaryenExpressionRef_val(Field(_values, i));
+  }
+  BinaryenExpressionRef exp = BinaryenArrayNewFixed(module, type, values, valuesLen);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_get(value _module, value _ref, value _index, value _type, value _signed) {
+  CAMLparam5(_module, _ref, _index, _type, _signed);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef index = BinaryenExpressionRef_val(_index);
+  BinaryenType type = BinaryenType_val(_type);
+  bool signed_ = Bool_val(_signed);
+  BinaryenExpressionRef exp = BinaryenArrayGet(module, ref, index, type, signed_);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_set(value _module, value _ref, value _index, value _value) {
+  CAMLparam4(_module, _ref, _index, _value);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef index = BinaryenExpressionRef_val(_index);
+  BinaryenExpressionRef value_ = BinaryenExpressionRef_val(_value);
+  BinaryenExpressionRef exp = BinaryenArraySet(module, ref, index, value_);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_len(value _module, value _ref) {
+  CAMLparam2(_module, _ref);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef exp = BinaryenArrayLen(module, ref);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_copy(value _module, value _destRef, value _destIndex, value _srcRef, value _srcIndex, value _length) {
+  CAMLparam5(_module, _destRef, _destIndex, _srcRef, _srcIndex);
+  CAMLxparam1(_length);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef destRef = BinaryenExpressionRef_val(_destRef);
+  BinaryenExpressionRef destIndex = BinaryenExpressionRef_val(_destIndex);
+  BinaryenExpressionRef srcRef = BinaryenExpressionRef_val(_srcRef);
+  BinaryenExpressionRef srcIndex = BinaryenExpressionRef_val(_srcIndex);
+  BinaryenExpressionRef length = BinaryenExpressionRef_val(_length);
+  BinaryenExpressionRef exp = BinaryenArrayCopy(module, destRef, destIndex, srcRef, srcIndex, length);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+CAMLprim value
+caml_binaryen_array_copy__bytecode(value * argv) {
+  return caml_binaryen_array_copy(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
+CAMLprim value
+caml_binaryen_array_fill(value _module, value _ref, value _index, value _value, value _size) {
+  CAMLparam5(_module, _ref, _index, _value, _size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef index = BinaryenExpressionRef_val(_index);
+  BinaryenExpressionRef val = BinaryenExpressionRef_val(_value);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayFill(module, ref, index, val, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_init_data(value _module, value _name, value _ref, value _index, value _offset, value _size) {
+  CAMLparam5(_module, _name, _ref, _index, _offset);
+  CAMLxparam1(_size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef index = BinaryenExpressionRef_val(_index);
+  BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayInitData(module, name, ref, index, offset, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_init_data__bytecode(value * argv) {
+  return caml_binaryen_array_init_data(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
+CAMLprim value
+caml_binaryen_array_init_elem(value _module, value _seg, value _ref, value _index, value _offset, value _size) {
+  CAMLparam5(_module, _seg, _ref, _index, _offset);
+  CAMLxparam1(_size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* seg = Safe_String_val(_seg);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef index = BinaryenExpressionRef_val(_index);
+  BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayInitElem(module, seg, ref, index, offset, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
+CAMLprim value
+caml_binaryen_array_init_elem__bytecode(value * argv) {
+  return caml_binaryen_array_init_elem(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
+// 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) {