Running passes on a single function in binaryen-c/.js (#1295)

 * Also other function utilities in C and JS APIs

Author: dcodeIO

bin/binaryen.js

@@ -358,6 +358,8 @@ export_function "_BinaryenConstGetValueI64High"
 export_function "_BinaryenConstGetValueF32"
 export_function "_BinaryenConstGetValueF64"
 export_function "_BinaryenAddFunction"
+export_function "_BinaryenGetFunction"
+export_function "_BinaryenRemoveFunction"
 export_function "_BinaryenAddGlobal"
 export_function "_BinaryenAddImport"
 export_function "_BinaryenRemoveImport"
@@ -376,6 +378,9 @@ export_function "_BinaryenModuleAutoDrop"
 export_function "_BinaryenModuleWrite"
 export_function "_BinaryenModuleRead"
 export_function "_BinaryenModuleInterpret"
+export_function "_BinaryenFunctionGetBody"
+export_function "_BinaryenFunctionOptimize"
+export_function "_BinaryenFunctionRunPasses"
 export_function "_RelooperCreate"
 export_function "_RelooperAddBlock"
 export_function "_RelooperAddBranch"

build-js.sh

@@ -28,6 +28,8 @@ Module property operations:
 
   * `addFunctionType(name, resultType, paramTypes)`: Add a function type to the module, with a specified name, result type, and param types.
   * `addFunction(name, functionType, varTypes, body)`: Add a function, with a name, a function type, an array of local types, and a body.
+  * `getFunction(name)`: Gets a function reference by name.
+  * `removeFunction(name)`: Removes a function by name.
   * `addImport(internalName, externalModuleName, externalBaseName, functionType)`: Add an import, with an internal name (used by other things in the module), an external module name (the module from which we import), an external base name (the name we import from that module), and a function type (for function imports).
   * `addExport(internalName, externalName)`: Add an export, with an internal name and an external name (the name the outside sees it exported as).
   * `setFunctionTable(funcs)`: Sets the function table to a array of functions.
@@ -40,7 +42,9 @@ Module operations:
   * `emitText()`: Returns a text representation of the module, in s-expression format.
   * `validate()`: Validates the module, checking it for correctness.
   * `optimize()`: Runs the standard optimization passes on the module.
+  * `optimizeFunction(func)`: Runs the standard optimization passes on a function.
   * `runPasses(passes)`: Runs the specified passes on the module.
+  * `runPassesOnFunction(func, passes)`: Runs the specified passes on a function.
   * `autoDrop()`: Automatically inserts `drop` operations. This lets you not worry about dropping when creating your code.
   * `interpret()`: Run the module in the Binaryen interpreter (creates the module, and calls the start method). Useful for debugging.
   * `dispose()`: Cleans up the module. If the Binaryen object can be garbage-collected anyhow, you don't need to do this, but if it stays around - e.g. if you create multiple `Module`s over time - then you should call this once a `Module` is no longer needed. (As binaryen.js uses compiled C++ code, we can't just rely on normal garbage collection to clean things up internally.)

docs/binaryen.js.Markdown

@@ -912,6 +912,22 @@ BinaryenFunctionRef BinaryenAddFunction(BinaryenModuleRef module, const char* na
 
   return ret;
 }
+BinaryenFunctionRef BinaryenGetFunction(BinaryenModuleRef module, const char* name) {
+  if (tracing) {
+    std::cout << "  BinaryenGetFunction(the_module, \"" << name << "\");\n";
+  }
+
+  auto* wasm = (Module*)module;
+  return wasm->getFunction(name);
+}
+void BinaryenRemoveFunction(BinaryenModuleRef module, const char* name) {
+  if (tracing) {
+    std::cout << "  BinaryenRemoveFunction(the_module, \"" << name << "\");\n";
+  }
+
+  auto* wasm = (Module*)module;
+  wasm->removeFunction(name);
+}
 
 BinaryenGlobalRef BinaryenAddGlobal(BinaryenModuleRef module, const char* name, BinaryenType type, int8_t mutable_, BinaryenExpressionRef init) {
   if (tracing) {
@@ -1213,6 +1229,50 @@ void BinaryenModuleInterpret(BinaryenModuleRef module) {
   ModuleInstance instance(*wasm, &interface);
 }
 
+//
+// ========== Function Operations ==========
+//
+
+BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func) {
+  if (tracing) {
+    std::cout << "  BinaryenFunctionGetBody(functions[" << functions[func] << "]);\n";
+  }
+
+  return ((Function*)func)->body;
+}
+
+void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module) {
+  if (tracing) {
+    std::cout << "  BinaryenFunctionOptimize(functions[" << functions[func] << "], the_module);\n";
+  }
+
+  Module* wasm = (Module*)module;
+  PassRunner passRunner(wasm);
+  passRunner.addDefaultOptimizationPasses();
+  passRunner.runFunction((Function*)func);
+}
+
+void BinaryenFunctionRunPasses(BinaryenFunctionRef func, BinaryenModuleRef module, const char **passes, BinaryenIndex numPasses) {
+  if (tracing) {
+    std::cout << "  {\n";
+    std::cout << "    const char* passes[] = { ";
+    for (BinaryenIndex i = 0; i < numPasses; i++) {
+      if (i > 0) std::cout << ", ";
+      std::cout << "\"" << passes[i] << "\"";
+    }
+    std::cout << " };\n";
+    std::cout << "    BinaryenFunctionRunPasses(functions[" << functions[func] << ", the_module, passes, " << numPasses << ");\n";
+    std::cout << "  }\n";
+  }
+
+  Module* wasm = (Module*)module;
+  PassRunner passRunner(wasm);
+  for (BinaryenIndex i = 0; i < numPasses; i++) {
+    passRunner.add(passes[i]);
+  }
+  passRunner.runFunction((Function*)func);
+}
+
 //
 // ========== CFG / Relooper ==========
 //

src/binaryen-c.cpp

@@ -400,6 +400,12 @@ typedef void* BinaryenFunctionRef;
 //            at indexes 1 and 2, etc., that is, they share an index space.
 BinaryenFunctionRef BinaryenAddFunction(BinaryenModuleRef module, const char* name, BinaryenFunctionTypeRef type, BinaryenType* varTypes, BinaryenIndex numVarTypes, BinaryenExpressionRef body);
 
+// Gets a function reference by name.
+BinaryenFunctionRef BinaryenGetFunction(BinaryenModuleRef module, const char* name);
+
+// Removes a function by name.
+void BinaryenRemoveFunction(BinaryenModuleRef module, const char* name);
+
 // Imports
 
 typedef void* BinaryenImportRef;
@@ -451,7 +457,7 @@ void BinaryenModulePrintAsmjs(BinaryenModuleRef module);
 //  @return 0 if an error occurred, 1 if validated succesfully
 int BinaryenModuleValidate(BinaryenModuleRef module);
 
-// Run the standard optimization passes on the module.
+// Runs the standard optimization passes on the module.
 void BinaryenModuleOptimize(BinaryenModuleRef module);
 
 // Runs the specified passes on the module.
@@ -474,6 +480,19 @@ BinaryenModuleRef BinaryenModuleRead(char* input, size_t inputSize);
 // and then destroying the instance.
 void BinaryenModuleInterpret(BinaryenModuleRef module);
 
+//
+// ========== Function Operations ==========
+//
+
+// Gets the body of the function.
+BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func);
+
+// Runs the standard optimization passes on the function.
+void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module);
+
+// Runs the specified passes on the function.
+void BinaryenFunctionRunPasses(BinaryenFunctionRef func, BinaryenModuleRef module, const char **passes, BinaryenIndex numPasses);
+
 //
 // ========== CFG / Relooper ==========
 //

src/binaryen-c.h

@@ -1019,6 +1019,16 @@
         return Module['_BinaryenAddFunction'](module, strToStack(name), functionType, i32sToStack(varTypes), varTypes.length, body);
       });
     };
+    this['getFunction'] = function(name) {
+      return preserveStack(function() {
+        return Module['_BinaryenGetFunction'](module, strToStack(name));
+      });
+    };
+    this['removeFunction'] = function(name) {
+      return preserveStack(function() {
+        return Module['_BinaryenRemoveFunction'](module, strToStack(name));
+      });
+    };
     this['addGlobal'] = function(name, type, mutable, init) {
       return preserveStack(function() {
         return Module['_BinaryenAddGlobal'](module, strToStack(name), type, mutable, init);
@@ -1098,13 +1108,25 @@
     this['optimize'] = function() {
       return Module['_BinaryenModuleOptimize'](module);
     };
+    this['optimizeFunction'] = function(func) {
+      if (typeof func === "string") func = this['getFunction'](func);
+      return Module['_BinaryenFunctionOptimize'](func, module);
+    };
     this['runPasses'] = function(passes) {
       return preserveStack(function() {
         return Module['_BinaryenModuleRunPasses'](module, i32sToStack(
           passes.map(strToStack)
         ), passes.length);
       });
-    }
+    };
+    this['runPassesOnFunction'] = function(func, passes) {
+      if (typeof func === "string") func = this['getFunction'](func);
+      return preserveStack(function() {
+        return Module['_BinaryenFunctionRunPasses'](func, module, i32sToStack(
+          passes.map(strToStack)
+        ), passes.length);
+      });
+    };
     this['autoDrop'] = function() {
       return Module['_BinaryenModuleAutoDrop'](module);
     };
@@ -1172,6 +1194,10 @@
     return Module['_BinaryenConstGetValueF64'](expr);
   };
 
+  Module['getFunctionBody'] = function(func) {
+    return Module['_BinaryenFunctionGetBody'](func);
+  };
+
   // emit text of an expression or a module
   Module['emitText'] = function(expr) {
     if (typeof expr === 'object') {

src/js/binaryen.js-post.js

@@ -0,0 +1,28 @@
+var module = new Binaryen.Module();
+
+var signature = module.addFunctionType("i", Binaryen.i32, []);
+
+var func = module.addFunction("a-function", signature, [],
+  module.i32.add(
+    module.i32.const(1),
+    module.i32.const(2)
+  )
+);
+
+console.log("GetFunction is equal: " + (func === module.getFunction("a-function")));
+
+module.runPassesOnFunction(func, ["precompute"]);
+
+var body = Binaryen.getFunctionBody(func);
+
+console.log("ExpressionId=" + Binaryen.getExpressionId(body));
+console.log("ExpressionType=" + Binaryen.getExpressionType(body));
+console.log(Binaryen.emitText(body));
+
+module.removeFunction("a-function");
+
+module.addGlobal("a-global", Binaryen.i32, false, body);
+
+module.validate();
+
+console.log(module.emitText());

test/binaryen.js/functions.js

@@ -0,0 +1,11 @@
+GetFunction is equal: true
+ExpressionId=15
+ExpressionType=1
+(i32.const 3)
+
+(module
+ (type $i (func (result i32)))
+ (global $a-global i32 (i32.const 3))
+ (memory $0 0)
+)
+