Remove emterpreter support.

Emterpreter has largerly been replaces by asyncify and is fastcomp only
so due for removing in the near future anyway.

The reason I'm pulling this forward ahead of fastcomp deprecation
is that it unblocks some other refactoring I'm working on.

Author: sbc100

ChangeLog.md

@@ -39,6 +39,9 @@ Current Trunk
 - Remove `BINARYEN_PASSES` settings.  We still have `BINARYEN_EXTRA_PASSES`, but
   completely overriding the set of passes from the command line didn't make much
   sense.
+- Remove emterpreter and ``EMTERPRETIFY`` settings.  Emterpreter has largerly
+  been replaces by asyncify and is fastcomp only so due for removing in
+  the near future anyway.
 
 v1.39.13: 04/17/2020
 --------------------

emcc.py

@@ -41,7 +41,7 @@
 
 import emscripten
 from tools import shared, system_libs, client_mods, js_optimizer, jsrun, colored_logger, diagnostics
-from tools.shared import unsuffixed, unsuffixed_basename, WINDOWS, safe_copy, safe_move, run_process, asbytes, read_and_preprocess, exit_with_error, DEBUG
+from tools.shared import unsuffixed, unsuffixed_basename, WINDOWS, safe_move, run_process, asbytes, read_and_preprocess, exit_with_error, DEBUG
 from tools.response_file import substitute_response_files
 from tools.minimal_runtime_shell import generate_minimal_runtime_html
 import tools.line_endings
@@ -96,8 +96,6 @@
 
 LIB_PREFIXES = ('', 'lib')
 
-DEFERRED_RESPONSE_FILES = ('EMTERPRETIFY_BLACKLIST', 'EMTERPRETIFY_WHITELIST', 'EMTERPRETIFY_SYNCLIST')
-
 DEFAULT_ASYNCIFY_IMPORTS = [
   'emscripten_sleep', 'emscripten_wget', 'emscripten_wget_data', 'emscripten_idb_load',
   'emscripten_idb_store', 'emscripten_idb_delete', 'emscripten_idb_exists',
@@ -407,11 +405,10 @@ def standardize_setting_change(key, value):
       value = str(shared.expand_byte_size_suffixes(value))
 
     if value[0] == '@':
-      if key not in DEFERRED_RESPONSE_FILES:
-        filename = value[1:]
-        if not os.path.exists(filename):
-          exit_with_error('%s: file not found parsing argument: %s' % (filename, change))
-        value = open(filename).read()
+      filename = value[1:]
+      if not os.path.exists(filename):
+        exit_with_error('%s: file not found parsing argument: %s' % (filename, change))
+      value = open(filename).read()
     else:
       value = value.replace('\\', '\\\\')
     try:
@@ -1189,9 +1186,6 @@ def check(input_file):
       diagnostics.warning('emcc', 'disabling closure because debug info was requested')
       options.use_closure_compiler = False
 
-    if shared.Settings.EMTERPRETIFY_FILE and shared.Settings.SINGLE_FILE:
-      exit_with_error('cannot have both EMTERPRETIFY_FILE and SINGLE_FILE enabled at the same time')
-
     if shared.Settings.WASM == 2 and shared.Settings.SINGLE_FILE:
       exit_with_error('cannot have both WASM=2 and SINGLE_FILE enabled at the same time (pick either JS to target with -s WASM=0 or Wasm to target with -s WASM=1)')
 
@@ -1422,19 +1416,6 @@ def has_c_source(args):
       if not shared.Settings.WASM_BACKEND:
         exit_with_error('ASYNCIFY has been removed from fastcomp. There is a new implementation which can be used in the upstream wasm backend.')
 
-    if shared.Settings.EMTERPRETIFY:
-      diagnostics.warning('emterpreter', 'emterpreter is soon to be removed.  If you depend on this feature please reach out on github for help transitioning.')
-      shared.Settings.FINALIZE_ASM_JS = 0
-      shared.Settings.SIMPLIFY_IFS = 0 # this is just harmful for emterpreting
-      shared.Settings.EXPORTED_FUNCTIONS += ['emterpret']
-      if not options.js_opts:
-        logger.debug('enabling js opts for EMTERPRETIFY')
-        options.js_opts = True
-      options.force_js_opts = True
-      if options.use_closure_compiler == 2:
-         exit_with_error('EMTERPRETIFY requires valid asm.js, and is incompatible with closure 2 which disables that')
-      assert not use_source_map(options), 'EMTERPRETIFY is not compatible with source maps (maps are not useful in emterpreted code, and splitting out non-emterpreted source maps is not yet implemented)'
-
     if shared.Settings.DISABLE_EXCEPTION_THROWING and not shared.Settings.DISABLE_EXCEPTION_CATCHING:
       exit_with_error("DISABLE_EXCEPTION_THROWING was set (probably from -fno-exceptions) but is not compatible with enabling exception catching (DISABLE_EXCEPTION_CATCHING=0). If you don't want exceptions, set DISABLE_EXCEPTION_CATCHING to 1; if you do want exceptions, don't link with -fno-exceptions")
 
@@ -1590,8 +1571,6 @@ def include_and_export(name):
         exit_with_error('-s SIDE_MODULE=1 is not supported with -s USE_PTHREADS>0!')
       if shared.Settings.MAIN_MODULE:
         exit_with_error('-s MAIN_MODULE=1 is not supported with -s USE_PTHREADS>0!')
-      if shared.Settings.EMTERPRETIFY:
-        exit_with_error('-s EMTERPRETIFY=1 is not supported with -s USE_PTHREADS>0!')
       if shared.Settings.PROXY_TO_WORKER:
         exit_with_error('--proxy-to-worker is not supported with -s USE_PTHREADS>0! Use the option -s PROXY_TO_PTHREAD=1 if you want to run the main thread of a multithreaded application in a web worker.')
     else:
@@ -1940,9 +1919,6 @@ def check_human_readable_list(items):
       exit_with_error('memory growth is not supported with shared asm.js modules')
 
     if shared.Settings.MINIMAL_RUNTIME:
-      if shared.Settings.EMTERPRETIFY:
-        exit_with_error('-s EMTERPRETIFY=1 is not supported with -s MINIMAL_RUNTIME=1')
-
       if shared.Settings.PRECISE_F32 == 2:
         exit_with_error('-s PRECISE_F32=2 is not supported with -s MINIMAL_RUNTIME=1')
 
@@ -2617,14 +2593,6 @@ def get_eliminate():
 
           optimizer.queue += ['simplifyExpressions']
 
-          if shared.Settings.EMTERPRETIFY:
-            # emterpreter code will not run through a JS optimizing JIT, do more work ourselves
-            optimizer.queue += ['localCSE']
-
-      if shared.Settings.EMTERPRETIFY:
-        # add explicit label setting, as we will run aggressiveVariableElimination late, *after* 'label' is no longer notable by name
-        optimizer.queue += ['safeLabelSetting']
-
       if shared.Settings.OPT_LEVEL >= 1 and options.js_opts:
         if shared.Settings.OPT_LEVEL >= 2:
           # simplify ifs if it is ok to make the code somewhat unreadable,
@@ -2660,7 +2628,7 @@ def get_eliminate():
 
       if options.js_opts:
         # some compilation modes require us to minify later or not at all
-        if not shared.Settings.EMTERPRETIFY and not shared.Settings.WASM:
+        if not shared.Settings.WASM:
           optimizer.do_minify()
 
         if shared.Settings.OPT_LEVEL >= 2:
@@ -2684,9 +2652,6 @@ def get_eliminate():
     log_time('js opts')
 
     with ToolchainProfiler.profile_block('final emitting'):
-      if shared.Settings.EMTERPRETIFY:
-        emterpretify(js_target, optimizer, options)
-
       # Remove some trivial whitespace
       # TODO: do not run when compress has already been done on all parts of the code
       # src = open(final).read()
@@ -3048,78 +3013,6 @@ def consume_arg():
   return options, settings_changes, newargs
 
 
-def emterpretify(js_target, optimizer, options):
-  global final
-  optimizer.flush('pre-emterpretify')
-  logger.debug('emterpretifying')
-  blacklist = shared.Settings.EMTERPRETIFY_BLACKLIST
-  whitelist = shared.Settings.EMTERPRETIFY_WHITELIST
-  synclist = shared.Settings.EMTERPRETIFY_SYNCLIST
-  if type(blacklist) == list:
-    blacklist = json.dumps(blacklist)
-  if type(whitelist) == list:
-    whitelist = json.dumps(whitelist)
-  if type(synclist) == list:
-    synclist = json.dumps(synclist)
-
-  args = [shared.PYTHON,
-          shared.path_from_root('tools', 'emterpretify.py'),
-          js_target,
-          final + '.em.js',
-          blacklist,
-          whitelist,
-          synclist,
-          str(shared.Settings.SWAPPABLE_ASM_MODULE)]
-  if shared.Settings.EMTERPRETIFY_ASYNC:
-    args += ['ASYNC=1']
-  if shared.Settings.EMTERPRETIFY_ADVISE:
-    args += ['ADVISE=1']
-  if options.profiling or options.profiling_funcs:
-    args += ['PROFILING=1']
-  if shared.Settings.ASSERTIONS:
-    args += ['ASSERTIONS=1']
-  if shared.Settings.PRECISE_F32:
-    args += ['FROUND=1']
-  if shared.Settings.ALLOW_MEMORY_GROWTH:
-    args += ['MEMORY_SAFE=1']
-  if shared.Settings.EMTERPRETIFY_FILE:
-    args += ['FILE="' + shared.Settings.EMTERPRETIFY_FILE + '"']
-
-  try:
-    # move temp js to final position, alongside its mem init file
-    shutil.move(final, js_target)
-    shared.check_call(args)
-  finally:
-    shared.try_delete(js_target)
-
-  final = final + '.em.js'
-
-  if shared.Settings.EMTERPRETIFY_ADVISE:
-    logger.warning('halting compilation due to EMTERPRETIFY_ADVISE')
-    sys.exit(0)
-
-  # minify (if requested) after emterpreter processing, and finalize output
-  logger.debug('finalizing emterpreted code')
-  shared.Settings.FINALIZE_ASM_JS = 1
-  if not shared.Settings.WASM:
-    optimizer.do_minify()
-  optimizer.queue += ['last']
-  optimizer.flush('finalizing-emterpreted-code')
-
-  # finalize the original as well, if we will be swapping it in (TODO: add specific option for this)
-  if shared.Settings.SWAPPABLE_ASM_MODULE:
-    real = final
-    original = js_target + '.orig.js' # the emterpretify tool saves the original here
-    final = original
-    logger.debug('finalizing original (non-emterpreted) code at ' + final)
-    if not shared.Settings.WASM:
-      optimizer.do_minify()
-    optimizer.queue += ['last']
-    optimizer.flush('finalizing-original-code')
-    safe_copy(final, original)
-    final = real
-
-
 def emit_js_source_maps(target, js_transform_tempfiles):
   logger.debug('generating source maps')
   jsrun.run_js_tool(shared.path_from_root('tools', 'source-maps', 'sourcemapper.js'),
@@ -3527,28 +3420,6 @@ def generate_traditional_runtime_html(target, options, js_target, target_basenam
                                     separate_asm=options.separate_asm)
 
   if not shared.Settings.SINGLE_FILE:
-    if shared.Settings.EMTERPRETIFY_FILE:
-      # We need to load the emterpreter file before anything else, it has to be synchronously ready
-      script.un_src()
-      script.inline = '''
-          var emterpretURL = '%s';
-          var emterpretXHR = new XMLHttpRequest();
-          emterpretXHR.open('GET', emterpretURL, true);
-          emterpretXHR.responseType = 'arraybuffer';
-          emterpretXHR.onload = function() {
-            if (emterpretXHR.status === 200 || emterpretXHR.status === 0) {
-              Module.emterpreterFile = emterpretXHR.response;
-            } else {
-              var emterpretURLBytes = tryParseAsDataURI(emterpretURL);
-              if (emterpretURLBytes) {
-                Module.emterpreterFile = emterpretURLBytes.buffer;
-              }
-            }
-%s
-          };
-          emterpretXHR.send(null);
-''' % (shared.JS.get_subresource_location(shared.Settings.EMTERPRETIFY_FILE), script.inline)
-
     if options.memory_init_file and not shared.Settings.MEM_INIT_IN_WASM:
       # start to load the memory init file in the HTML, in parallel with the JS
       script.un_src()

emscripten.py

@@ -521,7 +521,6 @@ def create_module_asmjs(function_table_sigs, metadata,
     temp_float = '  var tempFloat = %s;\n' % ('Math_fround(0)' if provide_fround() else '0.0')
   else:
     temp_float = ''
-  async_state = '  var asyncState = 0;\n' if shared.Settings.EMTERPRETIFY_ASYNC else ''
   f0_fround = '  const f0 = Math_fround(0);\n' if provide_fround() else ''
 
   replace_memory = create_replace_memory(metadata)
@@ -530,7 +529,7 @@ def create_module_asmjs(function_table_sigs, metadata,
 
   asm_end = create_asm_end(exports)
 
-  asm_variables = collapse_redundant_vars(memory_views + asm_global_vars + asm_temp_vars + asm_runtime_thread_local_vars + '\n' + asm_global_funcs + stack + temp_float + async_state + f0_fround)
+  asm_variables = collapse_redundant_vars(memory_views + asm_global_vars + asm_temp_vars + asm_runtime_thread_local_vars + '\n' + asm_global_funcs + stack + temp_float + f0_fround)
   asm_global_initializer = create_global_initializer(metadata['initializers'])
 
   module = [
@@ -954,11 +953,6 @@ def get_exported_implemented_functions(all_exported_functions, all_implemented,
   if shared.Settings.USE_PTHREADS:
     funcs += ['asmJsEstablishStackFrame']
 
-  if shared.Settings.EMTERPRETIFY:
-    funcs += ['emterpret']
-    if shared.Settings.EMTERPRETIFY_ASYNC:
-      funcs += ['setAsyncState', 'emtStackSave', 'emtStackRestore', 'getEmtStackMax', 'setEmtStackMax']
-
   return sorted(set(funcs))
 
 
@@ -1005,10 +999,6 @@ def include_asm_consts(pre, forwarded_json, metadata):
         proxy_args = ['-1 - code', str(int(sync_proxy))] + args
         pre_asm_const += '  if (ENVIRONMENT_IS_PTHREAD) { ' + proxy_debug_print(sync_proxy) + 'return _emscripten_proxy_to_main_thread_js(' + ', '.join(proxy_args) + '); }\n'
 
-    if shared.Settings.EMTERPRETIFY_ASYNC and shared.Settings.ASSERTIONS:
-      # we cannot have an EM_ASM on the stack when saving/loading
-      pre_asm_const += "  assert(typeof EmterpreterAsync !== 'object' || EmterpreterAsync.state !== 2, 'cannot have an EM_ASM on the stack when emterpreter pauses/resumes - the JS is not emterpreted, so we would end up running it again from the start');\n"
-
     asm_const_funcs.append(r'''
 function _emscripten_asm_const_%s(%s) {
 %s  return ASM_CONSTS[code](%s);
@@ -1352,7 +1342,7 @@ def closure(other):
 def asm_backend_uses(metadata, symbol):
   # If doing dynamic linking, we should generate full set of runtime primitives, since we cannot know up front ahead
   # of time what the dynamically linked in modules will need. Also with SAFE_HEAP and Emterpretify, generate full set of views.
-  if shared.Settings.MAIN_MODULE or shared.Settings.SIDE_MODULE or shared.Settings.SAFE_HEAP or shared.Settings.EMTERPRETIFY:
+  if shared.Settings.MAIN_MODULE or shared.Settings.SIDE_MODULE or shared.Settings.SAFE_HEAP:
     return True
 
   # Allow querying asm_backend_uses(metadata, 'Math.') to find if any of the Math objects are used
@@ -1609,8 +1599,6 @@ def create_basic_funcs(function_table_sigs, invoke_function_names):
   basic_funcs = shared.Settings.RUNTIME_FUNCS_TO_IMPORT
   if shared.Settings.STACK_OVERFLOW_CHECK and not shared.Settings.MINIMAL_RUNTIME:
     basic_funcs += ['abortStackOverflow']
-  if shared.Settings.EMTERPRETIFY:
-    basic_funcs += ['abortStackOverflowEmterpreter']
   if shared.Settings.SAFE_HEAP:
     if asm_safe_heap():
       basic_funcs += ['segfault', 'alignfault', 'ftfault']
@@ -1646,9 +1634,6 @@ def create_basic_vars(exported_implemented_functions, forwarded_json, metadata):
       # wasm side modules have a specific convention for these
       basic_vars += ['__memory_base', '__table_base']
 
-  if shared.Settings.EMTERPRETIFY:
-    basic_vars += ['EMTSTACKTOP', 'EMT_STACK_MAX', 'eb']
-
   return basic_vars
 
 
@@ -1915,35 +1900,6 @@ def create_runtime_funcs_asmjs(exports, metadata):
   tempDoublePtr = STACKTOP;
   STACKTOP = (STACKTOP + 16)|0;
 }
-''')
-
-  if shared.Settings.EMTERPRETIFY:
-    funcs.append('''
-function emterpret(pc) { // this will be replaced when the emterpreter code is generated; adding it here allows validation until then
-  pc = pc | 0;
-  assert(0);
-}''')
-
-  if shared.Settings.EMTERPRETIFY_ASYNC:
-    funcs.append('''
-function setAsyncState(x) {
-  x = x | 0;
-  asyncState = x;
-}
-function emtStackSave() {
-  return EMTSTACKTOP|0;
-}
-function emtStackRestore(x) {
-  x = x | 0;
-  EMTSTACKTOP = x;
-}
-function getEmtStackMax() {
-  return EMT_STACK_MAX | 0;
-}
-function setEmtStackMax(x) {
-  x = x | 0;
-  EMT_STACK_MAX = x;
-}
 ''')
 
   if asm_safe_heap():

site/build/text/docs/tools_reference/emcc.txt

@@ -184,9 +184,9 @@ Options that are modified or new in *emcc* are listed below:
    You normally don't need to specify this option, as "-O" with an
    optimization level will set a good value.
 
-   Note: Some options might override this flag (e.g. "EMTERPRETIFY",
-     "DEAD_FUNCTIONS", "SAFE_HEAP" and "SPLIT_MEMORY" override the
-     value with "js-opts=1"), because they depend on the js-optimizer.
+   Note: Some options might override this flag (e.g. "DEAD_FUNCTIONS",
+     "SAFE_HEAP" and "SPLIT_MEMORY" override the value with "js-opts=1"),
+     because they depend on the js-optimizer.
 
 "--llvm-opts <level>"
    Enables LLVM optimizations, relevant when we call the LLVM

site/source/docs/api_reference/emscripten.h.rst

@@ -1039,7 +1039,7 @@ Functions
   Returns whether pseudo-synchronous functions can be used.
 
   :rtype: int
-  :returns: 1 if program was compiled with ASYNCIFY=1 or EMTERPRETER_ASYNC=1, 0 otherwise.
+  :returns: 1 if program was compiled with ASYNCIFY=1, 0 otherwise.
 
 
 .. c:function:: void emscripten_debugger()
@@ -1252,7 +1252,7 @@ Typedefs
 Pseudo-synchronous functions
 ============================
 
-These functions require Asyncify (``-s ASYNCIFY=1``) with the wasm backend, or Emterpreter-async with fastcomp (``-s EMTERPRETIFY=1 -s EMTERPRETIFY_ASYNC=1``). These functions are asynchronous but appear synchronous in C. See `Asyncify <https://emscripten.org/docs/porting/asyncify.html>`_ and `Emterpreter <https://emscripten.org/docs/porting/emterpreter.html>`_ for more details.
+These functions require Asyncify (``-s ASYNCIFY=1``). These functions are asynchronous but appear synchronous in C. See `Asyncify <https://emscripten.org/docs/porting/asyncify.html>`_ for more details.
 
 Sleeping
 --------