6 files changed, 3110 insertions, 54 deletions

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index f4df69737..517ed42a6 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1167,6 +1167,7 @@ BinaryenExpressionRef BinaryenSIMDShuffle(BinaryenModuleRef module,
                                           BinaryenExpressionRef left,
                                           BinaryenExpressionRef right,
                                           const uint8_t mask_[16]) {
+  assert(mask_); // nullptr would be wrong
   std::array<uint8_t, 16> mask;
   memcpy(mask.data(), mask_, 16);
   return static_cast<Expression*>(
@@ -1307,7 +1308,7 @@ BinaryenExpressionRef BinaryenBrOnExn(BinaryenModuleRef module,
                                       const char* eventName,
                                       BinaryenExpressionRef exnref) {
   auto* wasm = (Module*)module;
-  Event* event = wasm->getEventOrNull(eventName);
+  auto* event = wasm->getEventOrNull(eventName);
   assert(event && "br_on_exn's event must exist");
   return static_cast<Expression*>(
     Builder(*wasm).makeBrOnExn(name, event, (Expression*)exnref));
@@ -1321,10 +1322,16 @@ BinaryenExpressionId BinaryenExpressionGetId(BinaryenExpressionRef expr) {
 BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr) {
   return ((Expression*)expr)->type.getID();
 }
+void BinaryenExpressionSetType(BinaryenExpressionRef expr, BinaryenType type) {
+  ((Expression*)expr)->type = Type(type);
+}
 void BinaryenExpressionPrint(BinaryenExpressionRef expr) {
   WasmPrinter::printExpression((Expression*)expr, std::cout);
   std::cout << '\n';
 }
+void BinaryenExpressionFinalize(BinaryenExpressionRef expr) {
+  ReFinalizeNode().visit((Expression*)expr);
+}
 
 BinaryenExpressionRef BinaryenExpressionCopy(BinaryenExpressionRef expr,
                                              BinaryenModuleRef module) {
@@ -1339,702 +1346,1690 @@ const char* BinaryenBlockGetName(BinaryenExpressionRef expr) {
   assert(expression->is<Block>());
   return static_cast<Block*>(expression)->name.c_str();
 }
+void BinaryenBlockSetName(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Block>());
+  // may be null or empty
+  static_cast<Block*>(expression)->name = name;
+}
 BinaryenIndex BinaryenBlockGetNumChildren(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Block>());
   return static_cast<Block*>(expression)->list.size();
 }
-BinaryenExpressionRef BinaryenBlockGetChild(BinaryenExpressionRef expr,
-                                            BinaryenIndex index) {
+BinaryenExpressionRef BinaryenBlockGetChildAt(BinaryenExpressionRef expr,
+                                              BinaryenIndex index) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Block>());
   assert(index < static_cast<Block*>(expression)->list.size());
   return static_cast<Block*>(expression)->list[index];
 }
+void BinaryenBlockSetChildAt(BinaryenExpressionRef expr,
+                             BinaryenIndex index,
+                             BinaryenExpressionRef childExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Block>());
+  assert(childExpr);
+  auto& list = static_cast<Block*>(expression)->list;
+  assert(index < list.size());
+  list[index] = (Expression*)childExpr;
+}
+BinaryenIndex BinaryenBlockAppendChild(BinaryenExpressionRef expr,
+                                       BinaryenExpressionRef childExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Block>());
+  assert(childExpr);
+  auto& list = static_cast<Block*>(expression)->list;
+  auto index = list.size();
+  list.push_back((Expression*)childExpr);
+  return index;
+}
+void BinaryenBlockInsertChildAt(BinaryenExpressionRef expr,
+                                BinaryenIndex index,
+                                BinaryenExpressionRef childExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Block>());
+  assert(childExpr);
+  static_cast<Block*>(expression)->list.insertAt(index, (Expression*)childExpr);
+}
+BinaryenExpressionRef BinaryenBlockRemoveChildAt(BinaryenExpressionRef expr,
+                                                 BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Block>());
+  return static_cast<Block*>(expression)->list.removeAt(index);
+}
 // If
 BinaryenExpressionRef BinaryenIfGetCondition(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<If>());
   return static_cast<If*>(expression)->condition;
 }
+void BinaryenIfSetCondition(BinaryenExpressionRef expr,
+                            BinaryenExpressionRef condExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<If>());
+  assert(condExpr);
+  static_cast<If*>(expression)->condition = (Expression*)condExpr;
+}
 BinaryenExpressionRef BinaryenIfGetIfTrue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<If>());
   return static_cast<If*>(expression)->ifTrue;
 }
+void BinaryenIfSetIfTrue(BinaryenExpressionRef expr,
+                         BinaryenExpressionRef ifTrueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<If>());
+  assert(ifTrueExpr);
+  static_cast<If*>(expression)->ifTrue = (Expression*)ifTrueExpr;
+}
 BinaryenExpressionRef BinaryenIfGetIfFalse(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<If>());
   return static_cast<If*>(expression)->ifFalse;
 }
+void BinaryenIfSetIfFalse(BinaryenExpressionRef expr,
+                          BinaryenExpressionRef ifFalseExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<If>());
+  // may be null
+  static_cast<If*>(expression)->ifFalse = (Expression*)ifFalseExpr;
+}
 // Loop
 const char* BinaryenLoopGetName(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Loop>());
   return static_cast<Loop*>(expression)->name.c_str();
 }
+void BinaryenLoopSetName(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Loop>());
+  // may be null or empty
+  static_cast<Loop*>(expression)->name = name;
+}
 BinaryenExpressionRef BinaryenLoopGetBody(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Loop>());
   return static_cast<Loop*>(expression)->body;
 }
+void BinaryenLoopSetBody(BinaryenExpressionRef expr,
+                         BinaryenExpressionRef bodyExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Loop>());
+  assert(bodyExpr);
+  static_cast<Loop*>(expression)->body = (Expression*)bodyExpr;
+}
 // Break
 const char* BinaryenBreakGetName(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Break>());
   return static_cast<Break*>(expression)->name.c_str();
 }
+void BinaryenBreakSetName(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Break>());
+  assert(name);
+  static_cast<Break*>(expression)->name = name;
+}
 BinaryenExpressionRef BinaryenBreakGetCondition(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Break>());
   return static_cast<Break*>(expression)->condition;
 }
+void BinaryenBreakSetCondition(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef condExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Break>());
+  // may be null (br)
+  static_cast<Break*>(expression)->condition = (Expression*)condExpr;
+}
 BinaryenExpressionRef BinaryenBreakGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Break>());
   return static_cast<Break*>(expression)->value;
 }
+void BinaryenBreakSetValue(BinaryenExpressionRef expr,
+                           BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Break>());
+  // may be null
+  static_cast<Break*>(expression)->value = (Expression*)valueExpr;
+}
 // Switch
 BinaryenIndex BinaryenSwitchGetNumNames(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->targets.size();
 }
-const char* BinaryenSwitchGetName(BinaryenExpressionRef expr,
-                                  BinaryenIndex index) {
+const char* BinaryenSwitchGetNameAt(BinaryenExpressionRef expr,
+                                    BinaryenIndex index) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Switch>());
   assert(index < static_cast<Switch*>(expression)->targets.size());
   return static_cast<Switch*>(expression)->targets[index].c_str();
 }
+void BinaryenSwitchSetNameAt(BinaryenExpressionRef expr,
+                             BinaryenIndex index,
+                             const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Switch>());
+  assert(index < static_cast<Switch*>(expression)->targets.size());
+  assert(name);
+  static_cast<Switch*>(expression)->targets[index] = name;
+}
+BinaryenIndex BinaryenSwitchAppendName(BinaryenExpressionRef expr,
+                                       const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Switch>());
+  assert(name);
+  auto& list = static_cast<Switch*>(expression)->targets;
+  auto index = list.size();
+  list.push_back(name);
+  return index;
+}
+void BinaryenSwitchInsertNameAt(BinaryenExpressionRef expr,
+                                BinaryenIndex index,
+                                const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Switch>());
+  assert(name);
+  static_cast<Switch*>(expression)->targets.insertAt(index, name);
+}
+const char* BinaryenSwitchRemoveNameAt(BinaryenExpressionRef expr,
+                                       BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Switch>());
+  return static_cast<Switch*>(expression)->targets.removeAt(index).c_str();
+}
 const char* BinaryenSwitchGetDefaultName(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->default_.c_str();
 }
+void BinaryenSwitchSetDefaultName(BinaryenExpressionRef expr,
+                                  const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Switch>());
+  // may be null or empty
+  static_cast<Switch*>(expression)->default_ = name;
+}
 BinaryenExpressionRef BinaryenSwitchGetCondition(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->condition;
 }
+void BinaryenSwitchSetCondition(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef condExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Switch>());
+  assert(condExpr);
+  static_cast<Switch*>(expression)->condition = (Expression*)condExpr;
+}
 BinaryenExpressionRef BinaryenSwitchGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->value;
 }
-// Call
-int BinaryenCallIsReturn(BinaryenExpressionRef expr) {
+void BinaryenSwitchSetValue(BinaryenExpressionRef expr,
+                            BinaryenExpressionRef valueExpr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<Call>());
-  return static_cast<Call*>(expression)->isReturn;
+  assert(expression->is<Switch>());
+  // may be null
+  static_cast<Switch*>(expression)->value = (Expression*)valueExpr;
 }
+// Call
 const char* BinaryenCallGetTarget(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Call>());
   return static_cast<Call*>(expression)->target.c_str();
 }
+void BinaryenCallSetTarget(BinaryenExpressionRef expr, const char* target) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Call>());
+  assert(target);
+  static_cast<Call*>(expression)->target = target;
+}
 BinaryenIndex BinaryenCallGetNumOperands(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Call>());
   return static_cast<Call*>(expression)->operands.size();
 }
-BinaryenExpressionRef BinaryenCallGetOperand(BinaryenExpressionRef expr,
-                                             BinaryenIndex index) {
+BinaryenExpressionRef BinaryenCallGetOperandAt(BinaryenExpressionRef expr,
+                                               BinaryenIndex index) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Call>());
   assert(index < static_cast<Call*>(expression)->operands.size());
   return static_cast<Call*>(expression)->operands[index];
 }
-// CallIndirect
-int BinaryenCallIndirectIsReturn(BinaryenExpressionRef expr) {
+void BinaryenCallSetOperandAt(BinaryenExpressionRef expr,
+                              BinaryenIndex index,
+                              BinaryenExpressionRef operandExpr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<CallIndirect>());
-  return static_cast<CallIndirect*>(expression)->isReturn;
+  assert(expression->is<Call>());
+  assert(index < static_cast<Call*>(expression)->operands.size());
+  assert(operandExpr);
+  static_cast<Call*>(expression)->operands[index] = (Expression*)operandExpr;
+}
+BinaryenIndex BinaryenCallAppendOperand(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Call>());
+  assert(operandExpr);
+  auto& list = static_cast<Call*>(expression)->operands;
+  auto index = list.size();
+  list.push_back((Expression*)operandExpr);
+  return index;
+}
+void BinaryenCallInsertOperandAt(BinaryenExpressionRef expr,
+                                 BinaryenIndex index,
+                                 BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Call>());
+  assert(operandExpr);
+  static_cast<Call*>(expression)
+    ->operands.insertAt(index, (Expression*)operandExpr);
+}
+BinaryenExpressionRef BinaryenCallRemoveOperandAt(BinaryenExpressionRef expr,
+                                                  BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Call>());
+  return static_cast<Call*>(expression)->operands.removeAt(index);
+}
+int BinaryenCallIsReturn(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Call>());
+  return static_cast<Call*>(expression)->isReturn;
 }
+void BinaryenCallSetReturn(BinaryenExpressionRef expr, int isReturn) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Call>());
+  static_cast<Call*>(expression)->isReturn = isReturn != 0;
+}
+// CallIndirect
 BinaryenExpressionRef
 BinaryenCallIndirectGetTarget(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->target;
 }
+void BinaryenCallIndirectSetTarget(BinaryenExpressionRef expr,
+                                   BinaryenExpressionRef targetExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  assert(targetExpr);
+  static_cast<CallIndirect*>(expression)->target = (Expression*)targetExpr;
+}
 BinaryenIndex BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->operands.size();
 }
-BinaryenExpressionRef BinaryenCallIndirectGetOperand(BinaryenExpressionRef expr,
-                                                     BinaryenIndex index) {
+BinaryenExpressionRef
+BinaryenCallIndirectGetOperandAt(BinaryenExpressionRef expr,
+                                 BinaryenIndex index) {
   auto* expression = (Expression*)expr;
   assert(expression->is<CallIndirect>());
   assert(index < static_cast<CallIndirect*>(expression)->operands.size());
   return static_cast<CallIndirect*>(expression)->operands[index];
 }
+void BinaryenCallIndirectSetOperandAt(BinaryenExpressionRef expr,
+                                      BinaryenIndex index,
+                                      BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  assert(index < static_cast<CallIndirect*>(expression)->operands.size());
+  assert(operandExpr);
+  static_cast<CallIndirect*>(expression)->operands[index] =
+    (Expression*)operandExpr;
+}
+BinaryenIndex
+BinaryenCallIndirectAppendOperand(BinaryenExpressionRef expr,
+                                  BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  assert(operandExpr);
+  auto& list = static_cast<CallIndirect*>(expression)->operands;
+  auto index = list.size();
+  list.push_back((Expression*)operandExpr);
+  return index;
+}
+void BinaryenCallIndirectInsertOperandAt(BinaryenExpressionRef expr,
+                                         BinaryenIndex index,
+                                         BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  assert(operandExpr);
+  static_cast<CallIndirect*>(expression)
+    ->operands.insertAt(index, (Expression*)operandExpr);
+}
+BinaryenExpressionRef
+BinaryenCallIndirectRemoveOperandAt(BinaryenExpressionRef expr,
+                                    BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  return static_cast<CallIndirect*>(expression)->operands.removeAt(index);
+}
+int BinaryenCallIndirectIsReturn(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  return static_cast<CallIndirect*>(expression)->isReturn;
+}
+void BinaryenCallIndirectSetReturn(BinaryenExpressionRef expr, int isReturn) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  static_cast<CallIndirect*>(expression)->isReturn = isReturn != 0;
+}
+BinaryenType BinaryenCallIndirectGetParams(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  return static_cast<CallIndirect*>(expression)->sig.params.getID();
+}
+void BinaryenCallIndirectSetParams(BinaryenExpressionRef expr,
+                                   BinaryenType params) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  static_cast<CallIndirect*>(expression)->sig.params = Type(params);
+}
+BinaryenType BinaryenCallIndirectGetResults(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  return static_cast<CallIndirect*>(expression)->sig.results.getID();
+}
+void BinaryenCallIndirectSetResults(BinaryenExpressionRef expr,
+                                    BinaryenType results) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  static_cast<CallIndirect*>(expression)->sig.results = Type(results);
+}
 // LocalGet
 BinaryenIndex BinaryenLocalGetGetIndex(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<LocalGet>());
   return static_cast<LocalGet*>(expression)->index;
 }
+void BinaryenLocalGetSetIndex(BinaryenExpressionRef expr, BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<LocalGet>());
+  static_cast<LocalGet*>(expression)->index = index;
+}
 // LocalSet
 int BinaryenLocalSetIsTee(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<LocalSet>());
   return static_cast<LocalSet*>(expression)->isTee();
+  // has no setter
 }
 BinaryenIndex BinaryenLocalSetGetIndex(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<LocalSet>());
   return static_cast<LocalSet*>(expression)->index;
 }
+void BinaryenLocalSetSetIndex(BinaryenExpressionRef expr, BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<LocalSet>());
+  static_cast<LocalSet*>(expression)->index = index;
+}
 BinaryenExpressionRef BinaryenLocalSetGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<LocalSet>());
   return static_cast<LocalSet*>(expression)->value;
 }
+void BinaryenLocalSetSetValue(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<LocalSet>());
+  assert(valueExpr);
+  static_cast<LocalSet*>(expression)->value = (Expression*)valueExpr;
+}
 // GlobalGet
 const char* BinaryenGlobalGetGetName(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<GlobalGet>());
   return static_cast<GlobalGet*>(expression)->name.c_str();
 }
+void BinaryenGlobalGetSetName(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<GlobalGet>());
+  assert(name);
+  static_cast<GlobalGet*>(expression)->name = name;
+}
 // GlobalSet
 const char* BinaryenGlobalSetGetName(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<GlobalSet>());
   return static_cast<GlobalSet*>(expression)->name.c_str();
 }
+void BinaryenGlobalSetSetName(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<GlobalSet>());
+  assert(name);
+  static_cast<GlobalSet*>(expression)->name = name;
+}
 BinaryenExpressionRef BinaryenGlobalSetGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<GlobalSet>());
   return static_cast<GlobalSet*>(expression)->value;
 }
+void BinaryenGlobalSetSetValue(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<GlobalSet>());
+  assert(valueExpr);
+  static_cast<GlobalSet*>(expression)->value = (Expression*)valueExpr;
+}
 // Host
 BinaryenOp BinaryenHostGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Host>());
   return static_cast<Host*>(expression)->op;
 }
+void BinaryenHostSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Host>());
+  static_cast<Host*>(expression)->op = (HostOp)op;
+}
 const char* BinaryenHostGetNameOperand(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Host>());
   return static_cast<Host*>(expression)->nameOperand.c_str();
 }
+void BinaryenHostSetNameOperand(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Host>());
+  static_cast<Host*>(expression)->nameOperand = name ? name : "";
+}
 BinaryenIndex BinaryenHostGetNumOperands(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Host>());
   return static_cast<Host*>(expression)->operands.size();
 }
-BinaryenExpressionRef BinaryenHostGetOperand(BinaryenExpressionRef expr,
-                                             BinaryenIndex index) {
+BinaryenExpressionRef BinaryenHostGetOperandAt(BinaryenExpressionRef expr,
+                                               BinaryenIndex index) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Host>());
   assert(index < static_cast<Host*>(expression)->operands.size());
   return static_cast<Host*>(expression)->operands[index];
 }
+void BinaryenHostSetOperandAt(BinaryenExpressionRef expr,
+                              BinaryenIndex index,
+                              BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Host>());
+  assert(index < static_cast<Host*>(expression)->operands.size());
+  assert(operandExpr);
+  static_cast<Host*>(expression)->operands[index] = (Expression*)operandExpr;
+}
+BinaryenIndex BinaryenHostAppendOperand(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Host>());
+  assert(operandExpr);
+  auto& list = static_cast<Host*>(expression)->operands;
+  auto index = list.size();
+  list.push_back((Expression*)operandExpr);
+  return index;
+}
+void BinaryenHostInsertOperandAt(BinaryenExpressionRef expr,
+                                 BinaryenIndex index,
+                                 BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Host>());
+  assert(operandExpr);
+  static_cast<Host*>(expression)
+    ->operands.insertAt(index, (Expression*)operandExpr);
+}
+BinaryenExpressionRef BinaryenHostRemoveOperandAt(BinaryenExpressionRef expr,
+                                                  BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Host>());
+  return static_cast<Host*>(expression)->operands.removeAt(index);
+}
 // Load
 int BinaryenLoadIsAtomic(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->isAtomic;
 }
+void BinaryenLoadSetAtomic(BinaryenExpressionRef expr, int isAtomic) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Load>());
+  static_cast<Load*>(expression)->isAtomic = isAtomic != 0;
+}
 int BinaryenLoadIsSigned(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->signed_;
 }
+void BinaryenLoadSetSigned(BinaryenExpressionRef expr, int isSigned) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Load>());
+  static_cast<Load*>(expression)->signed_ = isSigned != 0;
+}
 uint32_t BinaryenLoadGetBytes(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->bytes;
 }
+void BinaryenLoadSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Load>());
+  static_cast<Load*>(expression)->bytes = bytes;
+}
 uint32_t BinaryenLoadGetOffset(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->offset;
 }
+void BinaryenLoadSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Load>());
+  static_cast<Load*>(expression)->offset = offset;
+}
 uint32_t BinaryenLoadGetAlign(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->align;
 }
+void BinaryenLoadSetAlign(BinaryenExpressionRef expr, uint32_t align) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Load>());
+  static_cast<Load*>(expression)->align = align;
+}
 BinaryenExpressionRef BinaryenLoadGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->ptr;
 }
+void BinaryenLoadSetPtr(BinaryenExpressionRef expr,
+                        BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Load>());
+  assert(ptrExpr);
+  static_cast<Load*>(expression)->ptr = (Expression*)ptrExpr;
+}
 // Store
 int BinaryenStoreIsAtomic(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->isAtomic;
 }
+void BinaryenStoreSetAtomic(BinaryenExpressionRef expr, int isAtomic) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  static_cast<Store*>(expression)->isAtomic = isAtomic != 0;
+}
 uint32_t BinaryenStoreGetBytes(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->bytes;
 }
+void BinaryenStoreSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  static_cast<Store*>(expression)->bytes = bytes;
+}
 uint32_t BinaryenStoreGetOffset(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->offset;
 }
+void BinaryenStoreSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  static_cast<Store*>(expression)->offset = offset;
+}
 uint32_t BinaryenStoreGetAlign(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->align;
 }
+void BinaryenStoreSetAlign(BinaryenExpressionRef expr, uint32_t align) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  static_cast<Store*>(expression)->align = align;
+}
 BinaryenExpressionRef BinaryenStoreGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->ptr;
 }
+void BinaryenStoreSetPtr(BinaryenExpressionRef expr,
+                         BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  assert(ptrExpr);
+  static_cast<Store*>(expression)->ptr = (Expression*)ptrExpr;
+}
 BinaryenExpressionRef BinaryenStoreGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->value;
 }
+void BinaryenStoreSetValue(BinaryenExpressionRef expr,
+                           BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  assert(valueExpr);
+  static_cast<Store*>(expression)->value = (Expression*)valueExpr;
+}
+BinaryenType BinaryenStoreGetValueType(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  return static_cast<Store*>(expression)->valueType.getID();
+}
+void BinaryenStoreSetValueType(BinaryenExpressionRef expr,
+                               BinaryenType valueType) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Store>());
+  static_cast<Store*>(expression)->valueType = Type(valueType);
+}
 // Const
 int32_t BinaryenConstGetValueI32(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.geti32();
 }
+void BinaryenConstSetValueI32(BinaryenExpressionRef expr, int32_t value) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  static_cast<Const*>(expression)->value = Literal(value);
+}
 int64_t BinaryenConstGetValueI64(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.geti64();
 }
+void BinaryenConstSetValueI64(BinaryenExpressionRef expr, int64_t value) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  static_cast<Const*>(expression)->value = Literal(value);
+}
 int32_t BinaryenConstGetValueI64Low(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   return (int32_t)(static_cast<Const*>(expression)->value.geti64() &
                    0xffffffff);
 }
+void BinaryenConstSetValueI64Low(BinaryenExpressionRef expr, int32_t valueLow) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  auto& value = static_cast<Const*>(expression)->value;
+  int64_t valueI64 = value.type == Type::i64 ? value.geti64() : 0;
+  static_cast<Const*>(expression)->value =
+    Literal((valueI64 & ~0xffffffff) | (int64_t(valueLow) & 0xffffffff));
+}
 int32_t BinaryenConstGetValueI64High(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   return (int32_t)(static_cast<Const*>(expression)->value.geti64() >> 32);
 }
+void BinaryenConstSetValueI64High(BinaryenExpressionRef expr,
+                                  int32_t valueHigh) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  auto& value = static_cast<Const*>(expression)->value;
+  int64_t valueI64 = value.type == Type::i64 ? value.geti64() : 0;
+  static_cast<Const*>(expression)->value =
+    Literal((int64_t(valueHigh) << 32) | (valueI64 & 0xffffffff));
+}
 float BinaryenConstGetValueF32(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.getf32();
 }
+void BinaryenConstSetValueF32(BinaryenExpressionRef expr, float value) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  static_cast<Const*>(expression)->value = Literal(value);
+}
 double BinaryenConstGetValueF64(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.getf64();
 }
+void BinaryenConstSetValueF64(BinaryenExpressionRef expr, double value) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  static_cast<Const*>(expression)->value = Literal(value);
+}
 void BinaryenConstGetValueV128(BinaryenExpressionRef expr, uint8_t* out) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Const>());
   memcpy(out, static_cast<Const*>(expression)->value.getv128().data(), 16);
 }
+void BinaryenConstSetValueV128(BinaryenExpressionRef expr,
+                               const uint8_t value[16]) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Const>());
+  assert(value); // nullptr would be wrong
+  static_cast<Const*>(expression)->value = Literal(value);
+}
 // Unary
 BinaryenOp BinaryenUnaryGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Unary>());
   return static_cast<Unary*>(expression)->op;
 }
+void BinaryenUnarySetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Unary>());
+  static_cast<Unary*>(expression)->op = UnaryOp(op);
+}
 BinaryenExpressionRef BinaryenUnaryGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Unary>());
   return static_cast<Unary*>(expression)->value;
 }
+void BinaryenUnarySetValue(BinaryenExpressionRef expr,
+                           BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Unary>());
+  assert(valueExpr);
+  static_cast<Unary*>(expression)->value = (Expression*)valueExpr;
+}
 // Binary
 BinaryenOp BinaryenBinaryGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Binary>());
   return static_cast<Binary*>(expression)->op;
 }
+void BinaryenBinarySetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Binary>());
+  static_cast<Binary*>(expression)->op = BinaryOp(op);
+}
 BinaryenExpressionRef BinaryenBinaryGetLeft(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Binary>());
   return static_cast<Binary*>(expression)->left;
 }
+void BinaryenBinarySetLeft(BinaryenExpressionRef expr,
+                           BinaryenExpressionRef leftExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Binary>());
+  assert(leftExpr);
+  static_cast<Binary*>(expression)->left = (Expression*)leftExpr;
+}
 BinaryenExpressionRef BinaryenBinaryGetRight(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Binary>());
   return static_cast<Binary*>(expression)->right;
 }
+void BinaryenBinarySetRight(BinaryenExpressionRef expr,
+                            BinaryenExpressionRef rightExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Binary>());
+  assert(rightExpr);
+  static_cast<Binary*>(expression)->right = (Expression*)rightExpr;
+}
 // Select
 BinaryenExpressionRef BinaryenSelectGetIfTrue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Select>());
   return static_cast<Select*>(expression)->ifTrue;
 }
+void BinaryenSelectSetIfTrue(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef ifTrueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Select>());
+  assert(ifTrueExpr);
+  static_cast<Select*>(expression)->ifTrue = (Expression*)ifTrueExpr;
+}
 BinaryenExpressionRef BinaryenSelectGetIfFalse(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Select>());
   return static_cast<Select*>(expression)->ifFalse;
 }
+void BinaryenSelectSetIfFalse(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef ifFalseExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Select>());
+  assert(ifFalseExpr);
+  static_cast<Select*>(expression)->ifFalse = (Expression*)ifFalseExpr;
+}
 BinaryenExpressionRef BinaryenSelectGetCondition(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Select>());
   return static_cast<Select*>(expression)->condition;
 }
+void BinaryenSelectSetCondition(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef condExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Select>());
+  assert(condExpr);
+  static_cast<Select*>(expression)->condition = (Expression*)condExpr;
+}
 // Drop
 BinaryenExpressionRef BinaryenDropGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Drop>());
   return static_cast<Drop*>(expression)->value;
 }
+void BinaryenDropSetValue(BinaryenExpressionRef expr,
+                          BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Drop>());
+  assert(valueExpr);
+  static_cast<Drop*>(expression)->value = (Expression*)valueExpr;
+}
 // Return
 BinaryenExpressionRef BinaryenReturnGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Return>());
   return static_cast<Return*>(expression)->value;
 }
+void BinaryenReturnSetValue(BinaryenExpressionRef expr,
+                            BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Return>());
+  // may be null
+  static_cast<Return*>(expression)->value = (Expression*)valueExpr;
+}
 // AtomicRMW
 BinaryenOp BinaryenAtomicRMWGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->op;
 }
+void BinaryenAtomicRMWSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicRMW>());
+  static_cast<AtomicRMW*>(expression)->op = AtomicRMWOp(op);
+}
 uint32_t BinaryenAtomicRMWGetBytes(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->bytes;
 }
+void BinaryenAtomicRMWSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicRMW>());
+  static_cast<AtomicRMW*>(expression)->bytes = bytes;
+}
 uint32_t BinaryenAtomicRMWGetOffset(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->offset;
 }
+void BinaryenAtomicRMWSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicRMW>());
+  static_cast<AtomicRMW*>(expression)->offset = offset;
+}
 BinaryenExpressionRef BinaryenAtomicRMWGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->ptr;
 }
+void BinaryenAtomicRMWSetPtr(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicRMW>());
+  assert(ptrExpr);
+  static_cast<AtomicRMW*>(expression)->ptr = (Expression*)ptrExpr;
+}
 BinaryenExpressionRef BinaryenAtomicRMWGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->value;
 }
+void BinaryenAtomicRMWSetValue(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicRMW>());
+  assert(valueExpr);
+  static_cast<AtomicRMW*>(expression)->value = (Expression*)valueExpr;
+}
 // AtomicCmpxchg
 uint32_t BinaryenAtomicCmpxchgGetBytes(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->bytes;
 }
+void BinaryenAtomicCmpxchgSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicCmpxchg>());
+  static_cast<AtomicCmpxchg*>(expression)->bytes = bytes;
+}
 uint32_t BinaryenAtomicCmpxchgGetOffset(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->offset;
 }
+void BinaryenAtomicCmpxchgSetOffset(BinaryenExpressionRef expr,
+                                    uint32_t offset) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicCmpxchg>());
+  static_cast<AtomicCmpxchg*>(expression)->offset = offset;
+}
 BinaryenExpressionRef BinaryenAtomicCmpxchgGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->ptr;
 }
+void BinaryenAtomicCmpxchgSetPtr(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicCmpxchg>());
+  assert(ptrExpr);
+  static_cast<AtomicCmpxchg*>(expression)->ptr = (Expression*)ptrExpr;
+}
 BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetExpected(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->expected;
 }
+void BinaryenAtomicCmpxchgSetExpected(BinaryenExpressionRef expr,
+                                      BinaryenExpressionRef expectedExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicCmpxchg>());
+  assert(expectedExpr);
+  static_cast<AtomicCmpxchg*>(expression)->expected = (Expression*)expectedExpr;
+}
 BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetReplacement(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->replacement;
 }
+void BinaryenAtomicCmpxchgSetReplacement(
+  BinaryenExpressionRef expr, BinaryenExpressionRef replacementExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicCmpxchg>());
+  assert(replacementExpr);
+  static_cast<AtomicCmpxchg*>(expression)->replacement =
+    (Expression*)replacementExpr;
+}
 // AtomicWait
 BinaryenExpressionRef BinaryenAtomicWaitGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->ptr;
 }
+void BinaryenAtomicWaitSetPtr(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicWait>());
+  assert(ptrExpr);
+  static_cast<AtomicWait*>(expression)->ptr = (Expression*)ptrExpr;
+}
 BinaryenExpressionRef
 BinaryenAtomicWaitGetExpected(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->expected;
 }
+void BinaryenAtomicWaitSetExpected(BinaryenExpressionRef expr,
+                                   BinaryenExpressionRef expectedExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicWait>());
+  assert(expectedExpr);
+  static_cast<AtomicWait*>(expression)->expected = (Expression*)expectedExpr;
+}
 BinaryenExpressionRef BinaryenAtomicWaitGetTimeout(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->timeout;
 }
+void BinaryenAtomicWaitSetTimeout(BinaryenExpressionRef expr,
+                                  BinaryenExpressionRef timeoutExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicWait>());
+  assert(timeoutExpr);
+  static_cast<AtomicWait*>(expression)->timeout = (Expression*)timeoutExpr;
+}
 BinaryenType BinaryenAtomicWaitGetExpectedType(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->expectedType.getID();
 }
+void BinaryenAtomicWaitSetExpectedType(BinaryenExpressionRef expr,
+                                       BinaryenType expectedType) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicWait>());
+  static_cast<AtomicWait*>(expression)->expectedType = Type(expectedType);
+}
 // AtomicNotify
 BinaryenExpressionRef BinaryenAtomicNotifyGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicNotify>());
   return static_cast<AtomicNotify*>(expression)->ptr;
 }
+void BinaryenAtomicNotifySetPtr(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicNotify>());
+  assert(ptrExpr);
+  static_cast<AtomicNotify*>(expression)->ptr = (Expression*)ptrExpr;
+}
 BinaryenExpressionRef
 BinaryenAtomicNotifyGetNotifyCount(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicNotify>());
   return static_cast<AtomicNotify*>(expression)->notifyCount;
 }
+void BinaryenAtomicNotifySetNotifyCount(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef notifyCountExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicNotify>());
+  assert(notifyCountExpr);
+  static_cast<AtomicNotify*>(expression)->notifyCount =
+    (Expression*)notifyCountExpr;
+}
 // AtomicFence
 uint8_t BinaryenAtomicFenceGetOrder(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<AtomicFence>());
   return static_cast<AtomicFence*>(expression)->order;
 }
+void BinaryenAtomicFenceSetOrder(BinaryenExpressionRef expr, uint8_t order) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<AtomicFence>());
+  static_cast<AtomicFence*>(expression)->order = order;
+}
 // SIMDExtract
 BinaryenOp BinaryenSIMDExtractGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDExtract>());
   return static_cast<SIMDExtract*>(expression)->op;
 }
+void BinaryenSIMDExtractSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDExtract>());
+  static_cast<SIMDExtract*>(expression)->op = SIMDExtractOp(op);
+}
 BinaryenExpressionRef BinaryenSIMDExtractGetVec(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDExtract>());
   return static_cast<SIMDExtract*>(expression)->vec;
 }
+void BinaryenSIMDExtractSetVec(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef vecExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDExtract>());
+  assert(vecExpr);
+  static_cast<SIMDExtract*>(expression)->vec = (Expression*)vecExpr;
+}
 uint8_t BinaryenSIMDExtractGetIndex(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDExtract>());
   return static_cast<SIMDExtract*>(expression)->index;
 }
+void BinaryenSIMDExtractSetIndex(BinaryenExpressionRef expr, uint8_t index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDExtract>());
+  static_cast<SIMDExtract*>(expression)->index = index;
+}
 // SIMDReplace
 BinaryenOp BinaryenSIMDReplaceGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->op;
 }
+void BinaryenSIMDReplaceSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDReplace>());
+  static_cast<SIMDReplace*>(expression)->op = SIMDReplaceOp(op);
+}
 BinaryenExpressionRef BinaryenSIMDReplaceGetVec(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->vec;
 }
+void BinaryenSIMDReplaceSetVec(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef vecExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDReplace>());
+  assert(vecExpr);
+  static_cast<SIMDReplace*>(expression)->vec = (Expression*)vecExpr;
+}
 uint8_t BinaryenSIMDReplaceGetIndex(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->index;
 }
+void BinaryenSIMDReplaceSetIndex(BinaryenExpressionRef expr, uint8_t index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDReplace>());
+  static_cast<SIMDReplace*>(expression)->index = index;
+}
 BinaryenExpressionRef BinaryenSIMDReplaceGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->value;
 }
+void BinaryenSIMDReplaceSetValue(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDReplace>());
+  assert(valueExpr);
+  static_cast<SIMDReplace*>(expression)->value = (Expression*)valueExpr;
+}
 // SIMDShuffle
 BinaryenExpressionRef BinaryenSIMDShuffleGetLeft(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDShuffle>());
   return static_cast<SIMDShuffle*>(expression)->left;
 }
+void BinaryenSIMDShuffleSetLeft(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef leftExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDShuffle>());
+  assert(leftExpr);
+  static_cast<SIMDShuffle*>(expression)->left = (Expression*)leftExpr;
+}
 BinaryenExpressionRef BinaryenSIMDShuffleGetRight(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDShuffle>());
   return static_cast<SIMDShuffle*>(expression)->right;
 }
+void BinaryenSIMDShuffleSetRight(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef rightExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDShuffle>());
+  assert(rightExpr);
+  static_cast<SIMDShuffle*>(expression)->right = (Expression*)rightExpr;
+}
 void BinaryenSIMDShuffleGetMask(BinaryenExpressionRef expr, uint8_t* mask) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDShuffle>());
+  assert(mask); // nullptr would be wrong
   memcpy(mask, static_cast<SIMDShuffle*>(expression)->mask.data(), 16);
 }
+void BinaryenSIMDShuffleSetMask(BinaryenExpressionRef expr,
+                                const uint8_t mask_[16]) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDShuffle>());
+  assert(mask_); // nullptr would be wrong
+  auto& mask = static_cast<SIMDShuffle*>(expression)->mask;
+  memcpy(mask.data(), mask_, 16);
+}
 // SIMDTernary
 BinaryenOp BinaryenSIMDTernaryGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->op;
 }
+void BinaryenSIMDTernarySetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDTernary>());
+  static_cast<SIMDTernary*>(expression)->op = SIMDTernaryOp(op);
+}
 BinaryenExpressionRef BinaryenSIMDTernaryGetA(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->a;
 }
+void BinaryenSIMDTernarySetA(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef aExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDTernary>());
+  assert(aExpr);
+  static_cast<SIMDTernary*>(expression)->a = (Expression*)aExpr;
+}
 BinaryenExpressionRef BinaryenSIMDTernaryGetB(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->b;
 }
+void BinaryenSIMDTernarySetB(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef bExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDTernary>());
+  assert(bExpr);
+  static_cast<SIMDTernary*>(expression)->b = (Expression*)bExpr;
+}
 BinaryenExpressionRef BinaryenSIMDTernaryGetC(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->c;
 }
+void BinaryenSIMDTernarySetC(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef cExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDTernary>());
+  assert(cExpr);
+  static_cast<SIMDTernary*>(expression)->c = (Expression*)cExpr;
+}
 // SIMDShift
 BinaryenOp BinaryenSIMDShiftGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDShift>());
   return static_cast<SIMDShift*>(expression)->op;
 }
+void BinaryenSIMDShiftSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDShift>());
+  static_cast<SIMDShift*>(expression)->op = SIMDShiftOp(op);
+}
 BinaryenExpressionRef BinaryenSIMDShiftGetVec(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDShift>());
   return static_cast<SIMDShift*>(expression)->vec;
 }
+void BinaryenSIMDShiftSetVec(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef vecExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDShift>());
+  assert(vecExpr);
+  static_cast<SIMDShift*>(expression)->vec = (Expression*)vecExpr;
+}
 BinaryenExpressionRef BinaryenSIMDShiftGetShift(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDShift>());
   return static_cast<SIMDShift*>(expression)->shift;
 }
+void BinaryenSIMDShiftSetShift(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef shiftExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDShift>());
+  assert(shiftExpr);
+  static_cast<SIMDShift*>(expression)->shift = (Expression*)shiftExpr;
+}
 // SIMDLoad
 BinaryenOp BinaryenSIMDLoadGetOp(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->op;
 }
+void BinaryenSIMDLoadSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoad>());
+  static_cast<SIMDLoad*>(expression)->op = SIMDLoadOp(op);
+}
 uint32_t BinaryenSIMDLoadGetOffset(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->offset;
 }
+void BinaryenSIMDLoadSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoad>());
+  static_cast<SIMDLoad*>(expression)->offset = offset;
+}
 uint32_t BinaryenSIMDLoadGetAlign(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->align;
 }
+void BinaryenSIMDLoadSetAlign(BinaryenExpressionRef expr, uint32_t align) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoad>());
+  static_cast<SIMDLoad*>(expression)->align = align;
+}
 BinaryenExpressionRef BinaryenSIMDLoadGetPtr(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->ptr;
 }
+void BinaryenSIMDLoadSetPtr(BinaryenExpressionRef expr,
+                            BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoad>());
+  assert(ptrExpr);
+  static_cast<SIMDLoad*>(expression)->ptr = (Expression*)ptrExpr;
+}
 // MemoryInit
 uint32_t BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->segment;
 }
+void BinaryenMemoryInitSetSegment(BinaryenExpressionRef expr,
+                                  uint32_t segment) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryInit>());
+  static_cast<MemoryInit*>(expression)->segment = segment;
+}
 BinaryenExpressionRef BinaryenMemoryInitGetDest(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->dest;
 }
+void BinaryenMemoryInitSetDest(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef destExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryInit>());
+  assert(destExpr);
+  static_cast<MemoryInit*>(expression)->dest = (Expression*)destExpr;
+}
 BinaryenExpressionRef BinaryenMemoryInitGetOffset(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->offset;
 }
+void BinaryenMemoryInitSetOffset(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef offsetExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryInit>());
+  assert(offsetExpr);
+  static_cast<MemoryInit*>(expression)->offset = (Expression*)offsetExpr;
+}
 BinaryenExpressionRef BinaryenMemoryInitGetSize(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->size;
 }
+void BinaryenMemoryInitSetSize(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef sizeExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryInit>());
+  assert(sizeExpr);
+  static_cast<MemoryInit*>(expression)->size = (Expression*)sizeExpr;
+}
 // DataDrop
 uint32_t BinaryenDataDropGetSegment(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<DataDrop>());
   return static_cast<DataDrop*>(expression)->segment;
 }
+void BinaryenDataDropSetSegment(BinaryenExpressionRef expr, uint32_t segment) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<DataDrop>());
+  static_cast<DataDrop*>(expression)->segment = segment;
+}
 // MemoryCopy
 BinaryenExpressionRef BinaryenMemoryCopyGetDest(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryCopy>());
   return static_cast<MemoryCopy*>(expression)->dest;
 }
+void BinaryenMemoryCopySetDest(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef destExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryCopy>());
+  assert(destExpr);
+  static_cast<MemoryCopy*>(expression)->dest = (Expression*)destExpr;
+}
 BinaryenExpressionRef BinaryenMemoryCopyGetSource(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryCopy>());
   return static_cast<MemoryCopy*>(expression)->source;
 }
+void BinaryenMemoryCopySetSource(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef sourceExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryCopy>());
+  assert(sourceExpr);
+  static_cast<MemoryCopy*>(expression)->source = (Expression*)sourceExpr;
+}
 BinaryenExpressionRef BinaryenMemoryCopyGetSize(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryCopy>());
   return static_cast<MemoryCopy*>(expression)->size;
 }
+void BinaryenMemoryCopySetSize(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef sizeExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryCopy>());
+  assert(sizeExpr);
+  static_cast<MemoryCopy*>(expression)->size = (Expression*)sizeExpr;
+}
 // MemoryFill
 BinaryenExpressionRef BinaryenMemoryFillGetDest(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->dest;
 }
+void BinaryenMemoryFillSetDest(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef destExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryFill>());
+  assert(destExpr);
+  static_cast<MemoryFill*>(expression)->dest = (Expression*)destExpr;
+}
 BinaryenExpressionRef BinaryenMemoryFillGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->value;
 }
+void BinaryenMemoryFillSetValue(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryFill>());
+  assert(valueExpr);
+  static_cast<MemoryFill*>(expression)->value = (Expression*)valueExpr;
+}
 BinaryenExpressionRef BinaryenMemoryFillGetSize(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->size;
 }
+void BinaryenMemoryFillSetSize(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef sizeExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<MemoryFill>());
+  assert(sizeExpr);
+  static_cast<MemoryFill*>(expression)->size = (Expression*)sizeExpr;
+}
 // RefIsNull
 BinaryenExpressionRef BinaryenRefIsNullGetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<RefIsNull>());
   return static_cast<RefIsNull*>(expression)->value;
 }
+void BinaryenRefIsNullSetValue(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef valueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<RefIsNull>());
+  assert(valueExpr);
+  static_cast<RefIsNull*>(expression)->value = (Expression*)valueExpr;
+}
 // RefFunc
 const char* BinaryenRefFuncGetFunc(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<RefFunc>());
   return static_cast<RefFunc*>(expression)->func.c_str();
 }
+void BinaryenRefFuncSetFunc(BinaryenExpressionRef expr, const char* funcName) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<RefFunc>());
+  static_cast<RefFunc*>(expression)->func = funcName;
+}
 // Try
 BinaryenExpressionRef BinaryenTryGetBody(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->body;
 }
+void BinaryenTrySetBody(BinaryenExpressionRef expr,
+                        BinaryenExpressionRef bodyExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(bodyExpr);
+  static_cast<Try*>(expression)->body = (Expression*)bodyExpr;
+}
 BinaryenExpressionRef BinaryenTryGetCatchBody(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->catchBody;
 }
+void BinaryenTrySetCatchBody(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef catchBodyExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(catchBodyExpr);
+  static_cast<Try*>(expression)->catchBody = (Expression*)catchBodyExpr;
+}
 // Throw
 const char* BinaryenThrowGetEvent(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Throw>());
   return static_cast<Throw*>(expression)->event.c_str();
 }
-BinaryenExpressionRef BinaryenThrowGetOperand(BinaryenExpressionRef expr,
-                                              BinaryenIndex index) {
+void BinaryenThrowSetEvent(BinaryenExpressionRef expr, const char* eventName) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Throw>());
-  assert(index < static_cast<Throw*>(expression)->operands.size());
-  return static_cast<Throw*>(expression)->operands[index];
+  static_cast<Throw*>(expression)->event = eventName;
 }
 BinaryenIndex BinaryenThrowGetNumOperands(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Throw>());
   return static_cast<Throw*>(expression)->operands.size();
 }
+BinaryenExpressionRef BinaryenThrowGetOperandAt(BinaryenExpressionRef expr,
+                                                BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Throw>());
+  assert(index < static_cast<Throw*>(expression)->operands.size());
+  return static_cast<Throw*>(expression)->operands[index];
+}
+void BinaryenThrowSetOperandAt(BinaryenExpressionRef expr,
+                               BinaryenIndex index,
+                               BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Throw>());
+  assert(index < static_cast<Throw*>(expression)->operands.size());
+  assert(operandExpr);
+  static_cast<Throw*>(expression)->operands[index] = (Expression*)operandExpr;
+}
+BinaryenIndex BinaryenThrowAppendOperand(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Throw>());
+  assert(operandExpr);
+  auto& list = static_cast<Throw*>(expression)->operands;
+  auto index = list.size();
+  list.push_back((Expression*)operandExpr);
+  return index;
+}
+void BinaryenThrowInsertOperandAt(BinaryenExpressionRef expr,
+                                  BinaryenIndex index,
+                                  BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Throw>());
+  assert(operandExpr);
+  static_cast<Throw*>(expression)
+    ->operands.insertAt(index, (Expression*)operandExpr);
+}
+BinaryenExpressionRef BinaryenThrowRemoveOperandAt(BinaryenExpressionRef expr,
+                                                   BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Throw>());
+  return static_cast<Throw*>(expression)->operands.removeAt(index);
+}
 // Rethrow
 BinaryenExpressionRef BinaryenRethrowGetExnref(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Rethrow>());
   return static_cast<Rethrow*>(expression)->exnref;
 }
+void BinaryenRethrowSetExnref(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef exnrefExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Rethrow>());
+  assert(exnrefExpr);
+  static_cast<Rethrow*>(expression)->exnref = (Expression*)exnrefExpr;
+}
 // BrOnExn
 const char* BinaryenBrOnExnGetEvent(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<BrOnExn>());
   return static_cast<BrOnExn*>(expression)->event.c_str();
 }
+void BinaryenBrOnExnSetEvent(BinaryenExpressionRef expr,
+                             const char* eventName) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<BrOnExn>());
+  static_cast<BrOnExn*>(expression)->event = eventName;
+}
 const char* BinaryenBrOnExnGetName(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<BrOnExn>());
   return static_cast<BrOnExn*>(expression)->name.c_str();
 }
+void BinaryenBrOnExnSetName(BinaryenExpressionRef expr, const char* name) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<BrOnExn>());
+  static_cast<BrOnExn*>(expression)->name = name;
+}
 BinaryenExpressionRef BinaryenBrOnExnGetExnref(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<BrOnExn>());
   return static_cast<BrOnExn*>(expression)->exnref;
 }
+void BinaryenBrOnExnSetExnref(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef exnrefExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<BrOnExn>());
+  assert(exnrefExpr);
+  static_cast<BrOnExn*>(expression)->exnref = (Expression*)exnrefExpr;
+}
 // TupleMake
 BinaryenIndex BinaryenTupleMakeGetNumOperands(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<TupleMake>());
   return static_cast<TupleMake*>(expression)->operands.size();
 }
-BinaryenExpressionRef BinaryenTupleMakeGetOperand(BinaryenExpressionRef expr,
-                                                  BinaryenIndex index) {
+BinaryenExpressionRef BinaryenTupleMakeGetOperandAt(BinaryenExpressionRef expr,
+                                                    BinaryenIndex index) {
   auto* expression = (Expression*)expr;
   assert(expression->is<TupleMake>());
   return static_cast<TupleMake*>(expression)->operands[index];
 }
+void BinaryenTupleMakeSetOperandAt(BinaryenExpressionRef expr,
+                                   BinaryenIndex index,
+                                   BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleMake>());
+  assert(index < static_cast<TupleMake*>(expression)->operands.size());
+  assert(operandExpr);
+  static_cast<TupleMake*>(expression)->operands[index] =
+    (Expression*)operandExpr;
+}
+BinaryenIndex
+BinaryenTupleMakeAppendOperand(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleMake>());
+  assert(operandExpr);
+  auto& list = static_cast<TupleMake*>(expression)->operands;
+  auto index = list.size();
+  list.push_back((Expression*)operandExpr);
+  return index;
+}
+void BinaryenTupleMakeInsertOperandAt(BinaryenExpressionRef expr,
+                                      BinaryenIndex index,
+                                      BinaryenExpressionRef operandExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleMake>());
+  assert(operandExpr);
+  static_cast<TupleMake*>(expression)
+    ->operands.insertAt(index, (Expression*)operandExpr);
+}
+BinaryenExpressionRef
+BinaryenTupleMakeRemoveOperandAt(BinaryenExpressionRef expr,
+                                 BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleMake>());
+  return static_cast<TupleMake*>(expression)->operands.removeAt(index);
+}
+
 // TupleExtract
 BinaryenExpressionRef BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<TupleExtract>());
   return static_cast<TupleExtract*>(expression)->tuple;
 }
+void BinaryenTupleExtractSetTuple(BinaryenExpressionRef expr,
+                                  BinaryenExpressionRef tupleExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleExtract>());
+  assert(tupleExpr);
+  static_cast<TupleExtract*>(expression)->tuple = (Expression*)tupleExpr;
+}
 BinaryenIndex BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<TupleExtract>());
   return static_cast<TupleExtract*>(expression)->index;
 }
+void BinaryenTupleExtractSetIndex(BinaryenExpressionRef expr,
+                                  BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleExtract>());
+  static_cast<TupleExtract*>(expression)->index = index;
+}
 
 // Functions
 
@@ -2440,7 +3435,7 @@ void BinaryenModulePrintAsmjs(BinaryenModuleRef module) {
   auto* wasm = (Module*)module;
   Wasm2JSBuilder::Flags flags;
   Wasm2JSBuilder wasm2js(flags, globalPassOptions);
-  Ref asmjs = wasm2js.processWasm(wasm);
+  auto asmjs = wasm2js.processWasm(wasm);
   JSPrinter jser(true, true, asmjs);
   Output out("", Flags::Text); // stdout
   Wasm2JSGlue glue(*wasm, out, flags, "asmFunc");
@@ -2700,6 +3695,11 @@ BinaryenType BinaryenFunctionGetVar(BinaryenFunctionRef func,
 BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func) {
   return ((Function*)func)->body;
 }
+void BinaryenFunctionSetBody(BinaryenFunctionRef func,
+                             BinaryenExpressionRef body) {
+  assert(body);
+  ((Function*)func)->body = (Expression*)body;
+}
 void BinaryenFunctionOptimize(BinaryenFunctionRef func,
                               BinaryenModuleRef module) {
   PassRunner passRunner((Module*)module);
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index b153a28e9..b74993780 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -854,261 +854,1010 @@ BINARYEN_API BinaryenExpressionRef BinaryenTupleExtract(
 BINARYEN_API BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module,
                                                BinaryenType type);
 
+// Expression
+
+// Gets the id (kind) of the given expression.
 BINARYEN_API BinaryenExpressionId
 BinaryenExpressionGetId(BinaryenExpressionRef expr);
+// Gets the type of the given expression.
 BINARYEN_API BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr);
+// Sets the type of the given expression.
+BINARYEN_API void BinaryenExpressionSetType(BinaryenExpressionRef expr,
+                                            BinaryenType type);
+// Prints text format of the given expression to stdout.
 BINARYEN_API void BinaryenExpressionPrint(BinaryenExpressionRef expr);
+// Re-finalizes an expression after it has been modified.
+BINARYEN_API void BinaryenExpressionFinalize(BinaryenExpressionRef expr);
+// Makes a deep copy of the given expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenExpressionCopy(BinaryenExpressionRef expr, BinaryenModuleRef module);
 
+// Block
+
+// Gets the name (label) of a `block` expression.
 BINARYEN_API const char* BinaryenBlockGetName(BinaryenExpressionRef expr);
+// Sets the name (label) of a `block` expression.
+BINARYEN_API void BinaryenBlockSetName(BinaryenExpressionRef expr,
+                                       const char* name);
+// Gets the number of child expressions of a `block` expression.
 BINARYEN_API BinaryenIndex
 BinaryenBlockGetNumChildren(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenBlockGetChild(BinaryenExpressionRef expr, BinaryenIndex index);
-
+// Gets the child expression at the specified index of a `block` expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenBlockGetChildAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets (replaces) the child expression at the specified index of a `block`
+// expression.
+BINARYEN_API void BinaryenBlockSetChildAt(BinaryenExpressionRef expr,
+                                          BinaryenIndex index,
+                                          BinaryenExpressionRef childExpr);
+// Appends a child expression to a `block` expression, returning its insertion
+// index.
+BINARYEN_API BinaryenIndex BinaryenBlockAppendChild(
+  BinaryenExpressionRef expr, BinaryenExpressionRef childExpr);
+// Inserts a child expression at the specified index of a `block` expression,
+// moving existing children including the one previously at that index one index
+// up.
+BINARYEN_API void BinaryenBlockInsertChildAt(BinaryenExpressionRef expr,
+                                             BinaryenIndex index,
+                                             BinaryenExpressionRef childExpr);
+// Removes the child expression at the specified index of a `block` expression,
+// moving all subsequent children one index down. Returns the child expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenBlockRemoveChildAt(BinaryenExpressionRef expr, BinaryenIndex index);
+
+// If
+
+// Gets the condition expression of an `if` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenIfGetCondition(BinaryenExpressionRef expr);
+// Sets the condition expression of an `if` expression.
+BINARYEN_API void BinaryenIfSetCondition(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef condExpr);
+// Gets the ifTrue (then) expression of an `if` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenIfGetIfTrue(BinaryenExpressionRef expr);
+// Sets the ifTrue (then) expression of an `if` expression.
+BINARYEN_API void BinaryenIfSetIfTrue(BinaryenExpressionRef expr,
+                                      BinaryenExpressionRef ifTrueExpr);
+// Gets the ifFalse (else) expression, if any, of an `if` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenIfGetIfFalse(BinaryenExpressionRef expr);
+// Sets the ifFalse (else) expression, if any, of an `if` expression.
+BINARYEN_API void BinaryenIfSetIfFalse(BinaryenExpressionRef expr,
+                                       BinaryenExpressionRef ifFalseExpr);
+
+// Loop
 
+// Gets the name (label) of a `loop` expression.
 BINARYEN_API const char* BinaryenLoopGetName(BinaryenExpressionRef expr);
+// Sets the name (label) of a `loop` expression.
+BINARYEN_API void BinaryenLoopSetName(BinaryenExpressionRef expr,
+                                      const char* name);
+// Gets the body expression of a `loop` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenLoopGetBody(BinaryenExpressionRef expr);
+// Sets the body expression of a `loop` expression.
+BINARYEN_API void BinaryenLoopSetBody(BinaryenExpressionRef expr,
+                                      BinaryenExpressionRef bodyExpr);
+
+// Break
 
+// Gets the name (target label) of a `br` or `br_if` expression.
 BINARYEN_API const char* BinaryenBreakGetName(BinaryenExpressionRef expr);
+// Sets the name (target label) of a `br` or `br_if` expression.
+BINARYEN_API void BinaryenBreakSetName(BinaryenExpressionRef expr,
+                                       const char* name);
+// Gets the condition expression, if any, of a `br_if` expression. No condition
+// indicates a `br` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenBreakGetCondition(BinaryenExpressionRef expr);
+// Sets the condition expression, if any, of a `br_if` expression. No condition
+// makes it a `br` expression.
+BINARYEN_API void BinaryenBreakSetCondition(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef condExpr);
+// Gets the value expression, if any, of a `br` or `br_if` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenBreakGetValue(BinaryenExpressionRef expr);
+// Sets the value expression, if any, of a `br` or `br_if` expression.
+BINARYEN_API void BinaryenBreakSetValue(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef valueExpr);
+
+// Switch
 
+// Gets the number of names (target labels) of a `br_table` expression.
 BINARYEN_API BinaryenIndex
 BinaryenSwitchGetNumNames(BinaryenExpressionRef expr);
-BINARYEN_API const char* BinaryenSwitchGetName(BinaryenExpressionRef expr,
-                                               BinaryenIndex index);
+// Gets the name (target label) at the specified index of a `br_table`
+// expression.
+BINARYEN_API const char* BinaryenSwitchGetNameAt(BinaryenExpressionRef expr,
+                                                 BinaryenIndex index);
+// Sets the name (target label) at the specified index of a `br_table`
+// expression.
+BINARYEN_API void BinaryenSwitchSetNameAt(BinaryenExpressionRef expr,
+                                          BinaryenIndex index,
+                                          const char* name);
+// Appends a name to a `br_table` expression, returning its insertion index.
+BINARYEN_API BinaryenIndex BinaryenSwitchAppendName(BinaryenExpressionRef expr,
+                                                    const char* name);
+// Inserts a name at the specified index of a `br_table` expression, moving
+// existing names including the one previously at that index one index up.
+BINARYEN_API void BinaryenSwitchInsertNameAt(BinaryenExpressionRef expr,
+                                             BinaryenIndex index,
+                                             const char* name);
+// Removes the name at the specified index of a `br_table` expression, moving
+// all subsequent names one index down. Returns the name.
+BINARYEN_API const char* BinaryenSwitchRemoveNameAt(BinaryenExpressionRef expr,
+                                                    BinaryenIndex index);
+// Gets the default name (target label), if any, of a `br_table` expression.
 BINARYEN_API const char*
 BinaryenSwitchGetDefaultName(BinaryenExpressionRef expr);
+// Sets the default name (target label), if any, of a `br_table` expression.
+BINARYEN_API void BinaryenSwitchSetDefaultName(BinaryenExpressionRef expr,
+                                               const char* name);
+// Gets the condition expression of a `br_table` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSwitchGetCondition(BinaryenExpressionRef expr);
+// Sets the condition expression of a `br_table` expression.
+BINARYEN_API void BinaryenSwitchSetCondition(BinaryenExpressionRef expr,
+                                             BinaryenExpressionRef condExpr);
+// Gets the value expression, if any, of a `br_table` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSwitchGetValue(BinaryenExpressionRef expr);
+// Sets the value expression, if any, of a `br_table` expression.
+BINARYEN_API void BinaryenSwitchSetValue(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef valueExpr);
 
-BINARYEN_API int BinaryenCallIsReturn(BinaryenExpressionRef expr);
+// Call
+
+// Gets the target function name of a `call` expression.
 BINARYEN_API const char* BinaryenCallGetTarget(BinaryenExpressionRef expr);
+// Sets the target function name of a `call` expression.
+BINARYEN_API void BinaryenCallSetTarget(BinaryenExpressionRef expr,
+                                        const char* target);
+// Gets the number of operands of a `call` expression.
 BINARYEN_API BinaryenIndex
 BinaryenCallGetNumOperands(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenCallGetOperand(BinaryenExpressionRef expr, BinaryenIndex index);
+// Gets the operand expression at the specified index of a `call` expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenCallGetOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the operand expression at the specified index of a `call` expression.
+BINARYEN_API void BinaryenCallSetOperandAt(BinaryenExpressionRef expr,
+                                           BinaryenIndex index,
+                                           BinaryenExpressionRef operandExpr);
+// Appends an operand expression to a `call` expression, returning its insertion
+// index.
+BINARYEN_API BinaryenIndex BinaryenCallAppendOperand(
+  BinaryenExpressionRef expr, BinaryenExpressionRef operandExpr);
+// Inserts an operand expression at the specified index of a `call` expression,
+// moving existing operands including the one previously at that index one index
+// up.
+BINARYEN_API void
+BinaryenCallInsertOperandAt(BinaryenExpressionRef expr,
+                            BinaryenIndex index,
+                            BinaryenExpressionRef operandExpr);
+// Removes the operand expression at the specified index of a `call` expression,
+// moving all subsequent operands one index down. Returns the operand
+// expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenCallRemoveOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Gets whether the specified `call` expression is a tail call.
+BINARYEN_API int BinaryenCallIsReturn(BinaryenExpressionRef expr);
+// Sets whether the specified `call` expression is a tail call.
+BINARYEN_API void BinaryenCallSetReturn(BinaryenExpressionRef expr,
+                                        int isReturn);
 
-BINARYEN_API int BinaryenCallIndirectIsReturn(BinaryenExpressionRef expr);
+// CallIndirect
+
+// Gets the target expression of a `call_indirect` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenCallIndirectGetTarget(BinaryenExpressionRef expr);
+// Sets the target expression of a `call_indirect` expression.
+BINARYEN_API void
+BinaryenCallIndirectSetTarget(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef targetExpr);
+// Gets the number of operands of a `call_indirect` expression.
 BINARYEN_API BinaryenIndex
 BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenCallIndirectGetOperand(BinaryenExpressionRef expr, BinaryenIndex index);
+// Gets the operand expression at the specified index of a `call_indirect`
+// expression.
+BINARYEN_API BinaryenExpressionRef BinaryenCallIndirectGetOperandAt(
+  BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the operand expression at the specified index of a `call_indirect`
+// expression.
+BINARYEN_API void
+BinaryenCallIndirectSetOperandAt(BinaryenExpressionRef expr,
+                                 BinaryenIndex index,
+                                 BinaryenExpressionRef operandExpr);
+// Appends an operand expression to a `call_indirect` expression, returning its
+// insertion index.
+BINARYEN_API BinaryenIndex BinaryenCallIndirectAppendOperand(
+  BinaryenExpressionRef expr, BinaryenExpressionRef operandExpr);
+// Inserts an operand expression at the specified index of a `call_indirect`
+// expression, moving existing operands including the one previously at that
+// index one index up.
+BINARYEN_API void
+BinaryenCallIndirectInsertOperandAt(BinaryenExpressionRef expr,
+                                    BinaryenIndex index,
+                                    BinaryenExpressionRef operandExpr);
+// Removes the operand expression at the specified index of a `call_indirect`
+// expression, moving all subsequent operands one index down. Returns the
+// operand expression.
+BINARYEN_API BinaryenExpressionRef BinaryenCallIndirectRemoveOperandAt(
+  BinaryenExpressionRef expr, BinaryenIndex index);
+// Gets whether the specified `call_indirect` expression is a tail call.
+BINARYEN_API int BinaryenCallIndirectIsReturn(BinaryenExpressionRef expr);
+// Sets whether the specified `call_indirect` expression is a tail call.
+BINARYEN_API void BinaryenCallIndirectSetReturn(BinaryenExpressionRef expr,
+                                                int isReturn);
+// Gets the parameter types of the specified `call_indirect` expression.
+BINARYEN_API BinaryenType
+BinaryenCallIndirectGetParams(BinaryenExpressionRef expr);
+// Sets the parameter types of the specified `call_indirect` expression.
+BINARYEN_API void BinaryenCallIndirectSetParams(BinaryenExpressionRef expr,
+                                                BinaryenType params);
+// Gets the result types of the specified `call_indirect` expression.
+BINARYEN_API BinaryenType
+BinaryenCallIndirectGetResults(BinaryenExpressionRef expr);
+// Sets the result types of the specified `call_indirect` expression.
+BINARYEN_API void BinaryenCallIndirectSetResults(BinaryenExpressionRef expr,
+                                                 BinaryenType params);
+
+// LocalGet
 
+// Gets the local index of a `local.get` expression.
 BINARYEN_API BinaryenIndex BinaryenLocalGetGetIndex(BinaryenExpressionRef expr);
+// Sets the local index of a `local.get` expression.
+BINARYEN_API void BinaryenLocalGetSetIndex(BinaryenExpressionRef expr,
+                                           BinaryenIndex index);
 
+// LocalSet
+
+// Gets whether a `local.set` tees its value (is a `local.tee`). True if the
+// expression has a type other than `none`.
 BINARYEN_API int BinaryenLocalSetIsTee(BinaryenExpressionRef expr);
+// Gets the local index of a `local.set` or `local.tee` expression.
 BINARYEN_API BinaryenIndex BinaryenLocalSetGetIndex(BinaryenExpressionRef expr);
+// Sets the local index of a `local.set` or `local.tee` expression.
+BINARYEN_API void BinaryenLocalSetSetIndex(BinaryenExpressionRef expr,
+                                           BinaryenIndex index);
+// Gets the value expression of a `local.set` or `local.tee` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenLocalSetGetValue(BinaryenExpressionRef expr);
+// Sets the value expression of a `local.set` or `local.tee` expression.
+BINARYEN_API void BinaryenLocalSetSetValue(BinaryenExpressionRef expr,
+                                           BinaryenExpressionRef valueExpr);
+
+// GlobalGet
 
+// Gets the name of the global being accessed by a `global.get` expression.
 BINARYEN_API const char* BinaryenGlobalGetGetName(BinaryenExpressionRef expr);
+// Sets the name of the global being accessed by a `global.get` expression.
+BINARYEN_API void BinaryenGlobalGetSetName(BinaryenExpressionRef expr,
+                                           const char* name);
 
+// GlobalSet
+
+// Gets the name of the global being accessed by a `global.set` expression.
 BINARYEN_API const char* BinaryenGlobalSetGetName(BinaryenExpressionRef expr);
+// Sets the name of the global being accessed by a `global.set` expression.
+BINARYEN_API void BinaryenGlobalSetSetName(BinaryenExpressionRef expr,
+                                           const char* name);
+// Gets the value expression of a `global.set` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenGlobalSetGetValue(BinaryenExpressionRef expr);
+// Sets the value expression of a `global.set` expression.
+BINARYEN_API void BinaryenGlobalSetSetValue(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef valueExpr);
+
+// Host
 
+// Gets the operation being performed by a host expression.
 BINARYEN_API BinaryenOp BinaryenHostGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a host expression.
+BINARYEN_API void BinaryenHostSetOp(BinaryenExpressionRef expr, BinaryenOp op);
+// Gets the name operand, if any, of a host expression.
 BINARYEN_API const char* BinaryenHostGetNameOperand(BinaryenExpressionRef expr);
+// Sets the name operand, if any, of a host expression.
+BINARYEN_API void BinaryenHostSetNameOperand(BinaryenExpressionRef expr,
+                                             const char* nameOperand);
+// Gets the number of operands of a host expression.
 BINARYEN_API BinaryenIndex
 BinaryenHostGetNumOperands(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenHostGetOperand(BinaryenExpressionRef expr, BinaryenIndex index);
-
+// Gets the operand at the specified index of a host expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenHostGetOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the operand at the specified index of a host expression.
+BINARYEN_API void BinaryenHostSetOperandAt(BinaryenExpressionRef expr,
+                                           BinaryenIndex index,
+                                           BinaryenExpressionRef operandExpr);
+// Appends an operand expression to a host expression, returning its insertion
+// index.
+BINARYEN_API BinaryenIndex BinaryenHostAppendOperand(
+  BinaryenExpressionRef expr, BinaryenExpressionRef operandExpr);
+// Inserts an operand expression at the specified index of a host expression,
+// moving existing operands including the one previously at that index one index
+// up.
+BINARYEN_API void
+BinaryenHostInsertOperandAt(BinaryenExpressionRef expr,
+                            BinaryenIndex index,
+                            BinaryenExpressionRef operandExpr);
+// Removes the operand expression at the specified index of a host expression,
+// moving all subsequent operands one index down. Returns the operand
+// expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenHostRemoveOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+
+// Load
+
+// Gets whether a `load` expression is atomic (is an `atomic.load`).
 BINARYEN_API int BinaryenLoadIsAtomic(BinaryenExpressionRef expr);
+// Sets whether a `load` expression is atomic (is an `atomic.load`).
+BINARYEN_API void BinaryenLoadSetAtomic(BinaryenExpressionRef expr,
+                                        int isAtomic);
+// Gets whether a `load` expression operates on a signed value (`_s`).
 BINARYEN_API int BinaryenLoadIsSigned(BinaryenExpressionRef expr);
+// Sets whether a `load` expression operates on a signed value (`_s`).
+BINARYEN_API void BinaryenLoadSetSigned(BinaryenExpressionRef expr,
+                                        int isSigned);
+// Gets the constant offset of a `load` expression.
 BINARYEN_API uint32_t BinaryenLoadGetOffset(BinaryenExpressionRef expr);
+// Sets the constant offset of a `load` expression.
+BINARYEN_API void BinaryenLoadSetOffset(BinaryenExpressionRef expr,
+                                        uint32_t offset);
+// Gets the number of bytes loaded by a `load` expression.
 BINARYEN_API uint32_t BinaryenLoadGetBytes(BinaryenExpressionRef expr);
+// Sets the number of bytes loaded by a `load` expression.
+BINARYEN_API void BinaryenLoadSetBytes(BinaryenExpressionRef expr,
+                                       uint32_t bytes);
+// Gets the byte alignment of a `load` expression.
 BINARYEN_API uint32_t BinaryenLoadGetAlign(BinaryenExpressionRef expr);
+// Sets the byte alignment of a `load` expression.
+BINARYEN_API void BinaryenLoadSetAlign(BinaryenExpressionRef expr,
+                                       uint32_t align);
+// Gets the pointer expression of a `load` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenLoadGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of a `load` expression.
+BINARYEN_API void BinaryenLoadSetPtr(BinaryenExpressionRef expr,
+                                     BinaryenExpressionRef ptrExpr);
 
+// Store
+
+// Gets whether a `store` expression is atomic (is an `atomic.store`).
 BINARYEN_API int BinaryenStoreIsAtomic(BinaryenExpressionRef expr);
+// Sets whether a `store` expression is atomic (is an `atomic.store`).
+BINARYEN_API void BinaryenStoreSetAtomic(BinaryenExpressionRef expr,
+                                         int isAtomic);
+// Gets the number of bytes stored by a `store` expression.
 BINARYEN_API uint32_t BinaryenStoreGetBytes(BinaryenExpressionRef expr);
+// Sets the number of bytes stored by a `store` expression.
+BINARYEN_API void BinaryenStoreSetBytes(BinaryenExpressionRef expr,
+                                        uint32_t bytes);
+// Gets the constant offset of a `store` expression.
 BINARYEN_API uint32_t BinaryenStoreGetOffset(BinaryenExpressionRef expr);
+// Sets the constant offset of a `store` expression.
+BINARYEN_API void BinaryenStoreSetOffset(BinaryenExpressionRef expr,
+                                         uint32_t offset);
+// Gets the byte alignment of a `store` expression.
 BINARYEN_API uint32_t BinaryenStoreGetAlign(BinaryenExpressionRef expr);
+// Sets the byte alignment of a `store` expression.
+BINARYEN_API void BinaryenStoreSetAlign(BinaryenExpressionRef expr,
+                                        uint32_t align);
+// Gets the pointer expression of a `store` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenStoreGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of a `store` expression.
+BINARYEN_API void BinaryenStoreSetPtr(BinaryenExpressionRef expr,
+                                      BinaryenExpressionRef ptrExpr);
+// Gets the value expression of a `store` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenStoreGetValue(BinaryenExpressionRef expr);
-
+// Sets the value expression of a `store` expression.
+BINARYEN_API void BinaryenStoreSetValue(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef valueExpr);
+// Gets the value type of a `store` expression.
+BINARYEN_API BinaryenType BinaryenStoreGetValueType(BinaryenExpressionRef expr);
+// Sets the value type of a `store` expression.
+BINARYEN_API void BinaryenStoreSetValueType(BinaryenExpressionRef expr,
+                                            BinaryenType valueType);
+
+// Const
+
+// Gets the 32-bit integer value of an `i32.const` expression.
 BINARYEN_API int32_t BinaryenConstGetValueI32(BinaryenExpressionRef expr);
+// Sets the 32-bit integer value of an `i32.const` expression.
+BINARYEN_API void BinaryenConstSetValueI32(BinaryenExpressionRef expr,
+                                           int32_t value);
+// Gets the 64-bit integer value of an `i64.const` expression.
 BINARYEN_API int64_t BinaryenConstGetValueI64(BinaryenExpressionRef expr);
+// Sets the 64-bit integer value of an `i64.const` expression.
+BINARYEN_API void BinaryenConstSetValueI64(BinaryenExpressionRef expr,
+                                           int64_t value);
+// Gets the low 32-bits of the 64-bit integer value of an `i64.const`
+// expression.
 BINARYEN_API int32_t BinaryenConstGetValueI64Low(BinaryenExpressionRef expr);
+// Sets the low 32-bits of the 64-bit integer value of an `i64.const`
+// expression.
+BINARYEN_API void BinaryenConstSetValueI64Low(BinaryenExpressionRef expr,
+                                              int32_t valueLow);
+// Gets the high 32-bits of the 64-bit integer value of an `i64.const`
+// expression.
 BINARYEN_API int32_t BinaryenConstGetValueI64High(BinaryenExpressionRef expr);
+// Sets the high 32-bits of the 64-bit integer value of an `i64.const`
+// expression.
+BINARYEN_API void BinaryenConstSetValueI64High(BinaryenExpressionRef expr,
+                                               int32_t valueHigh);
+// Gets the 32-bit float value of a `f32.const` expression.
 BINARYEN_API float BinaryenConstGetValueF32(BinaryenExpressionRef expr);
+// Sets the 32-bit float value of a `f32.const` expression.
+BINARYEN_API void BinaryenConstSetValueF32(BinaryenExpressionRef expr,
+                                           float value);
+// Gets the 64-bit float (double) value of a `f64.const` expression.
 BINARYEN_API double BinaryenConstGetValueF64(BinaryenExpressionRef expr);
+// Sets the 64-bit float (double) value of a `f64.const` expression.
+BINARYEN_API void BinaryenConstSetValueF64(BinaryenExpressionRef expr,
+                                           double value);
+// Reads the 128-bit vector value of a `v128.const` expression.
 BINARYEN_API void BinaryenConstGetValueV128(BinaryenExpressionRef expr,
                                             uint8_t* out);
+// Sets the 128-bit vector value of a `v128.const` expression.
+BINARYEN_API void BinaryenConstSetValueV128(BinaryenExpressionRef expr,
+                                            const uint8_t value[16]);
 
+// Unary
+
+// Gets the operation being performed by a unary expression.
 BINARYEN_API BinaryenOp BinaryenUnaryGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a unary expression.
+BINARYEN_API void BinaryenUnarySetOp(BinaryenExpressionRef expr, BinaryenOp op);
+// Gets the value expression of a unary expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenUnaryGetValue(BinaryenExpressionRef expr);
+// Sets the value expression of a unary expression.
+BINARYEN_API void BinaryenUnarySetValue(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef valueExpr);
+
+// Binary
 
+// Gets the operation being performed by a binary expression.
 BINARYEN_API BinaryenOp BinaryenBinaryGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a binary expression.
+BINARYEN_API void BinaryenBinarySetOp(BinaryenExpressionRef expr,
+                                      BinaryenOp op);
+// Gets the left expression of a binary expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenBinaryGetLeft(BinaryenExpressionRef expr);
+// Sets the left expression of a binary expression.
+BINARYEN_API void BinaryenBinarySetLeft(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef leftExpr);
+// Gets the right expression of a binary expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenBinaryGetRight(BinaryenExpressionRef expr);
+// Sets the right expression of a binary expression.
+BINARYEN_API void BinaryenBinarySetRight(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef rightExpr);
 
+// Select
+
+// Gets the expression becoming selected by a `select` expression if the
+// condition turns out true.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSelectGetIfTrue(BinaryenExpressionRef expr);
+// Sets the expression becoming selected by a `select` expression if the
+// condition turns out true.
+BINARYEN_API void BinaryenSelectSetIfTrue(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef ifTrueExpr);
+// Gets the expression becoming selected by a `select` expression if the
+// condition turns out false.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSelectGetIfFalse(BinaryenExpressionRef expr);
+// Sets the expression becoming selected by a `select` expression if the
+// condition turns out false.
+BINARYEN_API void BinaryenSelectSetIfFalse(BinaryenExpressionRef expr,
+                                           BinaryenExpressionRef ifFalseExpr);
+// Gets the condition expression of a `select` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSelectGetCondition(BinaryenExpressionRef expr);
+// Sets the condition expression of a `select` expression.
+BINARYEN_API void BinaryenSelectSetCondition(BinaryenExpressionRef expr,
+                                             BinaryenExpressionRef condExpr);
+
+// Drop
 
+// Gets the value expression being dropped by a `drop` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenDropGetValue(BinaryenExpressionRef expr);
+// Sets the value expression being dropped by a `drop` expression.
+BINARYEN_API void BinaryenDropSetValue(BinaryenExpressionRef expr,
+                                       BinaryenExpressionRef valueExpr);
 
+// Return
+
+// Gets the value expression, if any, being returned by a `return` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenReturnGetValue(BinaryenExpressionRef expr);
+// Sets the value expression, if any, being returned by a `return` expression.
+BINARYEN_API void BinaryenReturnSetValue(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef valueExpr);
+
+// AtomicRMW
 
+// Gets the operation being performed by an atomic read-modify-write expression.
 BINARYEN_API BinaryenOp BinaryenAtomicRMWGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by an atomic read-modify-write expression.
+BINARYEN_API void BinaryenAtomicRMWSetOp(BinaryenExpressionRef expr,
+                                         BinaryenOp op);
+// Gets the number of bytes affected by an atomic read-modify-write expression.
 BINARYEN_API uint32_t BinaryenAtomicRMWGetBytes(BinaryenExpressionRef expr);
+// Sets the number of bytes affected by an atomic read-modify-write expression.
+BINARYEN_API void BinaryenAtomicRMWSetBytes(BinaryenExpressionRef expr,
+                                            uint32_t bytes);
+// Gets the constant offset of an atomic read-modify-write expression.
 BINARYEN_API uint32_t BinaryenAtomicRMWGetOffset(BinaryenExpressionRef expr);
+// Sets the constant offset of an atomic read-modify-write expression.
+BINARYEN_API void BinaryenAtomicRMWSetOffset(BinaryenExpressionRef expr,
+                                             uint32_t offset);
+// Gets the pointer expression of an atomic read-modify-write expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicRMWGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of an atomic read-modify-write expression.
+BINARYEN_API void BinaryenAtomicRMWSetPtr(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef ptrExpr);
+// Gets the value expression of an atomic read-modify-write expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicRMWGetValue(BinaryenExpressionRef expr);
+// Sets the value expression of an atomic read-modify-write expression.
+BINARYEN_API void BinaryenAtomicRMWSetValue(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef valueExpr);
 
+// AtomicCmpxchg
+
+// Gets the number of bytes affected by an atomic compare and exchange
+// expression.
 BINARYEN_API uint32_t BinaryenAtomicCmpxchgGetBytes(BinaryenExpressionRef expr);
+// Sets the number of bytes affected by an atomic compare and exchange
+// expression.
+BINARYEN_API void BinaryenAtomicCmpxchgSetBytes(BinaryenExpressionRef expr,
+                                                uint32_t bytes);
+// Gets the constant offset of an atomic compare and exchange expression.
 BINARYEN_API uint32_t
 BinaryenAtomicCmpxchgGetOffset(BinaryenExpressionRef expr);
+// Sets the constant offset of an atomic compare and exchange expression.
+BINARYEN_API void BinaryenAtomicCmpxchgSetOffset(BinaryenExpressionRef expr,
+                                                 uint32_t offset);
+// Gets the pointer expression of an atomic compare and exchange expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of an atomic compare and exchange expression.
+BINARYEN_API void BinaryenAtomicCmpxchgSetPtr(BinaryenExpressionRef expr,
+                                              BinaryenExpressionRef ptrExpr);
+// Gets the expression representing the expected value of an atomic compare and
+// exchange expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetExpected(BinaryenExpressionRef expr);
+// Sets the expression representing the expected value of an atomic compare and
+// exchange expression.
+BINARYEN_API void
+BinaryenAtomicCmpxchgSetExpected(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef expectedExpr);
+// Gets the replacement expression of an atomic compare and exchange expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetReplacement(BinaryenExpressionRef expr);
+// Sets the replacement expression of an atomic compare and exchange expression.
+BINARYEN_API void
+BinaryenAtomicCmpxchgSetReplacement(BinaryenExpressionRef expr,
+                                    BinaryenExpressionRef replacementExpr);
+
+// AtomicWait
 
+// Gets the pointer expression of an `atomic.wait` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicWaitGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of an `atomic.wait` expression.
+BINARYEN_API void BinaryenAtomicWaitSetPtr(BinaryenExpressionRef expr,
+                                           BinaryenExpressionRef ptrExpr);
+// Gets the expression representing the expected value of an `atomic.wait`
+// expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicWaitGetExpected(BinaryenExpressionRef expr);
+// Sets the expression representing the expected value of an `atomic.wait`
+// expression.
+BINARYEN_API void
+BinaryenAtomicWaitSetExpected(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef expectedExpr);
+// Gets the timeout expression of an `atomic.wait` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicWaitGetTimeout(BinaryenExpressionRef expr);
+// Sets the timeout expression of an `atomic.wait` expression.
+BINARYEN_API void
+BinaryenAtomicWaitSetTimeout(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef timeoutExpr);
+// Gets the expected type of an `atomic.wait` expression.
 BINARYEN_API BinaryenType
 BinaryenAtomicWaitGetExpectedType(BinaryenExpressionRef expr);
+// Sets the expected type of an `atomic.wait` expression.
+BINARYEN_API void BinaryenAtomicWaitSetExpectedType(BinaryenExpressionRef expr,
+                                                    BinaryenType expectedType);
 
+// AtomicNotify
+
+// Gets the pointer expression of an `atomic.notify` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicNotifyGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of an `atomic.notify` expression.
+BINARYEN_API void BinaryenAtomicNotifySetPtr(BinaryenExpressionRef expr,
+                                             BinaryenExpressionRef ptrExpr);
+// Gets the notify count expression of an `atomic.notify` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenAtomicNotifyGetNotifyCount(BinaryenExpressionRef expr);
+// Sets the notify count expression of an `atomic.notify` expression.
+BINARYEN_API void
+BinaryenAtomicNotifySetNotifyCount(BinaryenExpressionRef expr,
+                                   BinaryenExpressionRef notifyCountExpr);
+
+// AtomicFence
 
+// Gets the order of an `atomic.fence` expression.
 BINARYEN_API uint8_t BinaryenAtomicFenceGetOrder(BinaryenExpressionRef expr);
+// Sets the order of an `atomic.fence` expression.
+BINARYEN_API void BinaryenAtomicFenceSetOrder(BinaryenExpressionRef expr,
+                                              uint8_t order);
 
+// SIMDExtract
+
+// Gets the operation being performed by a SIMD extract expression.
 BINARYEN_API BinaryenOp BinaryenSIMDExtractGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a SIMD extract expression.
+BINARYEN_API void BinaryenSIMDExtractSetOp(BinaryenExpressionRef expr,
+                                           BinaryenOp op);
+// Gets the vector expression a SIMD extract expression extracts from.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDExtractGetVec(BinaryenExpressionRef expr);
+// Sets the vector expression a SIMD extract expression extracts from.
+BINARYEN_API void BinaryenSIMDExtractSetVec(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef vecExpr);
+// Gets the index of the extracted lane of a SIMD extract expression.
 BINARYEN_API uint8_t BinaryenSIMDExtractGetIndex(BinaryenExpressionRef expr);
+// Sets the index of the extracted lane of a SIMD extract expression.
+BINARYEN_API void BinaryenSIMDExtractSetIndex(BinaryenExpressionRef expr,
+                                              uint8_t index);
+
+// SIMDReplace
 
+// Gets the operation being performed by a SIMD replace expression.
 BINARYEN_API BinaryenOp BinaryenSIMDReplaceGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a SIMD replace expression.
+BINARYEN_API void BinaryenSIMDReplaceSetOp(BinaryenExpressionRef expr,
+                                           BinaryenOp op);
+// Gets the vector expression a SIMD replace expression replaces in.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDReplaceGetVec(BinaryenExpressionRef expr);
+// Sets the vector expression a SIMD replace expression replaces in.
+BINARYEN_API void BinaryenSIMDReplaceSetVec(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef vecExpr);
+// Gets the index of the replaced lane of a SIMD replace expression.
 BINARYEN_API uint8_t BinaryenSIMDReplaceGetIndex(BinaryenExpressionRef expr);
+// Sets the index of the replaced lane of a SIMD replace expression.
+BINARYEN_API void BinaryenSIMDReplaceSetIndex(BinaryenExpressionRef expr,
+                                              uint8_t index);
+// Gets the value expression a SIMD replace expression replaces with.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDReplaceGetValue(BinaryenExpressionRef expr);
+// Sets the value expression a SIMD replace expression replaces with.
+BINARYEN_API void BinaryenSIMDReplaceSetValue(BinaryenExpressionRef expr,
+                                              BinaryenExpressionRef valueExpr);
 
+// SIMDShuffle
+
+// Gets the left expression of a SIMD shuffle expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDShuffleGetLeft(BinaryenExpressionRef expr);
+// Sets the left expression of a SIMD shuffle expression.
+BINARYEN_API void BinaryenSIMDShuffleSetLeft(BinaryenExpressionRef expr,
+                                             BinaryenExpressionRef leftExpr);
+// Gets the right expression of a SIMD shuffle expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDShuffleGetRight(BinaryenExpressionRef expr);
+// Sets the right expression of a SIMD shuffle expression.
+BINARYEN_API void BinaryenSIMDShuffleSetRight(BinaryenExpressionRef expr,
+                                              BinaryenExpressionRef rightExpr);
+// Gets the 128-bit mask of a SIMD shuffle expression.
 BINARYEN_API void BinaryenSIMDShuffleGetMask(BinaryenExpressionRef expr,
                                              uint8_t* mask);
+// Sets the 128-bit mask of a SIMD shuffle expression.
+BINARYEN_API void BinaryenSIMDShuffleSetMask(BinaryenExpressionRef expr,
+                                             const uint8_t mask[16]);
+
+// SIMDTernary
 
+// Gets the operation being performed by a SIMD ternary expression.
 BINARYEN_API BinaryenOp BinaryenSIMDTernaryGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a SIMD ternary expression.
+BINARYEN_API void BinaryenSIMDTernarySetOp(BinaryenExpressionRef expr,
+                                           BinaryenOp op);
+// Gets the first operand expression of a SIMD ternary expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDTernaryGetA(BinaryenExpressionRef expr);
+// Sets the first operand expression of a SIMD ternary expression.
+BINARYEN_API void BinaryenSIMDTernarySetA(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef aExpr);
+// Gets the second operand expression of a SIMD ternary expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDTernaryGetB(BinaryenExpressionRef expr);
+// Sets the second operand expression of a SIMD ternary expression.
+BINARYEN_API void BinaryenSIMDTernarySetB(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef bExpr);
+// Gets the third operand expression of a SIMD ternary expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDTernaryGetC(BinaryenExpressionRef expr);
+// Sets the third operand expression of a SIMD ternary expression.
+BINARYEN_API void BinaryenSIMDTernarySetC(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef cExpr);
 
+// SIMDShift
+
+// Gets the operation being performed by a SIMD shift expression.
 BINARYEN_API BinaryenOp BinaryenSIMDShiftGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a SIMD shift expression.
+BINARYEN_API void BinaryenSIMDShiftSetOp(BinaryenExpressionRef expr,
+                                         BinaryenOp op);
+// Gets the expression being shifted by a SIMD shift expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDShiftGetVec(BinaryenExpressionRef expr);
+// Sets the expression being shifted by a SIMD shift expression.
+BINARYEN_API void BinaryenSIMDShiftSetVec(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef vecExpr);
+// Gets the expression representing the shift of a SIMD shift expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDShiftGetShift(BinaryenExpressionRef expr);
+// Sets the expression representing the shift of a SIMD shift expression.
+BINARYEN_API void BinaryenSIMDShiftSetShift(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef shiftExpr);
+
+// SIMDLoad
 
+// Gets the operation being performed by a SIMD load expression.
 BINARYEN_API BinaryenOp BinaryenSIMDLoadGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a SIMD load expression.
+BINARYEN_API void BinaryenSIMDLoadSetOp(BinaryenExpressionRef expr,
+                                        BinaryenOp op);
+// Gets the constant offset of a SIMD load expression.
 BINARYEN_API uint32_t BinaryenSIMDLoadGetOffset(BinaryenExpressionRef expr);
+// Sets the constant offset of a SIMD load expression.
+BINARYEN_API void BinaryenSIMDLoadSetOffset(BinaryenExpressionRef expr,
+                                            uint32_t offset);
+// Gets the byte alignment of a SIMD load expression.
 BINARYEN_API uint32_t BinaryenSIMDLoadGetAlign(BinaryenExpressionRef expr);
+// Sets the byte alignment of a SIMD load expression.
+BINARYEN_API void BinaryenSIMDLoadSetAlign(BinaryenExpressionRef expr,
+                                           uint32_t align);
+// Gets the pointer expression of a SIMD load expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenSIMDLoadGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of a SIMD load expression.
+BINARYEN_API void BinaryenSIMDLoadSetPtr(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef ptrExpr);
 
+// MemoryInit
+
+// Gets the index of the segment being initialized by a `memory.init`
+// expression.
 BINARYEN_API uint32_t BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr);
+// Sets the index of the segment being initialized by a `memory.init`
+// expression.
+BINARYEN_API void BinaryenMemoryInitSetSegment(BinaryenExpressionRef expr,
+                                               uint32_t segmentIndex);
+// Gets the destination expression of a `memory.init` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryInitGetDest(BinaryenExpressionRef expr);
+// Sets the destination expression of a `memory.init` expression.
+BINARYEN_API void BinaryenMemoryInitSetDest(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef destExpr);
+// Gets the offset expression of a `memory.init` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryInitGetOffset(BinaryenExpressionRef expr);
+// Sets the offset expression of a `memory.init` expression.
+BINARYEN_API void BinaryenMemoryInitSetOffset(BinaryenExpressionRef expr,
+                                              BinaryenExpressionRef offsetExpr);
+// Gets the size expression of a `memory.init` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryInitGetSize(BinaryenExpressionRef expr);
+// Sets the size expression of a `memory.init` expression.
+BINARYEN_API void BinaryenMemoryInitSetSize(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef sizeExpr);
+
+// DataDrop
 
+// Gets the index of the segment being dropped by a `memory.drop` expression.
 BINARYEN_API uint32_t BinaryenDataDropGetSegment(BinaryenExpressionRef expr);
+// Sets the index of the segment being dropped by a `memory.drop` expression.
+BINARYEN_API void BinaryenDataDropSetSegment(BinaryenExpressionRef expr,
+                                             uint32_t segmentIndex);
 
+// MemoryCopy
+
+// Gets the destination expression of a `memory.copy` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryCopyGetDest(BinaryenExpressionRef expr);
+// Sets the destination expression of a `memory.copy` expression.
+BINARYEN_API void BinaryenMemoryCopySetDest(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef destExpr);
+// Gets the source expression of a `memory.copy` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryCopyGetSource(BinaryenExpressionRef expr);
+// Sets the source expression of a `memory.copy` expression.
+BINARYEN_API void BinaryenMemoryCopySetSource(BinaryenExpressionRef expr,
+                                              BinaryenExpressionRef sourceExpr);
+// Gets the size expression (number of bytes copied) of a `memory.copy`
+// expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryCopyGetSize(BinaryenExpressionRef expr);
+// Sets the size expression (number of bytes copied) of a `memory.copy`
+// expression.
+BINARYEN_API void BinaryenMemoryCopySetSize(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef sizeExpr);
+
+// MemoryFill
 
+// Gets the destination expression of a `memory.fill` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryFillGetDest(BinaryenExpressionRef expr);
+// Sets the destination expression of a `memory.fill` expression.
+BINARYEN_API void BinaryenMemoryFillSetDest(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef destExpr);
+// Gets the value expression of a `memory.fill` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryFillGetValue(BinaryenExpressionRef expr);
+// Sets the value expression of a `memory.fill` expression.
+BINARYEN_API void BinaryenMemoryFillSetValue(BinaryenExpressionRef expr,
+                                             BinaryenExpressionRef valueExpr);
+// Gets the size expression (number of bytes filled) of a `memory.fill`
+// expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenMemoryFillGetSize(BinaryenExpressionRef expr);
+// Sets the size expression (number of bytes filled) of a `memory.fill`
+// expression.
+BINARYEN_API void BinaryenMemoryFillSetSize(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef sizeExpr);
 
+// RefIsNull
+
+// Gets the value expression tested to be null of a `ref.is_null` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenRefIsNullGetValue(BinaryenExpressionRef expr);
+// Sets the value expression tested to be null of a `ref.is_null` expression.
+BINARYEN_API void BinaryenRefIsNullSetValue(BinaryenExpressionRef expr,
+                                            BinaryenExpressionRef valueExpr);
+
+// RefFunc
 
+// Gets the name of the function being wrapped by a `ref.func` expression.
 BINARYEN_API const char* BinaryenRefFuncGetFunc(BinaryenExpressionRef expr);
+// Sets the name of the function being wrapped by a `ref.func` expression.
+BINARYEN_API void BinaryenRefFuncSetFunc(BinaryenExpressionRef expr,
+                                         const char* funcName);
 
+// Try
+
+// Gets the body expression of a `try` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenTryGetBody(BinaryenExpressionRef expr);
+// Sets the body expression of a `try` expression.
+BINARYEN_API void BinaryenTrySetBody(BinaryenExpressionRef expr,
+                                     BinaryenExpressionRef bodyExpr);
+// Gets the catch body expression of a `try` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenTryGetCatchBody(BinaryenExpressionRef expr);
+// Sets the catch body expression of a `try` expression.
+BINARYEN_API void BinaryenTrySetCatchBody(BinaryenExpressionRef expr,
+                                          BinaryenExpressionRef catchBodyExpr);
+
+// Throw
 
+// Gets the name of the event being thrown by a `throw` expression.
 BINARYEN_API const char* BinaryenThrowGetEvent(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenThrowGetOperand(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the name of the event being thrown by a `throw` expression.
+BINARYEN_API void BinaryenThrowSetEvent(BinaryenExpressionRef expr,
+                                        const char* eventName);
+// Gets the number of operands of a `throw` expression.
 BINARYEN_API BinaryenIndex
 BinaryenThrowGetNumOperands(BinaryenExpressionRef expr);
-
+// Gets the operand at the specified index of a `throw` expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenThrowGetOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the operand at the specified index of a `throw` expression.
+BINARYEN_API void BinaryenThrowSetOperandAt(BinaryenExpressionRef expr,
+                                            BinaryenIndex index,
+                                            BinaryenExpressionRef operandExpr);
+// Appends an operand expression to a `throw` expression, returning its
+// insertion index.
+BINARYEN_API BinaryenIndex BinaryenThrowAppendOperand(
+  BinaryenExpressionRef expr, BinaryenExpressionRef operandExpr);
+// Inserts an operand expression at the specified index of a `throw` expression,
+// moving existing operands including the one previously at that index one index
+// up.
+BINARYEN_API void
+BinaryenThrowInsertOperandAt(BinaryenExpressionRef expr,
+                             BinaryenIndex index,
+                             BinaryenExpressionRef operandExpr);
+// Removes the operand expression at the specified index of a `throw`
+// expression, moving all subsequent operands one index down. Returns the
+// operand expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenThrowRemoveOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+
+// Rethrow
+
+// Gets the exception reference expression of a `rethrow` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenRethrowGetExnref(BinaryenExpressionRef expr);
+// Sets the exception reference expression of a `rethrow` expression.
+BINARYEN_API void BinaryenRethrowSetExnref(BinaryenExpressionRef expr,
+                                           BinaryenExpressionRef exnrefExpr);
 
+// BrOnExn
+
+// Gets the name of the event triggering a `br_on_exn` expression.
 BINARYEN_API const char* BinaryenBrOnExnGetEvent(BinaryenExpressionRef expr);
+// Sets the name of the event triggering a `br_on_exn` expression.
+BINARYEN_API void BinaryenBrOnExnSetEvent(BinaryenExpressionRef expr,
+                                          const char* eventName);
+// Gets the name (target label) of a `br_on_exn` expression.
 BINARYEN_API const char* BinaryenBrOnExnGetName(BinaryenExpressionRef expr);
+// Sets the name (target label) of a `br_on_exn` expression.
+BINARYEN_API void BinaryenBrOnExnSetName(BinaryenExpressionRef expr,
+                                         const char* name);
+// Gets the expression reference expression of a `br_on_exn` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenBrOnExnGetExnref(BinaryenExpressionRef expr);
+// Sets the expression reference expression of a `br_on_exn` expression.
+BINARYEN_API void BinaryenBrOnExnSetExnref(BinaryenExpressionRef expr,
+                                           BinaryenExpressionRef exnrefExpr);
 
+// TupleMake
+
+// Gets the number of operands of a `tuple.make` expression.
 BINARYEN_API BinaryenIndex
 BinaryenTupleMakeGetNumOperands(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenTupleMakeGetOperand(BinaryenExpressionRef expr, BinaryenIndex index);
-
+// Gets the operand at the specified index of a `tuple.make` expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenTupleMakeGetOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the operand at the specified index of a `tuple.make` expression.
+BINARYEN_API void
+BinaryenTupleMakeSetOperandAt(BinaryenExpressionRef expr,
+                              BinaryenIndex index,
+                              BinaryenExpressionRef operandExpr);
+// Appends an operand expression to a `tuple.make` expression, returning its
+// insertion index.
+BINARYEN_API BinaryenIndex BinaryenTupleMakeAppendOperand(
+  BinaryenExpressionRef expr, BinaryenExpressionRef operandExpr);
+// Inserts an operand expression at the specified index of a `tuple.make`
+// expression, moving existing operands including the one previously at that
+// index one index up.
+BINARYEN_API void
+BinaryenTupleMakeInsertOperandAt(BinaryenExpressionRef expr,
+                                 BinaryenIndex index,
+                                 BinaryenExpressionRef operandExpr);
+// Removes the operand expression at the specified index of a `tuple.make`
+// expression, moving all subsequent operands one index down. Returns the
+// operand expression.
+BINARYEN_API BinaryenExpressionRef BinaryenTupleMakeRemoveOperandAt(
+  BinaryenExpressionRef expr, BinaryenIndex index);
+
+// TupleExtract
+
+// Gets the tuple extracted from of a `tuple.extract` expression.
 BINARYEN_API BinaryenExpressionRef
 BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr);
+// Sets the tuple extracted from of a `tuple.extract` expression.
+BINARYEN_API void BinaryenTupleExtractSetTuple(BinaryenExpressionRef expr,
+                                               BinaryenExpressionRef tupleExpr);
+// Gets the index extracted at of a `tuple.extract` expression.
 BINARYEN_API BinaryenIndex
 BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr);
+// Sets the index extracted at of a `tuple.extract` expression.
+BINARYEN_API void BinaryenTupleExtractSetIndex(BinaryenExpressionRef expr,
+                                               BinaryenIndex index);
 
 // Functions
 
@@ -1479,6 +2228,9 @@ BINARYEN_API BinaryenType BinaryenFunctionGetVar(BinaryenFunctionRef func,
 // Gets the body of the specified `Function`.
 BINARYEN_API BinaryenExpressionRef
 BinaryenFunctionGetBody(BinaryenFunctionRef func);
+// Sets the body of the specified `Function`.
+BINARYEN_API void BinaryenFunctionSetBody(BinaryenFunctionRef func,
+                                          BinaryenExpressionRef body);
 
 // Runs the standard optimization passes on the function. Uses the currently set
 // global optimize and shrink level.
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 99fb54350..123bf4a1a 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -2534,7 +2534,7 @@ Module['getExpressionInfo'] = function(expr) {
         'id': id,
         'type': type,
         'name': UTF8ToString(Module['_BinaryenBlockGetName'](expr)),
-        'children': getAllNested(expr, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChild'])
+        'children': getAllNested(expr, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt'])
       };
     case Module['IfId']:
       return {
@@ -2563,7 +2563,7 @@ Module['getExpressionInfo'] = function(expr) {
       return {
         'id': id,
         'type': type,
-        'names': getAllNested(expr, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetName']).map(function (p) {
+        'names': getAllNested(expr, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(function (p) {
           // Do not pass the index as the second parameter to UTF8ToString as that will cut off the string.
           return UTF8ToString(p);
         }),
@@ -2577,7 +2577,7 @@ Module['getExpressionInfo'] = function(expr) {
         'type': type,
         'isReturn': Boolean(Module['_BinaryenCallIsReturn'](expr)),
         'target': UTF8ToString(Module['_BinaryenCallGetTarget'](expr)),
-        'operands': getAllNested(expr, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperand'])
+        'operands': getAllNested(expr, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt'])
       };
     case Module['CallIndirectId']:
       return {
@@ -2585,7 +2585,7 @@ Module['getExpressionInfo'] = function(expr) {
         'type': type,
         'isReturn': Boolean(Module['_BinaryenCallIndirectIsReturn'](expr)),
         'target': Module['_BinaryenCallIndirectGetTarget'](expr),
-        'operands': getAllNested(expr, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperand'])
+        'operands': getAllNested(expr, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt'])
       };
     case Module['LocalGetId']:
       return {
@@ -2710,7 +2710,7 @@ Module['getExpressionInfo'] = function(expr) {
         'type': type,
         'op': Module['_BinaryenHostGetOp'](expr),
         'nameOperand': UTF8ToString(Module['_BinaryenHostGetNameOperand'](expr)),
-        'operands': getAllNested(expr, Module['_BinaryenHostGetNumOperands'], Module['_BinaryenHostGetOperand'])
+        'operands': getAllNested(expr, Module['_BinaryenHostGetNumOperands'], Module['_BinaryenHostGetOperandAt'])
       };
     case Module['AtomicRMWId']:
       return {
@@ -2869,7 +2869,7 @@ Module['getExpressionInfo'] = function(expr) {
         'id': id,
         'type': type,
         'event': UTF8ToString(Module['_BinaryenThrowGetEvent'](expr)),
-        'operands': getAllNested(expr, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperand'])
+        'operands': getAllNested(expr, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt'])
       };
     case Module['RethrowId']:
       return {
@@ -2889,7 +2889,7 @@ Module['getExpressionInfo'] = function(expr) {
       return {
         'id': id,
         'type': type,
-        'operands': getAllNested(expr, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperand'])
+        'operands': getAllNested(expr, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt'])
       };
     case Module['TupleExtractId']:
       return {
@@ -3103,6 +3103,1285 @@ Module['setOneCallerInlineMaxSize'] = function(size) {
   Module['_BinaryenSetOneCallerInlineMaxSize'](size);
 };
 
+// Expression wrappers
+
+// Makes a wrapper class with the specified static members while
+// automatically deriving instance methods and accessors.
+function makeExpressionWrapper(ownStaticMembers) {
+  function SpecificExpression(expr) {
+    // can call the constructor without `new`
+    if (!(this instanceof SpecificExpression)) {
+      if (!expr) return null;
+      return new SpecificExpression(expr);
+    }
+    Expression.call(this, expr);
+  }
+  // inherit static members of Expression
+  Object.assign(SpecificExpression, Expression);
+  // add own static members
+  Object.assign(SpecificExpression, ownStaticMembers);
+  // inherit from Expression
+  (SpecificExpression.prototype = Object.create(Expression.prototype)).constructor = SpecificExpression;
+  // make own instance members
+  makeExpressionWrapperInstanceMembers(SpecificExpression.prototype, ownStaticMembers);
+  return SpecificExpression;
+}
+
+// Makes instance members from the given static members
+function makeExpressionWrapperInstanceMembers(prototype, staticMembers) {
+  Object.keys(staticMembers).forEach(function(memberName) {
+    var member = staticMembers[memberName];
+    if (typeof member === "function") {
+      // Instance method calls the respective static method
+      prototype[memberName] = function(/* arguments */) {
+        var numArgs = arguments.length;
+        var args = new Array(1 + numArgs);
+        args[0] = this['expr'];
+        for (var i = 0; i < numArgs; ++i) {
+          args[1 + i] = arguments[i];
+        }
+        return this.constructor[memberName].apply(null, args);
+      };
+      // Instance accessor calls the respective static methods
+      var match;
+      if (member.length === 1 && (match = memberName.match(/^(get|is)/))) {
+        (function(propertyName, getter, setterIfAny) {
+          Object.defineProperty(prototype, propertyName, {
+            get: function() {
+              return getter(this['expr']);
+            },
+            set: function(value) {
+              if (setterIfAny) setterIfAny(this['expr'], value);
+              else throw Error("property '" + propertyName + "' has no setter");
+            }
+          });
+        })(
+          memberName.charAt(match[1].length).toLowerCase() + memberName.substring(match[1].length + 1),
+          staticMembers[memberName],
+          staticMembers["set" + memberName.substring(match[1].length)]
+        );
+      }
+    }
+  });
+}
+
+// Base class of all expression wrappers
+function Expression(expr) {
+  if (!expr) throw Error("expression reference must not be null");
+  this['expr'] = expr;
+}
+Expression['getId'] = function(expr) {
+  return Module['_BinaryenExpressionGetId'](expr);
+};
+Expression['getType'] = function(expr) {
+  return Module['_BinaryenExpressionGetType'](expr);
+};
+Expression['setType'] = function(expr, type) {
+  Module['_BinaryenExpressionSetType'](expr, type);
+};
+Expression['finalize'] = function(expr) {
+  return Module['_BinaryenExpressionFinalize'](expr);
+};
+Expression['toText'] = function(expr) {
+  return Module['emitText'](expr);
+};
+makeExpressionWrapperInstanceMembers(Expression.prototype, Expression);
+Expression.prototype['valueOf'] = function() {
+  return this['expr'];
+};
+
+Module['Expression'] = Expression;
+
+Module['Block'] = makeExpressionWrapper({
+  'getName': function(expr) {
+    var name = Module['_BinaryenBlockGetName'](expr);
+    return name ? UTF8ToString(name) : null;
+  },
+  'setName': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenBlockSetName'](expr, strToStack(name));
+    });
+  },
+  'getNumChildren': function(expr) {
+    return Module['_BinaryenBlockGetNumChildren'](expr);
+  },
+  'getChildren': function(expr) {
+    var numChildren = Module['_BinaryenBlockGetNumChildren'](expr);
+    var children = new Array(numChildren);
+    var index = 0;
+    while (index < numChildren) {
+      children[index] = Module['_BinaryenBlockGetChildAt'](expr, index++);
+    }
+    return children;
+  },
+  'setChildren': function(expr, children) {
+    var numChildren = children.length;
+    var prevNumChildren = Module['_BinaryenBlockGetNumChildren'](expr);
+    var index = 0;
+    while (index < numChildren) {
+      if (index < prevNumChildren) {
+        Module['_BinaryenBlockSetChildAt'](expr, index, children[index]);
+      } else {
+        Module['_BinaryenBlockAppendChild'](expr, children[index]);
+      }
+      ++index;
+    }
+    while (prevNumChildren > index) {
+      Module['_BinaryenBlockRemoveChildAt'](expr, --prevNumChildren);
+    }
+  },
+  'getChildAt': function(expr, index) {
+    return Module['_BinaryenBlockGetChildAt'](expr, index);
+  },
+  'setChildAt': function(expr, index, childExpr) {
+    Module['_BinaryenBlockSetChildAt'](expr, index, childExpr);
+  },
+  'appendChild': function(expr, childExpr) {
+    return Module['_BinaryenBlockAppendChild'](expr, childExpr);
+  },
+  'insertChildAt': function(expr, index, childExpr) {
+    Module['_BinaryenBlockInsertChildAt'](expr, index, childExpr);
+  },
+  'removeChildAt': function(expr, index) {
+    return Module['_BinaryenBlockRemoveChildAt'](expr, index);
+  }
+});
+
+Module['If'] = makeExpressionWrapper({
+  'getCondition': function(expr) {
+    return Module['_BinaryenIfGetCondition'](expr);
+  },
+  'setCondition': function(expr, condExpr) {
+    Module['_BinaryenIfSetCondition'](expr, condExpr);
+  },
+  'getIfTrue': function(expr) {
+    return Module['_BinaryenIfGetIfTrue'](expr);
+  },
+  'setIfTrue': function(expr, ifTrueExpr) {
+    Module['_BinaryenIfSetIfTrue'](expr, ifTrueExpr);
+  },
+  'getIfFalse': function(expr) {
+    return Module['_BinaryenIfGetIfFalse'](expr);
+  },
+  'setIfFalse': function(expr, ifFalseExpr) {
+    Module['_BinaryenIfSetIfFalse'](expr, ifFalseExpr);
+  }
+});
+
+Module['Loop'] = makeExpressionWrapper({
+  'getName': function(expr) {
+    var name = Module['_BinaryenLoopGetName'](expr);
+    return name ? UTF8ToString(name) : null;
+  },
+  'setName': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenLoopSetName'](expr, strToStack(name));
+    });
+  },
+  'getBody': function(expr) {
+    return Module['_BinaryenLoopGetBody'](expr);
+  },
+  'setBody': function(expr, bodyExpr) {
+    Module['_BinaryenLoopSetBody'](expr, bodyExpr);
+  }
+});
+
+Module['Break'] = makeExpressionWrapper({
+  'getName': function(expr) {
+    var name = Module['_BinaryenBreakGetName'](expr);
+    return name ? UTF8ToString(name) : null;
+  },
+  'setName': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenBreakSetName'](expr, strToStack(name));
+    });
+  },
+  'getCondition': function(expr) {
+    return Module['_BinaryenBreakGetCondition'](expr);
+  },
+  'setCondition': function(expr, condExpr) {
+    Module['_BinaryenBreakSetCondition'](expr, condExpr);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenBreakGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenBreakSetValue'](expr, valueExpr);
+  }
+});
+
+Module['Switch'] = makeExpressionWrapper({
+  'getNumNames': function(expr) {
+    return Module['_BinaryenSwitchGetNumNames'](expr);
+  },
+  'getNames': function(expr) {
+    var numNames = Module['_BinaryenSwitchGetNumNames'](expr);
+    var names = new Array(numNames);
+    var index = 0;
+    while (index < numNames) {
+      names[index] = UTF8ToString(Module['_BinaryenSwitchGetNameAt'](expr, index++));
+    }
+    return names;
+  },
+  'setNames': function(expr, names) {
+    var numNames = names.length;
+    var prevNumNames = Module['_BinaryenSwitchGetNumNames'](expr);
+    var index = 0;
+    while (index < numNames) {
+      preserveStack(function() {
+        if (index < prevNumNames) {
+          Module['_BinaryenSwitchSetNameAt'](expr, index, strToStack(names[index]));
+        } else {
+          Module['_BinaryenSwitchAppendName'](expr, strToStack(names[index]));
+        }
+      });
+      ++index;
+    }
+    while (prevNumNames > index) {
+      Module['_BinaryenSwitchRemoveNameAt'](expr, --prevNumNames);
+    }
+  },
+  'getDefaultName': function(expr) {
+    var name = Module['_BinaryenSwitchGetDefaultName'](expr);
+    return name ? UTF8ToString(name) : null;
+  },
+  'setDefaultName': function(expr, defaultName) {
+    preserveStack(function() {
+      Module['_BinaryenSwitchSetDefaultName'](expr, strToStack(defaultName));
+    });
+  },
+  'getCondition': function(expr) {
+    return Module['_BinaryenSwitchGetCondition'](expr);
+  },
+  'setCondition': function(expr, condExpr) {
+    Module['_BinaryenSwitchSetCondition'](expr, condExpr);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenSwitchGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenSwitchSetValue'](expr, valueExpr);
+  },
+  'getNameAt': function(expr, index) {
+    return UTF8ToString(Module['_BinaryenSwitchGetNameAt'](expr, index));
+  },
+  'setNameAt': function(expr, index, name) {
+    preserveStack(function() {
+      Module['_BinaryenSwitchSetNameAt'](expr, index, strToStack(name));
+    });
+  },
+  'appendName': function(expr, name) {
+    preserveStack(function() {
+      return Module['_BinaryenSwitchAppendName'](expr, strToStack(name));
+    });
+  },
+  'insertNameAt': function(expr, index, name) {
+    preserveStack(function() {
+      Module['_BinaryenSwitchInsertNameAt'](expr, index, strToStack(name));
+    });
+  },
+  'removeNameAt': function(expr, index) {
+    return UTF8ToString(Module['_BinaryenSwitchRemoveNameAt'](expr, index));
+  },
+});
+
+Module['Call'] = makeExpressionWrapper({
+  'getTarget': function(expr) {
+    return UTF8ToString(Module['_BinaryenCallGetTarget'](expr));
+  },
+  'setTarget': function(expr, targetName) {
+    preserveStack(function() {
+      Module['_BinaryenCallSetTarget'](expr, strToStack(targetName));
+    });
+  },
+  'getNumOperands': function(expr) {
+    return Module['_BinaryenCallGetNumOperands'](expr);
+  },
+  'getOperands': function(expr) {
+    var numOperands = Module['_BinaryenCallGetNumOperands'](expr);
+    var operands = new Array(numOperands);
+    var index = 0;
+    while (index < numOperands) {
+      operands[index] = Module['_BinaryenCallGetOperandAt'](expr, index++);
+    }
+    return operands;
+  },
+  'setOperands': function(expr, operands) {
+    var numOperands = operands.length;
+    var prevNumOperands = Module['_BinaryenCallGetNumOperands'](expr);
+    var index = 0;
+    while (index < numOperands) {
+      if (index < prevNumOperands) {
+        Module['_BinaryenCallSetOperandAt'](expr, index, operands[index]);
+      } else {
+        Module['_BinaryenCallAppendOperand'](expr, operands[index]);
+      }
+      ++index;
+    }
+    while (prevNumOperands > index) {
+      Module['_BinaryenCallRemoveOperandAt'](expr, --prevNumOperands);
+    }
+  },
+  'getOperandAt': function(expr, index) {
+    return Module['_BinaryenCallGetOperandAt'](expr, index);
+  },
+  'setOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenCallSetOperandAt'](expr, index, operandExpr);
+  },
+  'appendOperand': function(expr, operandExpr) {
+    return Module['_BinaryenCallAppendOperand'](expr, operandExpr);
+  },
+  'insertOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenCallInsertOperandAt'](expr, index, operandExpr);
+  },
+  'removeOperandAt': function(expr, index) {
+    return Module['_BinaryenCallRemoveOperandAt'](expr, index);
+  },
+  'isReturn': function(expr) {
+    return Boolean(Module['_BinaryenCallIsReturn'](expr));
+  },
+  'setReturn': function(expr, isReturn) {
+    Module['_BinaryenCallSetReturn'](expr, isReturn);
+  }
+});
+
+Module['CallIndirect'] = makeExpressionWrapper({
+  'getTarget': function(expr) {
+    return Module['_BinaryenCallIndirectGetTarget'](expr);
+  },
+  'setTarget': function(expr, targetExpr) {
+    Module['_BinaryenCallIndirectSetTarget'](expr, targetExpr);
+  },
+  'getNumOperands': function(expr) {
+    return Module['_BinaryenCallIndirectGetNumOperands'](expr);
+  },
+  'getOperands': function(expr) {
+    var numOperands = Module['_BinaryenCallIndirectGetNumOperands'](expr);
+    var operands = new Array(numOperands);
+    var index = 0;
+    while (index < numOperands) {
+      operands[index] = Module['_BinaryenCallIndirectGetOperandAt'](expr, index++);
+    }
+    return operands;
+  },
+  'setOperands': function(expr, operands) {
+    var numOperands = operands.length;
+    var prevNumOperands = Module['_BinaryenCallIndirectGetNumOperands'](expr);
+    var index = 0;
+    while (index < numOperands) {
+      if (index < prevNumOperands) {
+        Module['_BinaryenCallIndirectSetOperandAt'](expr, index, operands[index]);
+      } else {
+        Module['_BinaryenCallIndirectAppendOperand'](expr, operands[index]);
+      }
+      ++index;
+    }
+    while (prevNumOperands > index) {
+      Module['_BinaryenCallIndirectRemoveOperandAt'](expr, --prevNumOperands);
+    }
+  },
+  'getOperandAt': function(expr, index) {
+    return Module['_BinaryenCallIndirectGetOperandAt'](expr, index);
+  },
+  'setOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenCallIndirectSetOperandAt'](expr, index, operandExpr);
+  },
+  'appendOperand': function(expr, operandExpr) {
+    return Module['_BinaryenCallIndirectAppendOperand'](expr, operandExpr);
+  },
+  'insertOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenCallIndirectInsertOperandAt'](expr, index, operandExpr);
+  },
+  'removeOperandAt': function(expr, index) {
+    return Module['_BinaryenCallIndirectRemoveOperandAt'](expr, index);
+  },
+  'isReturn': function(expr) {
+    return Boolean(Module['_BinaryenCallIndirectIsReturn'](expr));
+  },
+  'setReturn': function(expr, isReturn) {
+    Module['_BinaryenCallIndirectSetReturn'](expr, isReturn);
+  },
+  'getParams': function(expr) {
+    return Module['_BinaryenCallIndirectGetParams'](expr);
+  },
+  'setParams': function(expr, params) {
+    Module['_BinaryenCallIndirectSetParams'](expr, params);
+  },
+  'getResults': function(expr) {
+    return Module['_BinaryenCallIndirectGetResults'](expr);
+  },
+  'setResults': function(expr, results) {
+    Module['_BinaryenCallIndirectSetResults'](expr, results);
+  }
+});
+
+Module['LocalGet'] = makeExpressionWrapper({
+  'getIndex': function(expr) {
+    return Module['_BinaryenLocalGetGetIndex'](expr);
+  },
+  'setIndex': function(expr, index) {
+    Module['_BinaryenLocalGetSetIndex'](expr, index);
+  }
+});
+
+Module['LocalSet'] = makeExpressionWrapper({
+  'getIndex': function(expr) {
+    return Module['_BinaryenLocalSetGetIndex'](expr);
+  },
+  'setIndex': function(expr, index) {
+    Module['_BinaryenLocalSetSetIndex'](expr, index);
+  },
+  'isTee': function(expr) {
+    return Boolean(Module['_BinaryenLocalSetIsTee'](expr));
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenLocalSetGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenLocalSetSetValue'](expr, valueExpr);
+  }
+});
+
+Module['GlobalGet'] = makeExpressionWrapper({
+  'getName': function(expr) {
+    return UTF8ToString(Module['_BinaryenGlobalGetGetName'](expr));
+  },
+  'setName': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenGlobalGetSetName'](expr, strToStack(name));
+    });
+  }
+});
+
+Module['GlobalSet'] = makeExpressionWrapper({
+  'getName': function(expr) {
+    return UTF8ToString(Module['_BinaryenGlobalSetGetName'](expr));
+  },
+  'setName': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenGlobalSetSetName'](expr, strToStack(name));
+    });
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenGlobalSetGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenGlobalSetSetValue'](expr, valueExpr);
+  }
+});
+
+Module['Host'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenHostGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenHostSetOp'](expr, op);
+  },
+  'getNameOperand': function(expr) {
+    var name = Module['_BinaryenHostGetNameOperand'](expr);
+    return name ? UTF8ToString(name) : null;
+  },
+  'setNameOperand': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenHostSetNameOperand'](expr, strToStack(name));
+    });
+  },
+  'getNumOperands': function(expr) {
+    return Module['_BinaryenHostGetNumOperands'](expr);
+  },
+  'getOperands': function(expr) {
+    var numOperands = Module['_BinaryenHostGetNumOperands'](expr);
+    var operands = new Array(numOperands);
+    var index = 0;
+    while (index < numOperands) {
+      operands[index] = Module['_BinaryenHostGetOperandAt'](expr, index++);
+    }
+    return operands;
+  },
+  'setOperands': function(expr, operands) {
+    var numOperands = operands.length;
+    var prevNumOperands = Module['_BinaryenHostGetNumOperands'](expr);
+    var index = 0;
+    while (index < numOperands) {
+      if (index < prevNumOperands) {
+        Module['_BinaryenHostSetOperandAt'](expr, index, operands[index]);
+      } else {
+        Module['_BinaryenHostAppendOperand'](expr, operands[index]);
+      }
+      ++index;
+    }
+    while (prevNumOperands > index) {
+      Module['_BinaryenHostRemoveOperandAt'](expr, --prevNumOperands);
+    }
+  },
+  'getOperandAt': function(expr, index) {
+    return Module['_BinaryenHostGetOperandAt'](expr, index);
+  },
+  'setOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenHostSetOperandAt'](expr, index, operandExpr);
+  },
+  'appendOperand': function(expr, operandExpr) {
+    return Module['_BinaryenHostAppendOperand'](expr, operandExpr);
+  },
+  'insertOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenHostInsertOperandAt'](expr, index, operandExpr);
+  },
+  'removeOperandAt': function(expr, index) {
+    return Module['_BinaryenHostRemoveOperandAt'](expr, index);
+  },
+});
+
+Module['Load'] = makeExpressionWrapper({
+  'isAtomic': function(expr) {
+    return Boolean(Module['_BinaryenLoadIsAtomic'](expr));
+  },
+  'setAtomic': function(expr, isAtomic) {
+    Module['_BinaryenLoadSetAtomic'](expr, isAtomic);
+  },
+  'isSigned': function(expr) {
+    return Boolean(Module['_BinaryenLoadIsSigned'](expr));
+  },
+  'setSigned': function(expr, isSigned) {
+    Module['_BinaryenLoadSetSigned'](expr, isSigned);
+  },
+  'getOffset': function(expr) {
+    return Module['_BinaryenLoadGetOffset'](expr);
+  },
+  'setOffset': function(expr, offset) {
+    Module['_BinaryenLoadSetOffset'](expr, offset);
+  },
+  'getBytes': function(expr) {
+    return Module['_BinaryenLoadGetBytes'](expr);
+  },
+  'setBytes': function(expr, bytes) {
+    Module['_BinaryenLoadSetBytes'](expr, bytes);
+  },
+  'getAlign': function(expr) {
+    return Module['_BinaryenLoadGetAlign'](expr);
+  },
+  'setAlign': function(expr, align) {
+    Module['_BinaryenLoadSetAlign'](expr, align);
+  },
+  'getPtr': function(expr) {
+    return Module['_BinaryenLoadGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenLoadSetPtr'](expr, ptrExpr);
+  }
+});
+
+Module['Store'] = makeExpressionWrapper({
+  'isAtomic': function(expr) {
+    return Boolean(Module['_BinaryenStoreIsAtomic'](expr));
+  },
+  'setAtomic': function(expr, isAtomic) {
+    Module['_BinaryenStoreSetAtomic'](expr, isAtomic);
+  },
+  'getBytes': function(expr) {
+    return Module['_BinaryenStoreGetBytes'](expr);
+  },
+  'setBytes': function(expr, bytes) {
+    Module['_BinaryenStoreSetBytes'](expr, bytes);
+  },
+  'getOffset': function(expr) {
+    return Module['_BinaryenStoreGetOffset'](expr);
+  },
+  'setOffset': function(expr, offset) {
+    Module['_BinaryenStoreSetOffset'](expr, offset);
+  },
+  'getAlign': function(expr) {
+    return Module['_BinaryenStoreGetAlign'](expr);
+  },
+  'setAlign': function(expr, align) {
+    Module['_BinaryenStoreSetAlign'](expr, align);
+  },
+  'getPtr': function(expr) {
+    return Module['_BinaryenStoreGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenStoreSetPtr'](expr, ptrExpr);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenStoreGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenStoreSetValue'](expr, valueExpr);
+  },
+  'getValueType': function(expr) {
+    return Module['_BinaryenStoreGetValueType'](expr);
+  },
+  'setValueType': function(expr, valueType) {
+    Module['_BinaryenStoreSetValueType'](expr, valueType);
+  }
+});
+
+Module['Const'] = makeExpressionWrapper({
+  'getValueI32': function(expr) {
+    return Module['_BinaryenConstGetValueI32'](expr);
+  },
+  'setValueI32': function(expr, value) {
+    Module['_BinaryenConstSetValueI32'](expr, value);
+  },
+  'getValueI64Low': function(expr) {
+    return Module['_BinaryenConstGetValueI64Low'](expr);
+  },
+  'setValueI64Low': function(expr, value) {
+    Module['_BinaryenConstSetValueI64Low'](expr, value);
+  },
+  'getValueI64High': function(expr) {
+    return Module['_BinaryenConstGetValueI64High'](expr);
+  },
+  'setValueI64High': function(expr, value) {
+    Module['_BinaryenConstSetValueI64High'](expr, value);
+  },
+  'getValueF32': function(expr) {
+    return Module['_BinaryenConstGetValueF32'](expr);
+  },
+  'setValueF32': function(expr, value) {
+    Module['_BinaryenConstSetValueF32'](expr, value);
+  },
+  'getValueF64': function(expr) {
+    return Module['_BinaryenConstGetValueF64'](expr);
+  },
+  'setValueF64': function(expr, value) {
+    Module['_BinaryenConstSetValueF64'](expr, value);
+  },
+  'getValueV128': function(expr) {
+    var value;
+    preserveStack(function() {
+      var tempBuffer = stackAlloc(16);
+      Module['_BinaryenConstGetValueV128'](expr, tempBuffer);
+      value = new Array(16);
+      for (var i = 0 ; i < 16; ++i) {
+        value[i] = HEAPU8[tempBuffer + i];
+      }
+    });
+    return value;
+  },
+  'setValueV128': function(expr, value) {
+    preserveStack(function() {
+      var tempBuffer = stackAlloc(16);
+      for (var i = 0 ; i < 16; ++i) {
+        HEAPU8[tempBuffer + i] = value[i];
+      }
+      Module['_BinaryenConstSetValueV128'](expr, tempBuffer);
+    });
+  }
+});
+
+Module['Unary'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenUnaryGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenUnarySetOp'](expr, op);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenUnaryGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenUnarySetValue'](expr, valueExpr);
+  }
+});
+
+Module['Binary'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenBinaryGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenBinarySetOp'](expr, op);
+  },
+  'getLeft': function(expr) {
+    return Module['_BinaryenBinaryGetLeft'](expr);
+  },
+  'setLeft': function(expr, leftExpr) {
+    Module['_BinaryenBinarySetLeft'](expr, leftExpr);
+  },
+  'getRight': function(expr) {
+    return Module['_BinaryenBinaryGetRight'](expr);
+  },
+  'setRight': function(expr, rightExpr) {
+    Module['_BinaryenBinarySetRight'](expr, rightExpr);
+  }
+});
+
+Module['Select'] = makeExpressionWrapper({
+  'getIfTrue': function(expr) {
+    return Module['_BinaryenSelectGetIfTrue'](expr);
+  },
+  'setIfTrue': function(expr, ifTrueExpr) {
+    Module['_BinaryenSelectSetIfTrue'](expr, ifTrueExpr);
+  },
+  'getIfFalse': function(expr) {
+    return Module['_BinaryenSelectGetIfFalse'](expr);
+  },
+  'setIfFalse': function(expr, ifFalseExpr) {
+    Module['_BinaryenSelectSetIfFalse'](expr, ifFalseExpr);
+  },
+  'getCondition': function(expr) {
+    return Module['_BinaryenSelectGetCondition'](expr);
+  },
+  'setCondition': function(expr, condExpr) {
+    Module['_BinaryenSelectSetCondition'](expr, condExpr);
+  }
+});
+
+Module['Drop'] = makeExpressionWrapper({
+  'getValue': function(expr) {
+    return Module['_BinaryenDropGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenDropSetValue'](expr, valueExpr);
+  }
+});
+
+Module['Return'] = makeExpressionWrapper({
+  'getValue': function(expr) {
+    return Module['_BinaryenReturnGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenReturnSetValue'](expr, valueExpr);
+  }
+});
+
+Module['AtomicRMW'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenAtomicRMWGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenAtomicRMWSetOp'](expr, op);
+  },
+  'getBytes': function(expr) {
+    return Module['_BinaryenAtomicRMWGetBytes'](expr);
+  },
+  'setBytes': function(expr, bytes) {
+    Module['_BinaryenAtomicRMWSetBytes'](expr, bytes);
+  },
+  'getOffset': function(expr) {
+    return Module['_BinaryenAtomicRMWGetOffset'](expr);
+  },
+  'setOffset': function(expr, offset) {
+    Module['_BinaryenAtomicRMWSetOffset'](expr, offset);
+  },
+  'getPtr': function(expr) {
+    return Module['_BinaryenAtomicRMWGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenAtomicRMWSetPtr'](expr, ptrExpr);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenAtomicRMWGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenAtomicRMWSetValue'](expr, valueExpr);
+  }
+});
+
+Module['AtomicCmpxchg'] = makeExpressionWrapper({
+  'getBytes': function(expr) {
+    return Module['_BinaryenAtomicCmpxchgGetBytes'](expr);
+  },
+  'setBytes': function(expr, bytes) {
+    Module['_BinaryenAtomicCmpxchgSetBytes'](expr, bytes);
+  },
+  'getOffset': function(expr) {
+    return Module['_BinaryenAtomicCmpxchgGetOffset'](expr);
+  },
+  'setOffset': function(expr, offset) {
+    Module['_BinaryenAtomicCmpxchgSetOffset'](expr, offset);
+  },
+  'getPtr': function(expr) {
+    return Module['_BinaryenAtomicCmpxchgGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenAtomicCmpxchgSetPtr'](expr, ptrExpr);
+  },
+  'getExpected': function(expr) {
+    return Module['_BinaryenAtomicCmpxchgGetExpected'](expr);
+  },
+  'setExpected': function(expr, expectedExpr) {
+    Module['_BinaryenAtomicCmpxchgSetExpected'](expr, expectedExpr);
+  },
+  'getReplacement': function(expr) {
+    return Module['_BinaryenAtomicCmpxchgGetReplacement'](expr);
+  },
+  'setReplacement': function(expr, replacementExpr) {
+    Module['_BinaryenAtomicCmpxchgSetReplacement'](expr, replacementExpr);
+  }
+});
+
+Module['AtomicWait'] = makeExpressionWrapper({
+  'getPtr': function(expr) {
+    return Module['_BinaryenAtomicWaitGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenAtomicWaitSetPtr'](expr, ptrExpr);
+  },
+  'getExpected': function(expr) {
+    return Module['_BinaryenAtomicWaitGetExpected'](expr);
+  },
+  'setExpected': function(expr, expectedExpr) {
+    Module['_BinaryenAtomicWaitSetExpected'](expr, expectedExpr);
+  },
+  'getTimeout': function(expr) {
+    return Module['_BinaryenAtomicWaitGetTimeout'](expr);
+  },
+  'setTimeout': function(expr, timeoutExpr) {
+    Module['_BinaryenAtomicWaitSetTimeout'](expr, timeoutExpr);
+  },
+  'getExpectedType': function(expr) {
+    return Module['_BinaryenAtomicWaitGetExpectedType'](expr);
+  },
+  'setExpectedType': function(expr, expectedType) {
+    Module['_BinaryenAtomicWaitSetExpectedType'](expr, expectedType);
+  }
+});
+
+Module['AtomicNotify'] = makeExpressionWrapper({
+  'getPtr': function(expr) {
+    return Module['_BinaryenAtomicNotifyGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenAtomicNotifySetPtr'](expr, ptrExpr);
+  },
+  'getNotifyCount': function(expr) {
+    return Module['_BinaryenAtomicNotifyGetNotifyCount'](expr);
+  },
+  'setNotifyCount': function(expr, notifyCountExpr) {
+    Module['_BinaryenAtomicNotifySetNotifyCount'](expr, notifyCountExpr);
+  }
+});
+
+Module['AtomicFence'] = makeExpressionWrapper({
+  'getOrder': function(expr) {
+    return Module['_BinaryenAtomicFenceGetOrder'](expr);
+  },
+  'setOrder': function(expr, order) {
+    Module['_BinaryenAtomicFenceSetOrder'](expr, order);
+  }
+});
+
+Module['SIMDExtract'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenSIMDExtractGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenSIMDExtractSetOp'](expr, op);
+  },
+  'getVec': function(expr) {
+    return Module['_BinaryenSIMDExtractGetVec'](expr);
+  },
+  'setVec': function(expr, vecExpr) {
+    Module['_BinaryenSIMDExtractSetVec'](expr, vecExpr);
+  },
+  'getIndex': function(expr) {
+    return Module['_BinaryenSIMDExtractGetIndex'](expr);
+  },
+  'setIndex': function(expr, index) {
+    Module['_BinaryenSIMDExtractSetIndex'](expr, index)
+  }
+});
+
+Module['SIMDReplace'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenSIMDReplaceGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenSIMDReplaceSetOp'](expr, op);
+  },
+  'getVec': function(expr) {
+    return Module['_BinaryenSIMDReplaceGetVec'](expr);
+  },
+  'setVec': function(expr, vecExpr) {
+    Module['_BinaryenSIMDReplaceSetVec'](expr, vecExpr);
+  },
+  'getIndex': function(expr) {
+    return Module['_BinaryenSIMDReplaceGetIndex'](expr);
+  },
+  'setIndex': function(expr, index) {
+    Module['_BinaryenSIMDReplaceSetIndex'](expr, index);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenSIMDReplaceGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenSIMDReplaceSetValue'](expr, valueExpr);
+  }
+});
+
+Module['SIMDShuffle'] = makeExpressionWrapper({
+  'getLeft': function(expr) {
+    return Module['_BinaryenSIMDShuffleGetLeft'](expr);
+  },
+  'setLeft': function(expr, leftExpr) {
+    Module['_BinaryenSIMDShuffleSetLeft'](expr, leftExpr)
+  },
+  'getRight': function(expr) {
+    return Module['_BinaryenSIMDShuffleGetRight'](expr);
+  },
+  'setRight': function(expr, rightExpr) {
+    Module['_BinaryenSIMDShuffleSetRight'](expr, rightExpr);
+  },
+  'getMask': function(expr) {
+    var mask;
+    preserveStack(function() {
+      var tempBuffer = stackAlloc(16);
+      Module['_BinaryenSIMDShuffleGetMask'](expr, tempBuffer);
+      mask = new Array(16);
+      for (var i = 0 ; i < 16; ++i) {
+        mask[i] = HEAPU8[tempBuffer + i];
+      }
+    });
+    return mask;
+  },
+  'setMask': function(expr, mask) {
+    preserveStack(function() {
+      var tempBuffer = stackAlloc(16);
+      for (var i = 0 ; i < 16; ++i) {
+        HEAPU8[tempBuffer + i] = mask[i];
+      }
+      Module['_BinaryenSIMDShuffleSetMask'](expr, tempBuffer);
+    });
+  }
+});
+
+Module['SIMDTernary'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenSIMDTernaryGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenSIMDTernarySetOp'](expr, op);
+  },
+  'getA': function(expr) {
+    return Module['_BinaryenSIMDTernaryGetA'](expr);
+  },
+  'setA': function(expr, aExpr) {
+    Module['_BinaryenSIMDTernarySetA'](expr, aExpr);
+  },
+  'getB': function(expr) {
+    return Module['_BinaryenSIMDTernaryGetB'](expr);
+  },
+  'setB': function(expr, bExpr) {
+    Module['_BinaryenSIMDTernarySetB'](expr, bExpr);
+  },
+  'getC': function(expr) {
+    return Module['_BinaryenSIMDTernaryGetC'](expr);
+  },
+  'setC': function(expr, cExpr) {
+    Module['_BinaryenSIMDTernarySetC'](expr, cExpr);
+  }
+});
+
+Module['SIMDShift'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenSIMDShiftGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenSIMDShiftSetOp'](expr, op);
+  },
+  'getVec': function(expr) {
+    return Module['_BinaryenSIMDShiftGetVec'](expr);
+  },
+  'setVec': function(expr, vecExpr) {
+    Module['_BinaryenSIMDShiftSetVec'](expr, vecExpr);
+  },
+  'getShift': function(expr) {
+    return Module['_BinaryenSIMDShiftGetShift'](expr);
+  },
+  'setShift': function(expr, shiftExpr) {
+    Module['_BinaryenSIMDShiftSetShift'](expr, shiftExpr);
+  }
+});
+
+Module['SIMDLoad'] = makeExpressionWrapper({
+  'getOp': function(expr) {
+    return Module['_BinaryenSIMDLoadGetOp'](expr);
+  },
+  'setOp': function(expr, op) {
+    Module['_BinaryenSIMDLoadSetOp'](expr, op);
+  },
+  'getOffset': function(expr) {
+    return Module['_BinaryenSIMDLoadGetOffset'](expr);
+  },
+  'setOffset': function(expr, offset) {
+    Module['_BinaryenSIMDLoadSetOffset'](expr, offset);
+  },
+  'getAlign': function(expr) {
+    return Module['_BinaryenSIMDLoadGetAlign'](expr);
+  },
+  'setAlign': function(expr, align) {
+    Module['_BinaryenSIMDLoadSetAlign'](expr, align);
+  },
+  'getPtr': function(expr) {
+    return Module['_BinaryenSIMDLoadGetPtr'](expr);
+  },
+  'setPtr': function(expr, ptrExpr) {
+    Module['_BinaryenSIMDLoadSetPtr'](expr, ptrExpr);
+  }
+});
+
+Module['MemoryInit'] = makeExpressionWrapper({
+  'getSegment': function(expr) {
+    return Module['_BinaryenMemoryInitGetSegment'](expr);
+  },
+  'setSegment': function(expr, segmentIndex) {
+    Module['_BinaryenMemoryInitSetSegment'](expr, segmentIndex);
+  },
+  'getDest': function(expr) {
+    return Module['_BinaryenMemoryInitGetDest'](expr);
+  },
+  'setDest': function(expr, destExpr) {
+    Module['_BinaryenMemoryInitSetDest'](expr, destExpr);
+  },
+  'getOffset': function(expr) {
+    return Module['_BinaryenMemoryInitGetOffset'](expr);
+  },
+  'setOffset': function(expr, offset) {
+    Module['_BinaryenMemoryInitSetOffset'](expr, offset);
+  },
+  'getSize': function(expr) {
+    return Module['_BinaryenMemoryInitGetSize'](expr);
+  },
+  'setSize': function(expr, sizeExpr) {
+    Module['_BinaryenMemoryInitSetSize'](expr, sizeExpr);
+  }
+});
+
+Module['DataDrop'] = makeExpressionWrapper({
+  'getSegment': function(expr) {
+    return Module['_BinaryenDataDropGetSegment'](expr);
+  },
+  'setSegment': function(expr, segmentIndex) {
+    Module['_BinaryenDataDropSetSegment'](expr, segmentIndex);
+  }
+});
+
+Module['MemoryCopy'] = makeExpressionWrapper({
+  'getDest': function(expr) {
+    return Module['_BinaryenMemoryCopyGetDest'](expr);
+  },
+  'setDest': function(expr, destExpr) {
+    Module['_BinaryenMemoryCopySetDest'](expr, destExpr);
+  },
+  'getSource': function(expr) {
+    return Module['_BinaryenMemoryCopyGetSource'](expr);
+  },
+  'setSource': function(expr, sourceExpr) {
+    Module['_BinaryenMemoryCopySetSource'](expr, sourceExpr);
+  },
+  'getSize': function(expr) {
+    return Module['_BinaryenMemoryCopyGetSize'](expr);
+  },
+  'setSize': function(expr, sizeExpr) {
+    Module['_BinaryenMemoryCopySetSize'](expr, sizeExpr);
+  }
+});
+
+Module['MemoryFill'] = makeExpressionWrapper({
+  'getDest': function(expr) {
+    return Module['_BinaryenMemoryFillGetDest'](expr);
+  },
+  'setDest': function(expr, destExpr) {
+    Module['_BinaryenMemoryFillSetDest'](expr, destExpr);
+  },
+  'getValue': function(expr) {
+    return Module['_BinaryenMemoryFillGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenMemoryFillSetValue'](expr, valueExpr);
+  },
+  'getSize': function(expr) {
+    return Module['_BinaryenMemoryFillGetSize'](expr);
+  },
+  'setSize': function(expr, sizeExpr) {
+    Module['_BinaryenMemoryFillSetSize'](expr, sizeExpr);
+  }
+});
+
+Module['RefIsNull'] = makeExpressionWrapper({
+  'getValue': function(expr) {
+    return Module['_BinaryenRefIsNullGetValue'](expr);
+  },
+  'setValue': function(expr, valueExpr) {
+    Module['_BinaryenRefIsNullSetValue'](expr, valueExpr);
+  }
+});
+
+Module['RefFunc'] = makeExpressionWrapper({
+  'getFunc': function(expr) {
+    return UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expr));
+  },
+  'setFunc': function(expr, funcName) {
+    preserveStack(function() {
+      Module['_BinaryenRefFuncSetFunc'](expr, strToStack(funcName));
+    });
+  }
+});
+
+Module['Try'] = makeExpressionWrapper({
+  'getBody': function(expr) {
+    return Module['_BinaryenTryGetBody'](expr);
+  },
+  'setBody': function(expr, bodyExpr) {
+    Module['_BinaryenTrySetBody'](expr, bodyExpr);
+  },
+  'getCatchBody': function(expr) {
+    return Module['_BinaryenTryGetCatchBody'](expr);
+  },
+  'setCatchBody': function(expr, catchBodyExpr) {
+    Module['_BinaryenTrySetCatchBody'](expr, catchBodyExpr);
+  }
+});
+
+Module['Throw'] = makeExpressionWrapper({
+  'getEvent': function(expr) {
+    return UTF8ToString(Module['_BinaryenThrowGetEvent'](expr));
+  },
+  'setEvent': function(expr, eventName) {
+    preserveStack(function() {
+      Module['_BinaryenThrowSetEvent'](expr, strToStack(eventName));
+    });
+  },
+  'getNumOperands': function(expr) {
+    return Module['_BinaryenThrowGetNumOperands'](expr);
+  },
+  'getOperands': function(expr) {
+    var numOperands = Module['_BinaryenThrowGetNumOperands'](expr);
+    var operands = new Array(numOperands);
+    var index = 0;
+    while (index < numOperands) {
+      operands[index] = Module['_BinaryenThrowGetOperandAt'](expr, index++);
+    }
+    return operands;
+  },
+  'setOperands': function(expr, operands) {
+    var numOperands = operands.length;
+    var prevNumOperands = Module['_BinaryenThrowGetNumOperands'](expr);
+    var index = 0;
+    while (index < numOperands) {
+      if (index < prevNumOperands) {
+        Module['_BinaryenThrowSetOperandAt'](expr, index, operands[index]);
+      } else {
+        Module['_BinaryenThrowAppendOperand'](expr, operands[index]);
+      }
+      ++index;
+    }
+    while (prevNumOperands > index) {
+      Module['_BinaryenThrowRemoveOperandAt'](expr, --prevNumOperands);
+    }
+  },
+  'getOperandAt': function(expr, index) {
+    return Module['_BinaryenThrowGetOperandAt'](expr, index);
+  },
+  'setOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenThrowSetOperandAt'](expr, index, operandExpr);
+  },
+  'appendOperand': function(expr, operandExpr) {
+    return Module['_BinaryenThrowAppendOperand'](expr, operandExpr);
+  },
+  'insertOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenThrowInsertOperandAt'](expr, index, operandExpr);
+  },
+  'removeOperandAt': function(expr, index) {
+    return Module['_BinaryenThrowRemoveOperandAt'](expr, index);
+  },
+});
+
+Module['Rethrow'] = makeExpressionWrapper({
+  'getExnref': function(expr) {
+    return Module['_BinaryenRethrowGetExnref'](expr);
+  },
+  'setExnref': function(expr, exnrefExpr) {
+    Module['_BinaryenRethrowSetExnref'](expr, exnrefExpr);
+  }
+});
+
+Module['BrOnExn'] = makeExpressionWrapper({
+  'getEvent': function(expr) {
+    return UTF8ToString(Module['_BinaryenBrOnExnGetEvent'](expr));
+  },
+  'setEvent': function(expr, eventName) {
+    preserveStack(function() {
+      Module['_BinaryenBrOnExnSetEvent'](expr, strToStack(eventName));
+    });
+  },
+  'getName': function(expr) {
+    return UTF8ToString(Module['_BinaryenBrOnExnGetName'](expr));
+  },
+  'setName': function(expr, name) {
+    preserveStack(function() {
+      Module['_BinaryenBrOnExnSetName'](expr, strToStack(name));
+    });
+  },
+  'getExnref': function(expr) {
+    return Module['_BinaryenBrOnExnGetExnref'](expr);
+  },
+  'setExnref': function(expr, exnrefExpr) {
+    Module['_BinaryenBrOnExnSetExnref'](expr, exnrefExpr);
+  }
+});
+
+Module['TupleMake'] = makeExpressionWrapper({
+  'getNumOperands': function(expr) {
+    return Module['_BinaryenTupleMakeGetNumOperands'](expr);
+  },
+  'getOperands': function(expr) {
+    var numOperands = Module['_BinaryenTupleMakeGetNumOperands'](expr);
+    var operands = new Array(numOperands);
+    var index = 0;
+    while (index < numOperands) {
+      operands[index] = Module['_BinaryenTupleMakeGetOperandAt'](expr, index++);
+    }
+    return operands;
+  },
+  'setOperands': function(expr, operands) {
+    var numOperands = operands.length;
+    var prevNumOperands = Module['_BinaryenTupleMakeGetNumOperands'](expr);
+    var index = 0;
+    while (index < numOperands) {
+      if (index < prevNumOperands) {
+        Module['_BinaryenTupleMakeSetOperandAt'](expr, index, operands[index]);
+      } else {
+        Module['_BinaryenTupleMakeAppendOperand'](expr, operands[index]);
+      }
+      ++index;
+    }
+    while (prevNumOperands > index) {
+      Module['_BinaryenTupleMakeRemoveOperandAt'](expr, --prevNumOperands);
+    }
+  },
+  'getOperandAt': function(expr, index) {
+    return Module['_BinaryenTupleMakeGetOperandAt'](expr, index);
+  },
+  'setOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenTupleMakeSetOperandAt'](expr, index, operandExpr);
+  },
+  'appendOperand': function(expr, operandExpr) {
+    return Module['_BinaryenTupleMakeAppendOperand'](expr, operandExpr);
+  },
+  'insertOperandAt': function(expr, index, operandExpr) {
+    Module['_BinaryenTupleMakeInsertOperandAt'](expr, index, operandExpr);
+  },
+  'removeOperandAt': function(expr, index) {
+    return Module['_BinaryenTupleMakeRemoveOperandAt'](expr, index);
+  }
+});
+
+Module['TupleExtract'] = makeExpressionWrapper({
+  'getTuple': function(expr) {
+    return Module['_BinaryenTupleExtractGetTuple'](expr);
+  },
+  'setTuple': function(expr, tupleExpr) {
+    Module['_BinaryenTupleExtractSetTuple'](expr, tupleExpr);
+  },
+  'getIndex': function(expr) {
+    return Module['_BinaryenTupleExtractGetIndex'](expr);
+  },
+  'setIndex': function(expr, index) {
+    Module['_BinaryenTupleExtractSetIndex'](expr, index);
+  }
+});
+
 // Additional customizations
 
 Module['exit'] = function(status) {
diff --git a/src/mixed_arena.h b/src/mixed_arena.h
index 079ce9028..9ae19f94d 100644
--- a/src/mixed_arena.h
+++ b/src/mixed_arena.h
@@ -364,6 +364,27 @@ public:
   void allocate(size_t size) {
     abort(); // must be implemented in children
   }
+
+  // C-API
+
+  void insertAt(size_t index, T item) {
+    assert(index <= usedElements); // appending is ok
+    resize(usedElements + 1);
+    for (auto i = usedElements; i > index; --i) {
+      data[i] = data[i - 1];
+    }
+    data[index] = item;
+  }
+
+  T removeAt(size_t index) {
+    assert(index < usedElements);
+    auto item = data[index];
+    for (auto i = index; i < usedElements - 1; ++i) {
+      data[i] = data[i + 1];
+    }
+    resize(usedElements - 1);
+    return item;
+  }
 };
 
 // A vector that has an allocator for arena allocation
diff --git a/src/wasm.h b/src/wasm.h
index b52e7539b..fafb03d41 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -862,6 +862,8 @@ public:
   // other orderings may be added in the future. This field is reserved for
   // that, and currently set to 0.
   uint8_t order = 0;
+
+  void finalize();
 };
 
 class SIMDExtract : public SpecificExpression<Expression::SIMDExtractId> {
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index f1d51bbca..adaa81838 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -522,6 +522,8 @@ void AtomicNotify::finalize() {
   }
 }
 
+void AtomicFence::finalize() { type = Type::none; }
+
 void SIMDExtract::finalize() {
   assert(vec);
   switch (op) {