Add optimize, shrink level and debug info options to C/JS (#1357)

* Add optimize, shrink level and debug info options to C/JS

* Add instantiate functionality for creating additional unique instances of the API

* Use a workaround when running tests in node

Tests misuse a module as a script by concatenating, so instead of catching this case in the library, catch it there

* Update sieve test

Seems optimized output changed due to running with optimize levels 2/1 now

* Use the options with all pass runners

* Update relooper-fuzz C-API test

* Share defaults between tools and the C-API

* Add a test for optimize levels

* Unify node test support in check.by and auto_update_tests.py

* Also add getters for optimize levels and test them

* Also test debugInfo

* Add debug info to C tests that used it as well

* Fix missing NODEJS import in auto_update_tests

* Detect node.js version (WASM support)

* Update hello-world JS test (now also runs with node)

* feature-test WebAssembly in node instead

* Document that these options apply globally, and where

* Make sure hello-world.js output doesn't differ between mozjs/node

Author: dcodeIO

.gitignore

@@ -45,6 +45,8 @@ cmake_install.cmake
 *.vcxproj*
 *.dir/
 *.sln
+*.sdf
+*.VC.opendb
 bin/
 lib/
 Win32/

auto_update_tests.py

@@ -2,9 +2,9 @@
 
 import os, sys, subprocess, difflib
 
-from scripts.test.support import run_command, split_wast
+from scripts.test.support import run_command, split_wast, node_test_glue, node_has_webassembly
 from scripts.test.shared import (
-    ASM2WASM, MOZJS, S2WASM, WASM_SHELL, WASM_OPT, WASM_AS, WASM_DIS,
+    ASM2WASM, MOZJS, NODEJS, S2WASM, WASM_SHELL, WASM_OPT, WASM_AS, WASM_DIS,
     WASM_CTOR_EVAL, WASM_MERGE, WASM_REDUCE, WASM2ASM, WASM_METADCE,
     BINARYEN_INSTALL_DIR, has_shell_timeout)
 from scripts.test.wasm2asm import tests, spec_tests, extra_tests, assert_tests
@@ -231,20 +231,27 @@
         with open(out, 'w') as o: o.write(actual)
         with open(out + '.stdout', 'w') as o: o.write(stdout)
 
-if MOZJS:
+if MOZJS or NODEJS:
   print '\n[ checking binaryen.js testcases... ]\n'
 
+  node_has_wasm = NODEJS and node_has_webassembly(NODEJS)
   for s in sorted(os.listdir(os.path.join('test', 'binaryen.js'))):
     if not s.endswith('.js'): continue
     print s
     f = open('a.js', 'w')
     f.write(open(os.path.join('bin', 'binaryen.js')).read())
-    # node/shell test support
-    f.write(open(os.path.join('test', 'binaryen.js', s)).read())
+    if NODEJS:
+      f.write(node_test_glue())
+    test_path = os.path.join('test', 'binaryen.js', s)
+    test_src = open(test_path).read()
+    f.write(test_src)
     f.close()
-    cmd = [MOZJS, 'a.js']
-    out = run_command(cmd, stderr=subprocess.STDOUT)
-    with open(os.path.join('test', 'binaryen.js', s + '.txt'), 'w') as o: o.write(out)
+    if MOZJS or node_has_wasm or not 'WebAssembly.' in test_src:
+      cmd = [MOZJS or NODEJS, 'a.js']
+      out = run_command(cmd, stderr=subprocess.STDOUT)
+      with open(os.path.join('test', 'binaryen.js', s + '.txt'), 'w') as o: o.write(out)
+    else:
+      print 'Skipping ' + test_path + ' because WebAssembly might not be supported'
 
 print '\n[ checking wasm-ctor-eval... ]\n'
 
@@ -320,4 +327,4 @@
       expected = t + '.txt'
       run_command(WASM_DIS + ['c.wasm', '-o', expected])
 
-print '\n[ success! ]'  
+print '\n[ success! ]'

bin/binaryen.js

@@ -109,6 +109,7 @@ echo "building shared bitcode"
   src/passes/ReReloop.cpp \
   src/passes/SafeHeap.cpp \
   src/passes/SimplifyLocals.cpp \
+  src/passes/SpillPointers.cpp \
   src/passes/SSAify.cpp \
   src/passes/TrapMode.cpp \
   src/passes/Untee.cpp \
@@ -524,6 +525,12 @@ export_function "_BinaryenModulePrint"
 export_function "_BinaryenModulePrintAsmjs"
 export_function "_BinaryenModuleValidate"
 export_function "_BinaryenModuleOptimize"
+export_function "_BinaryenGetOptimizeLevel"
+export_function "_BinaryenSetOptimizeLevel"
+export_function "_BinaryenGetShrinkLevel"
+export_function "_BinaryenSetShrinkLevel"
+export_function "_BinaryenGetDebugInfo"
+export_function "_BinaryenSetDebugInfo"
 export_function "_BinaryenModuleRunPasses"
 export_function "_BinaryenModuleAutoDrop"
 export_function "_BinaryenModuleWrite"
@@ -579,10 +586,5 @@ export_function "_BinaryenSetAPITracing"
   -Isrc/ \
   -s EXPORTED_FUNCTIONS=[${EXPORTED_FUNCTIONS}] \
   -o bin/binaryen${OUT_FILE_SUFFIX}.js \
-  --post-js src/js/binaryen.js-post.js \
-  -s MODULARIZE=1 \
-  -s 'EXPORT_NAME="Binaryen"'
-
-# Create a singleton instance from the MODULARIZE module
-echo "Binaryen = Binaryen();" >> bin/binaryen${OUT_FILE_SUFFIX}.js
-
+  --pre-js src/js/binaryen.js-pre.js \
+  --post-js src/js/binaryen.js-post.js

bin/wasm.js

@@ -20,7 +20,7 @@
 import subprocess
 import sys
 
-from scripts.test.support import run_command, split_wast
+from scripts.test.support import run_command, split_wast, node_test_glue, node_has_webassembly
 from scripts.test.shared import (
     BIN_DIR, EMCC, MOZJS, NATIVECC, NATIVEXX, NODEJS, S2WASM_EXE,
     WASM_AS, WASM_CTOR_EVAL, WASM_OPT, WASM_SHELL, WASM_MERGE, WASM_SHELL_EXE, WASM_METADCE,
@@ -351,6 +351,7 @@ def fix(x):
 def run_binaryen_js_tests():
   if not MOZJS and not NODEJS:
     return
+  node_has_wasm = NODEJS and node_has_webassembly(NODEJS)
 
   print '\n[ checking binaryen.js testcases... ]\n'
 
@@ -360,10 +361,11 @@ def run_binaryen_js_tests():
     f = open('a.js', 'w')
     binaryen_js = open(os.path.join(options.binaryen_bin, 'binaryen.js')).read()
     f.write(binaryen_js)
+    if NODEJS:
+      f.write(node_test_glue())
     test_path = os.path.join(options.binaryen_test, 'binaryen.js', s)
-    test = open(test_path).read()
-    need_wasm = 'WebAssembly.' in test # some tests use wasm support in the VM
-    f.write(test)
+    test_src = open(test_path).read()
+    f.write(test_src)
     f.close()
     def test(engine):
       cmd = [engine, 'a.js']
@@ -374,8 +376,11 @@ def test(engine):
     # run in all possible shells
     if MOZJS:
       test(MOZJS)
-    if NODEJS and not need_wasm: # TODO: check if node is new and has wasm support
-      test(NODEJS)
+    if NODEJS:
+      if node_has_wasm or not 'WebAssembly.' in test_src:
+        test(NODEJS)
+      else:
+        print 'Skipping ' + test_path + ' because WebAssembly might not be supported'
 
 def run_validator_tests():
   print '\n[ running validation tests... ]\n'

build-js.sh

@@ -165,3 +165,17 @@ def run_command(cmd, expected_status=0, stderr=None,
     raise Exception(('run_command unexpected stderr',
                      "expected '%s', actual '%s'" % (expected_err, err)))
   return out
+
+
+def node_has_webassembly(cmd):
+  cmd = [cmd, '-e', 'process.stdout.write(typeof WebAssembly)']
+  return run_command(cmd) == 'object'
+
+
+def node_test_glue():
+  # running concatenated files (a.js) in node interferes with module loading
+  # because the concatenated file expects a 'var Binaryen' but binaryen.js
+  # assigned to module.exports. this is correct behavior but tests then need
+  # a workaround:
+  return ('if (typeof module === "object" && typeof exports === "object")\n'
+          '  Binaryen = module.exports;\n')

check.py

@@ -33,6 +33,7 @@
 #include "cfg/Relooper.h"
 #include "ir/utils.h"
 #include "shell-interface.h"
+#include "support/defaults.h"
 
 using namespace wasm;
 
@@ -70,6 +71,11 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
 static std::mutex BinaryenFunctionMutex;
 static std::mutex BinaryenFunctionTypeMutex;
 
+// Optimization options
+static int optimizeLevel = BINARYEN_DEFAULT_OPTIMIZE_LEVEL;
+static int shrinkLevel = BINARYEN_DEFAULT_SHRINK_LEVEL;
+static bool debugInfo = BINARYEN_DEFAULT_DEBUG_INFO;
+
 // Tracing support
 
 static int tracing = 0;
@@ -2007,10 +2013,61 @@ void BinaryenModuleOptimize(BinaryenModuleRef module) {
 
   Module* wasm = (Module*)module;
   PassRunner passRunner(wasm);
+  passRunner.options.optimizeLevel = optimizeLevel;
+  passRunner.options.shrinkLevel = shrinkLevel;
+  passRunner.options.debugInfo = debugInfo;
   passRunner.addDefaultOptimizationPasses();
   passRunner.run();
 }
 
+int BinaryenGetOptimizeLevel() {
+  if (tracing) {
+    std::cout << "  BinaryenGetOptimizeLevel();\n";
+  }
+
+  return optimizeLevel;
+}
+
+void BinaryenSetOptimizeLevel(int level) {
+  if (tracing) {
+    std::cout << "  BinaryenSetOptimizeLevel(" << level << ");\n";
+  }
+
+  optimizeLevel = level;
+}
+
+int BinaryenGetShrinkLevel() {
+  if (tracing) {
+    std::cout << "  BinaryenGetShrinkLevel();\n";
+  }
+
+  return shrinkLevel;
+}
+
+void BinaryenSetShrinkLevel(int level) {
+  if (tracing) {
+    std::cout << "  BinaryenSetShrinkLevel(" << level << ");\n";
+  }
+
+  shrinkLevel = level;
+}
+
+int BinaryenGetDebugInfo() {
+  if (tracing) {
+    std::cout << "  BinaryenGetDebugInfo();\n";
+  }
+
+  return debugInfo;
+}
+
+void BinaryenSetDebugInfo(int on) {
+  if (tracing) {
+    std::cout << "  BinaryenSetDebugInfo(" << on << ");\n";
+  }
+
+  debugInfo = bool(on);
+}
+
 void BinaryenModuleRunPasses(BinaryenModuleRef module, const char **passes, BinaryenIndex numPasses) {
   if (tracing) {
     std::cout << "  {\n";
@@ -2026,6 +2083,9 @@ void BinaryenModuleRunPasses(BinaryenModuleRef module, const char **passes, Bina
 
   Module* wasm = (Module*)module;
   PassRunner passRunner(wasm);
+  passRunner.options.optimizeLevel = optimizeLevel;
+  passRunner.options.shrinkLevel = shrinkLevel;
+  passRunner.options.debugInfo = debugInfo;
   for (BinaryenIndex i = 0; i < numPasses; i++) {
     passRunner.add(passes[i]);
   }
@@ -2039,6 +2099,7 @@ void BinaryenModuleAutoDrop(BinaryenModuleRef module) {
 
   Module* wasm = (Module*)module;
   PassRunner passRunner(wasm);
+  passRunner.options.debugInfo = debugInfo;
   passRunner.add<AutoDrop>();
   passRunner.run();
 }
@@ -2051,6 +2112,7 @@ size_t BinaryenModuleWrite(BinaryenModuleRef module, char* output, size_t output
   Module* wasm = (Module*)module;
   BufferWithRandomAccess buffer(false);
   WasmBinaryWriter writer(wasm, buffer, false);
+  writer.setNamesSection(debugInfo);
   writer.write();
   size_t bytes = std::min(buffer.size(), outputSize);
   std::copy_n(buffer.begin(), bytes, output);
@@ -2192,6 +2254,9 @@ void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module
 
   Module* wasm = (Module*)module;
   PassRunner passRunner(wasm);
+  passRunner.options.optimizeLevel = optimizeLevel;
+  passRunner.options.shrinkLevel = shrinkLevel;
+  passRunner.options.debugInfo = debugInfo;
   passRunner.addDefaultOptimizationPasses();
   passRunner.runOnFunction((Function*)func);
 }
@@ -2210,6 +2275,9 @@ void BinaryenFunctionRunPasses(BinaryenFunctionRef func, BinaryenModuleRef modul
 
   Module* wasm = (Module*)module;
   PassRunner passRunner(wasm);
+  passRunner.options.optimizeLevel = optimizeLevel;
+  passRunner.options.shrinkLevel = shrinkLevel;
+  passRunner.options.debugInfo = debugInfo;
   for (BinaryenIndex i = 0; i < numPasses; i++) {
     passRunner.add(passes[i]);
   }

scripts/test/support.py

@@ -48,6 +48,7 @@
 #include <stdint.h>
 
 #include "compiler-support.h"
+#include "support/defaults.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -656,18 +657,44 @@ void BinaryenModulePrintAsmjs(BinaryenModuleRef module);
 //  @return 0 if an error occurred, 1 if validated succesfully
 int BinaryenModuleValidate(BinaryenModuleRef module);
 
-// Runs the standard optimization passes on the module.
+// Runs the standard optimization passes on the module. Uses the currently set
+// global optimize and shrink level.
 void BinaryenModuleOptimize(BinaryenModuleRef module);
 
-// Runs the specified passes on the module.
+// Gets the currently set optimize level. Applies to all modules, globally.
+// 0, 1, 2 correspond to -O0, -O1, -O2 (default), etc.
+int BinaryenGetOptimizeLevel();
+
+// Sets the optimization level to use. Applies to all modules, globally.
+// 0, 1, 2 correspond to -O0, -O1, -O2 (default), etc.
+void BinaryenSetOptimizeLevel(int level);
+
+// Gets the currently set shrink level. Applies to all modules, globally.
+// 0, 1, 2 correspond to -O0, -Os (default), -Oz.
+int BinaryenGetShrinkLevel();
+
+// Sets the shrink level to use. Applies to all modules, globally.
+// 0, 1, 2 correspond to -O0, -Os (default), -Oz.
+void BinaryenSetShrinkLevel(int level);
+
+// Gets whether generating debug information is currently enabled or not.
+// Applies to all modules, globally.
+int BinaryenGetDebugInfo();
+
+// Enables or disables debug information in emitted binaries.
+// Applies to all modules, globally.
+void BinaryenSetDebugInfo(int on);
+
+// Runs the specified passes on the module. Uses the currently set global
+// optimize and shrink level.
 void BinaryenModuleRunPasses(BinaryenModuleRef module, const char **passes, BinaryenIndex numPasses);
 
 // Auto-generate drop() operations where needed. This lets you generate code without
 // worrying about where they are needed. (It is more efficient to do it yourself,
 // but simpler to use autodrop).
 void BinaryenModuleAutoDrop(BinaryenModuleRef module);
 
-// Serialize a module into binary form.
+// Serialize a module into binary form. Uses the currently set global debugInfo option.
 // @return how many bytes were written. This will be less than or equal to outputSize
 size_t BinaryenModuleWrite(BinaryenModuleRef module, char* output, size_t outputSize);
 
@@ -713,10 +740,12 @@ BinaryenType BinaryenFunctionGetVar(BinaryenFunctionRef func, BinaryenIndex inde
 // Gets the body of the specified `Function`.
 BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func);
 
-// Runs the standard optimization passes on the function.
+// Runs the standard optimization passes on the function. Uses the currently set
+// global optimize and shrink level.
 void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module);
 
-// Runs the specified passes on the function.
+// Runs the specified passes on the function. Uses the currently set global
+// optimize and shrink level.
 void BinaryenFunctionRunPasses(BinaryenFunctionRef func, BinaryenModuleRef module, const char **passes, BinaryenIndex numPasses);
 
 //