Merge branch 'incoming' of https://github.com/jpernst/emscripten into incoming

Author: yoanlcq

AUTHORS

@@ -299,3 +299,4 @@ a license to everyone to use it as detailed in LICENSE.)
 * Ryan Lester <ryan@cyph.com> (copyright owned by Cyph, Inc.)
 * Jameson Ernst <jameson@jpernst.com>
 * Yoan Lecoq <yoanlecoq.io@gmail.com>
+* Nazar Mokrynskyi <nazar@mokrynskyi.com>

site/source/docs/api_reference/module.rst

@@ -81,6 +81,14 @@ The following ``Module`` attributes affect code execution.
 
 	If ``noExitRuntime`` is set to ``true``, the runtime is not shut down after ``run`` completes. Shutting down the runtime calls shutdown callbacks, for example ``atexit`` calls. If you want to continue using the code after ``run()`` finishes, it is necessary to set this. This is automatically set for you if you use an API command that implies that you want the runtime to not be shut down, for example ``emscripten_set_main_loop``.
 
+.. js:attribute:: Module.onRuntimeInitialized
+
+	If set, this function is called when the runtime is fully initialized, that is, when compiled code is safe to run, which is after any asynchronous startup operations have completed (such as asynchronous WebAssembly compilation, file preloading, etc.). (An alternative to waiting for this to be called is to wait for ``main()`` to be called.)
+
+.. js:attribute:: Module.onAbort
+
+	If set, this function is called when abnormal program termination occurs. That can happen due to the C method ``abort()`` being called directly, or called from JavaScript, or due to a fatal problem such as being unable to fetch a necessary file during startup (like the wasm binary when running wasm), etc. After calling this function, program termination occurs (i.e., you can't use this to try to do something else instead of stopping; there is no possibility of recovering here).
+
 .. js:attribute:: Module.filePackagePrefixURL
 
 	This is the "prefix" URL for a preloaded data file that is hosted separately from its JavaScript and HTML files (it includes the full path up to, but not including, the data file). See :ref:`packaging-files-data-file-location` for more information.

src/preamble.js

@@ -2496,6 +2496,12 @@ function integrateWasmJS(Module) {
     // try the methods. each should return the exports if it succeeded
 
     var exports;
+#if BINARYEN_METHOD == 'native-wasm'
+    exports = doNativeWasm(global, env, providedBuffer);
+#else
+#if BINARYEN_METHOD == 'asmjs'
+    exports = doJustAsm(global, env, providedBuffer);
+#else
     var methods = method.split(',');
 
     for (var i = 0; i < methods.length; i++) {
@@ -2519,6 +2525,8 @@ function integrateWasmJS(Module) {
     }
 
     if (!exports) throw 'no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods';
+#endif
+#endif
 
 #if RUNTIME_LOGGING
     Module['printErr']('binaryen method succeeded.');

tests/test_other.py

@@ -3196,26 +3196,77 @@ def test_warn_unaligned(self):
     assert '@line 11 "src.cpp"' in output[1], output[1]
 
   def test_on_abort(self):
-    cmd = [PYTHON, EMCC, path_from_root('tests', 'hello_world.c'), '-s', 'WASM=1', '-s', 'BINARYEN_METHOD="interpret-binary"']
+    expected_output = 'Module.onAbort was called'
 
-    self.clear()
-    proc = Popen(cmd, stdout=PIPE, stderr=PIPE)
-    output, err = proc.communicate()
+    def add_on_abort_and_verify():
+      with open('a.out.js') as f:
+        js = f.read()
+      with open('a.out.js', 'w') as f:
+        f.write("var Module = { onAbort: function() { console.log('%s') } };\n" % expected_output)
+        f.write(js)
+      self.assertContained(expected_output, run_js('a.out.js', assert_returncode=None))
 
-    expectedOutput = 'Module.onAbort was called'
+    # test direct abort() C call
 
-    # trigger onAbort by intentionally causing startup to fail
-    os.remove('a.out.wasm')
+    with open('src.c', 'w') as f:
+      f.write('''
+        #include <stdlib.h>
+        int main() {
+          abort();
+        }
+      ''')
+    subprocess.check_call([PYTHON, EMCC, 'src.c'])
+    add_on_abort_and_verify()
 
-    f = open('a.out.js', 'r')
-    js = f.read()
-    f.close()
-    f = open('a.out.js', 'w')
-    f.write("var Module = {onAbort: function() { console.log('%s') }};\n" % expectedOutput)
-    f.write(js)
-    f.close()
+    # test direct abort() JS call
 
-    self.assertContained(expectedOutput, run_js('a.out.js', assert_returncode=None))
+    with open('src.c', 'w') as f:
+      f.write('''
+        #include <emscripten.h>
+        int main() {
+          EM_ASM({ abort() });
+        }
+      ''')
+    subprocess.check_call([PYTHON, EMCC, 'src.c'])
+    add_on_abort_and_verify()
+
+    # test throwing in an abort handler, and catching that
+
+    with open('src.c', 'w') as f:
+      f.write('''
+        #include <emscripten.h>
+        int main() {
+          EM_ASM({
+            try {
+              Module.print('first');
+              abort();
+            } catch (e) {
+              Module.print('second');
+              abort();
+              throw e;
+            }
+          });
+        }
+      ''')
+    subprocess.check_call([PYTHON, EMCC, 'src.c'])
+    with open('a.out.js') as f:
+      js = f.read()
+    with open('a.out.js', 'w') as f:
+      f.write("var Module = { onAbort: function() { console.log('%s'); throw 're-throw'; } };\n" % expected_output)
+      f.write(js)
+    out = run_js('a.out.js', stderr=subprocess.STDOUT, assert_returncode=None)
+    print out
+    self.assertContained(expected_output, out)
+    self.assertContained('re-throw', out)
+    self.assertContained('first', out)
+    self.assertContained('second', out)
+    self.assertEqual(out.count(expected_output), 2)
+
+    # test an abort during startup
+
+    subprocess.check_call([PYTHON, EMCC, path_from_root('tests', 'hello_world.c'), '-s', 'WASM=1', '-s', 'BINARYEN_METHOD="interpret-binary"'])
+    os.remove('a.out.wasm') # trigger onAbort by intentionally causing startup to fail
+    add_on_abort_and_verify()
 
   def test_no_exit_runtime(self):
     open('code.cpp', 'w').write(r'''

tools/ports/binaryen.py

@@ -29,9 +29,11 @@ def create():
   return [shared.Cache.get('binaryen_tag_' + TAG, create, what='port', extension='.txt')]
 
 def process_args(ports, args, settings, shared):
-  if not needed(settings, shared, ports):
-    return args
-  get(ports, settings, shared)
+  # we don't need to do anything just for compile args; binaryen
+  # is used in the final link stage to wasm, not bitcode
+  # (otherwise, if we get binaryen while building to bitcode, we
+  # may be building system libraries, so this would be recursive.
+  # TODO: consider avoiding such recursion in a more direct way)
   return args
 
 def show():