emcc option to override closure compiler, and use closure compiler by default in -O2 and not just -O3

2 files changed, 40 insertions, 22 deletions

diff --git a/emcc b/emcc
index e6f4d3dd..62225e1c 100755
--- a/emcc
+++ b/emcc
@@ -112,7 +112,8 @@ Options that are modified or new in %s include:
   -O0                      No optimizations (default)
   -O1                      Simple optimizations, including safe LLVM
                            optimizations, and no runtime assertions
-  -O2                      As -O1, plus code flow optimization (relooper)
+  -O2                      As -O1, plus the relooper (loop recreation),
+                           plus closure compiler
                            Warning: Compiling with this takes a long time!
   -O3                      As -O2, plus dangerous optimizations that may
                            break the generated code! If that happens, try
@@ -129,6 +130,8 @@ Options that are modified or new in %s include:
                            2: Full, unsafe/unportable LLVM optimizations;
                               this will almost certainly break the
                               generated code!
+  --closure <on>           0: No closure compiler (default in -O0, -O1)
+                           1: Run closure compiler (default in -O2, -O3)
 
 The target file, if specified (-o <target>), defines what will
 be generated:
@@ -226,7 +229,11 @@ try:
   newargs = sys.argv[1:]
 
   opt_level = 0
-  llvm_opt_level = 0
+  llvm_opt_level = None
+  closure = None
+
+  def check_bad_eq(arg):
+    assert '=' not in arg, 'Invalid parameter (do not use "=" with "--" options)'
 
   for i in range(len(newargs)):
     if newargs[i].startswith('-O'):
@@ -235,17 +242,23 @@ try:
         assert 0 <= opt_level <= 3
       except:
         raise Exception('Invalid optimization level: ' + newargs[i])
-      if opt_level >= 1:
-        llvm_opt_level = 1
       newargs[i] = ''
     elif newargs[i].startswith('--llvm-opts'):
-      assert '=' not in newargs[i], 'Invalid llvm opts parameter (do not use "=")'
+      check_bad_eq(newargs[i])
       llvm_opt_level = eval(newargs[i+1])
       assert 0 <= llvm_opt_level <= 1, 'Only two levels of LLVM optimizations are supported so far, 0 (none) and 1 (safe)'
       newargs[i] = ''
       newargs[i+1] = ''
+    elif newargs[i].startswith('--closure'):
+      check_bad_eq(newargs[i])
+      closure = int(newargs[i+1])
+      newargs[i] = ''
+      newargs[i+1] = ''
   newargs = [ arg for arg in newargs if arg is not '' ]
 
+  if llvm_opt_level is None: llvm_opt_level = 1 if opt_level >= 1 else 0
+  if closure is None: closure = 1 if opt_level >= 2 else 0
+
   settings_changes = []
   for i in range(len(newargs)):
     if newargs[i] == '-s':
@@ -292,7 +305,6 @@ try:
     shared.Settings.ASSERTIONS = 0
   if opt_level >= 2:
     shared.Settings.RELOOP = 1
-    print >> sys.stderr, 'Warning: The relooper optimization can be very slow.'
   if opt_level >= 3:
     shared.Settings.CORRECT_SIGNS = 0
     shared.Settings.CORRECT_OVERFLOWS = 0
@@ -355,6 +367,9 @@ try:
     key, value = change.split('=')
     exec('shared.Settings.' + key + ' = ' + value)
 
+  if opt_level >= 2:
+    print >> sys.stderr, 'Warning: The relooper optimization can be very slow.'
+
   final = shared.Building.emscripten(in_temp(target_basename + '.bc'), append_ext=False)
 
   if opt_level >= 1:
@@ -365,8 +380,7 @@ try:
     # eliminator
     final = shared.Building.eliminator(final)
 
-  if opt_level >= 3:
-    # closure
+  if closure:
     if DEBUG: print >> sys.stderr, 'emcc: running closure'
     final = shared.Building.closure_compiler(final)
 
diff --git a/tests/runner.py b/tests/runner.py
index 83fe4ca6..df4f7ba7 100644
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -4921,19 +4921,23 @@ Options that are modified or new in %s include:
           self.assertContained('hello, world!', self.run_llvm_interpreter([target]))
 
         # Optimization: emcc src.cpp -o something.js [-Ox]. -O0 is the same as not specifying any optimization setting
-        for params, opt_level, bc_params in [ # bc params are used after compiling to bitcode
-          (['-o', 'something.js'],        0, None),
-          (['-o', 'something.js', '-O0'], 0, None),
-          (['-o', 'something.js', '-O1'], 1, None),
-          (['-o', 'something.js', '-O2'], 2, None),
-          (['-o', 'something.js', '-O3'], 3, None),
+        for params, opt_level, bc_params, closure in [ # bc params are used after compiling to bitcode
+          (['-o', 'something.js'],                          0, None, 0),
+          (['-o', 'something.js', '-O0'],                   0, None, 0),
+          (['-o', 'something.js', '-O1'],                   1, None, 0),
+          (['-o', 'something.js', '-O1', '--closure', '1'], 1, None, 1),
+          (['-o', 'something.js', '-O2'],                   2, None, 1),
+          (['-o', 'something.js', '-O2', '--closure', '0'], 2, None, 0),
+          (['-o', 'something.js', '-O3'],                   3, None, 1),
+          (['-o', 'something.js', '-O3', '--closure', '0'], 3, None, 0),
           # and, test compiling to bitcode first
-          (['-o', 'something.bc'], 0, []),
-          (['-o', 'something.bc'], 0, ['-O0']),
-          (['-o', 'something.bc'], 1, ['-O1']),
-          (['-o', 'something.bc'], 2, ['-O2']),
-          (['-o', 'something.bc'], 3, ['-O3']),
+          (['-o', 'something.bc'], 0, [],      0),
+          (['-o', 'something.bc'], 0, ['-O0'], 0),
+          (['-o', 'something.bc'], 1, ['-O1'], 0),
+          (['-o', 'something.bc'], 2, ['-O2'], 1),
+          (['-o', 'something.bc'], 3, ['-O3'], 1),
         ]:
+          #print params, opt_level, bc_params, closure
           clear()
           output = Popen([compiler, path_from_root('tests', 'hello_world_loop.cpp')] + params,
                          stdout=PIPE, stderr=PIPE).communicate()
@@ -4949,16 +4953,16 @@ Options that are modified or new in %s include:
           # Verify optimization level etc. in the generated code
           # XXX these are quite sensitive, and will need updating when code generation changes
           generated = open('something.js').read() # TODO: parse out the _main function itself, not support code, if the tests below need that some day
-          assert ('(__label__)' in generated) == (opt_level <= 1), 'relooping should be in opt >= 2'
-          assert ('assert(STACKTOP < STACK_MAX)' in generated) == (opt_level == 0), 'assertions should be in opt == 0'
           assert ('|0)/2)|0)' in generated or '| 0) / 2 | 0)' in generated) == (opt_level <= 2), 'corrections should be in opt <= 2'
           assert 'new Uint16Array' in generated and 'new Uint32Array' in generated, 'typed arrays 2 should be used by default'
           assert 'SAFE_HEAP' not in generated, 'safe heap should not be used by default'
           assert ': while(' not in generated, 'when relooping we also js-optimize, so there should be no labelled whiles'
-          if opt_level >= 3:
+          if closure:
             assert 'Module._main = ' in generated, 'closure compiler should have been run'
           else:
             # closure has not been run, we can do some additional checks. TODO: figure out how to do these even with closure
+            assert ('(__label__)' in generated) == (opt_level <= 1), 'relooping should be in opt >= 2'
+            assert ('assert(STACKTOP < STACK_MAX)' in generated) == (opt_level == 0), 'assertions should be in opt == 0'
             assert 'var $i;' in generated, 'micro opts should always be on'
             if opt_level >= 1: assert 'HEAP8[HEAP32[' in generated, 'eliminator should create compound expressions, and fewer one-time vars'
             assert ('_puts(' in generated) == (opt_level >= 1), 'with opt >= 1, llvm opts are run and they should optimize printf to puts'