Add C/JS APIs to copy expressions

src/binaryen-c.cpp

@@ -1962,6 +1962,19 @@ void BinaryenExpressionPrint(BinaryenExpressionRef expr) {
   std::cout << '\n';
 }
 
+BinaryenExpressionRef BinaryenExpressionCopy(BinaryenExpressionRef expr,
+                                             BinaryenModuleRef module) {
+  auto* wasm = (Module*)module;
+  auto* ret = ExpressionManipulator::copy(expr, *wasm);
+  if (tracing) {
+    auto id = noteExpression(ret);
+    std::cout << "  expressions[" << id
+              << "] = BinaryenExpressionCopy(expressions[" << expressions[expr]
+              << "], theModule);\n";
+  }
+  return ret;
+}
+
 // Specific expression utility
 
 // Block

src/binaryen-c.h

@@ -848,6 +848,8 @@ BINARYEN_API BinaryenExpressionId
 BinaryenExpressionGetId(BinaryenExpressionRef expr);
 BINARYEN_API BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr);
 BINARYEN_API void BinaryenExpressionPrint(BinaryenExpressionRef expr);
+BINARYEN_API BinaryenExpressionRef
+BinaryenExpressionCopy(BinaryenExpressionRef expr, BinaryenModuleRef module);
 
 BINARYEN_API const char* BinaryenBlockGetName(BinaryenExpressionRef expr);
 BINARYEN_API BinaryenIndex

src/js/binaryen.js-post.js

@@ -2407,6 +2407,9 @@ function wrapModule(module, self) {
   self['setDebugLocation'] = function(func, expr, fileIndex, lineNumber, columnNumber) {
     return Module['_BinaryenFunctionSetDebugLocation'](func, expr, fileIndex, lineNumber, columnNumber);
   };
+  self['copyExpression'] = function(expr) {
+    return Module['_BinaryenExpressionCopy'](expr, module);
+  };
 
   return self;
 }

test/binaryen.js/copy-expression.js

@@ -0,0 +1,28 @@
+binaryen.setAPITracing(true);
+
+var module = new binaryen.Module();
+
+// Create an expression and copy it
+var original = module.block(null, [
+  module.if(
+    module.local.get(0, binaryen.i32),
+    module.i32.const(1),
+    module.i32.const(2)
+  )
+], binaryen.i32);
+var copy = module.copyExpression(original);
+
+// Check that the expression incl. sub-expressions are copies
+assert(original !== copy);
+var originalIf = binaryen._BinaryenBlockGetChild(original, 0);
+var copyIf = binaryen._BinaryenBlockGetChild(copy, 0);
+assert(originalIf !== copyIf);
+assert(binaryen._BinaryenIfGetCondition(originalIf) !== binaryen._BinaryenIfGetCondition(copyIf));
+assert(binaryen._BinaryenIfGetIfTrue(originalIf) !== binaryen._BinaryenIfGetIfTrue(copyIf));
+assert(binaryen._BinaryenIfGetIfFalse(originalIf) !== binaryen._BinaryenIfGetIfFalse(copyIf));
+
+binaryen.setAPITracing(false);
+
+// Check that both are otherwise identical, but do it after tracing so
+// emitText and tracing output don't conflict on stdout
+assert(binaryen.emitText(original) === binaryen.emitText(copy));

test/binaryen.js/copy-expression.js.txt

@@ -0,0 +1,37 @@
+// beginning a Binaryen API trace
+#include <math.h>
+#include <map>
+#include "binaryen-c.h"
+int main() {
+  std::map<size_t, BinaryenType> types;
+  std::map<size_t, BinaryenExpressionRef> expressions;
+  std::map<size_t, BinaryenFunctionRef> functions;
+  std::map<size_t, BinaryenGlobalRef> globals;
+  std::map<size_t, BinaryenEventRef> events;
+  std::map<size_t, BinaryenExportRef> exports;
+  std::map<size_t, RelooperBlockRef> relooperBlocks;
+  std::map<size_t, ExpressionRunnerRef> expressionRunners;
+  BinaryenModuleRef the_module = NULL;
+  RelooperRef the_relooper = NULL;
+  the_module = BinaryenModuleCreate();
+  expressions[size_t(NULL)] = BinaryenExpressionRef(NULL);
+  expressions[1] = BinaryenLocalGet(the_module, 0, BinaryenTypeInt32());
+  expressions[2] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[3] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[4] = BinaryenIf(the_module, expressions[1], expressions[2], expressions[3]);
+  {
+    BinaryenExpressionRef children[] = { expressions[4] };
+    expressions[5] = BinaryenBlock(the_module, NULL, children, 1, BinaryenTypeInt32());
+  }
+  expressions[6] = BinaryenExpressionCopy(expressions[5], theModule);
+  BinaryenBlockGetChild(expressions[5], 0);
+  BinaryenBlockGetChild(expressions[6], 0);
+  BinaryenIfGetCondition(expressions[4]);
+  BinaryenIfGetCondition(expressions[0]); // this is bad
+  BinaryenIfGetIfTrue(expressions[4]);
+  BinaryenIfGetIfTrue(expressions[0]); // this is bad
+  BinaryenIfGetIfFalse(expressions[4]);
+  BinaryenIfGetIfFalse(expressions[0]); // this is bad
+  return 0;
+}
+// ending a Binaryen API trace