Fix emterpreter SAFE_HEAP invokes. fixes #6532 (#6539)

We must not emterpret SAFE_FT_MASK, as it appears in dynCall_*, which may be called during rebuilding of the stack after an async operation (if an invoke was on the stack, then we will call it again, and it calls dynCall_*), and it is not valid to run emterpreted code at that time.

Author: kripken

tests/runner.py

@@ -140,13 +140,14 @@ def get_browser():
 ]
 nondefault_test_modes = [
   'asm2f',
-  'asm2i',
   'binaryen0',
   'binaryen1',
   'binaryen2',
   'binaryen3',
   'binaryens',
   'binaryenz',
+  'asmi',
+  'asm2i',
 ]
 test_index = 0
 

tests/test_core.py

@@ -7407,6 +7407,77 @@ def test_async_abort(self):
     self.emcc_args += ['--js-library', 'lib.js']
     self.do_run(src, 'Hello')
 
+  def test_async_invoke_safe_heap(self):
+    if not self.is_emterpreter(): return self.skip('emterpreter-only test')
+
+    self.banned_js_engines = [SPIDERMONKEY_ENGINE, V8_ENGINE] # needs setTimeout which only node has
+
+    # SAFE_HEAP leads to SAFE_FT_MASK, which appear in dynCall_*
+    # and then if they are interpreted, that messes up reloading
+    # of the stack (we can't run emterpreted code at that time,
+    # we should just see calls and follow them).
+    Settings.EMTERPRETIFY_ASYNC = 1
+    Settings.SAFE_HEAP = 1
+    Settings.EXPORTED_FUNCTIONS = ['_async_callback_test']
+    Settings.EXTRA_EXPORTED_RUNTIME_METHODS = ["ccall"]
+    Settings.DISABLE_EXCEPTION_CATCHING = 0
+    Settings.ALLOW_MEMORY_GROWTH = 1
+    Settings.EMTERPRETIFY = 1
+    Settings.EMTERPRETIFY_ASYNC = 1
+    Settings.ASSERTIONS = 2
+
+    open('post.js', 'w').write(r'''
+var AsyncOperation = {
+  done: false,
+
+  start: function() {
+    // this.done = true; // uncomment this line => no crash
+    Promise.resolve().then(function() {
+      console.log('done!');
+      AsyncOperation.done = true;
+    });
+  }
+};
+
+Module.ccall('async_callback_test', null, [], [], { async: true });
+''')
+
+    src = r'''
+#include <stdio.h>
+#include <emscripten.h>
+
+extern "C" {
+  void call_async_operation() {
+    printf("start\n");
+    EM_ASM({AsyncOperation.start()});
+    printf("mid\n");
+    while (!EM_ASM_INT({return AsyncOperation.done})) {
+      printf("sleep1\n");
+      emscripten_sleep(200);
+      printf("sleep2\n");
+    }
+  }
+
+  // remove throw() => no crash
+  static void nothrow_func() throw()
+  {
+    call_async_operation();
+    printf("async operation OK\n");
+  }
+
+  void async_callback_test() {
+    nothrow_func();
+  }
+}'''
+
+    self.emcc_args += [
+      '--post-js', 'post.js',
+      '--profiling-funcs',
+      '--minify', '0',
+      '--memory-init-file', '0'
+    ]
+    self.do_run(src, 'async operation OK')
+
   def do_test_coroutine(self, additional_settings):
     Settings.NO_EXIT_RUNTIME = 0 # needs to flush stdio streams
     src = open(path_from_root('tests', 'test_coroutines.cpp')).read()
@@ -7632,7 +7703,6 @@ def setUp(self):
 
 # asm.js
 asm2f = make_run('asm2f', compiler=CLANG, emcc_args=['-Oz', '-s', 'PRECISE_F32=1', '-s', 'ALLOW_MEMORY_GROWTH=1', '-s', 'WASM=0'])
-asm2i = make_run('asm2i', compiler=CLANG, emcc_args=['-O2', '-s', 'EMTERPRETIFY=1', '-s', 'WASM=0'])
 asm2nn = make_run('asm2nn', compiler=CLANG, emcc_args=['-O2', '-s', 'WASM=0'], env={'EMCC_NATIVE_OPTIMIZER': '0'})
 
 # wasm
@@ -7641,4 +7711,8 @@ def setUp(self):
 binaryen2s = make_run('binaryen2s', compiler=CLANG, emcc_args=['-O2', '-s', 'SAFE_HEAP=1'])
 binaryen2_interpret = make_run('binaryen2_interpret', compiler=CLANG, emcc_args=['-O2', '-s', 'BINARYEN_METHOD="interpret-binary"'])
 
+# emterpreter
+asmi = make_run('asmi', compiler=CLANG, emcc_args=['-s', 'EMTERPRETIFY=1', '-s', 'WASM=0'])
+asm2i = make_run('asm2i', compiler=CLANG, emcc_args=['-O2', '-s', 'EMTERPRETIFY=1', '-s', 'WASM=0'])
+
 del T # T is just a shape for the specific subclasses, we don't test it itself

tools/emterpretify.py

@@ -61,7 +61,17 @@ def handle_arg(arg):
 
 # consts
 
-BLACKLIST = set(['_malloc', '_free', '_memcpy', '_memmove', '_memset', '_strlen', 'stackAlloc', 'setThrew', 'stackRestore', 'setTempRet0', 'getTempRet0', 'stackSave', '_emscripten_autodebug_double', '_emscripten_autodebug_float', '_emscripten_autodebug_i8', '_emscripten_autodebug_i16', '_emscripten_autodebug_i32', '_emscripten_autodebug_i64', '_strncpy', '_strcpy', '_strcat', '_saveSetjmp', '_testSetjmp', '_emscripten_replace_memory', '_bitshift64Shl', '_bitshift64Ashr', '_bitshift64Lshr', 'setAsyncState', 'emtStackSave', 'emtStackRestore', 'getEmtStackMax', 'setEmtStackMax'])
+# The blacklist contains functions we will not emterpret in any case: they are known to be safe to run normally, e.g.
+# because they don't call anything, or they only call trivial things we know are safe.
+# One particularly interesting case is SAFE_FT_MASK: we must not emterpret it, as it appears in expressions like
+#   FUNCTION_TABLE_vi[SAFE_FT_MASK(..) & 7](..)
+# which means that if we are in async mode and reloading the stack to resume, and we need to make that call as
+# part of getting there - say, if an invoke was part of the path to get here, and invoke calls dynCall which
+# calls SAFE_FT_MASK - then we'll end up doing that call during recreating the stack, which breaks. In other
+# words, dynCall_* must be calls without running emterpreted code in them. To avoid that, we blacklist
+# SAFE_FT_MASK, which should be blacklisted anyhow as it has no need for emterpretation.
+BLACKLIST = set(['_malloc', '_free', '_memcpy', '_memmove', '_memset', '_strlen', 'stackAlloc', 'setThrew', 'stackRestore', 'setTempRet0', 'getTempRet0', 'stackSave', '_emscripten_autodebug_double', '_emscripten_autodebug_float', '_emscripten_autodebug_i8', '_emscripten_autodebug_i16', '_emscripten_autodebug_i32', '_emscripten_autodebug_i64', '_strncpy', '_strcpy', '_strcat', '_saveSetjmp', '_testSetjmp', '_emscripten_replace_memory', '_bitshift64Shl', '_bitshift64Ashr', '_bitshift64Lshr', 'setAsyncState', 'emtStackSave', 'emtStackRestore', 'getEmtStackMax', 'setEmtStackMax', 'SAFE_FT_MASK', 'SAFE_HEAP_LOAD', 'SAFE_HEAP_LOAD_D', 'SAFE_HEAP_STORE', 'SAFE_HEAP_STORE_D'])
+
 WHITELIST = []
 
 SYNC_FUNCS = set(['_emscripten_sleep', '_emscripten_sleep_with_yield', '_emscripten_wget_data', '_emscripten_idb_load', '_emscripten_idb_store', '_emscripten_idb_delete', '_emscripten_yield'])