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

@@ -69,6 +69,9 @@ Current Trunk
   this might result in slightly slower link times with the old fastcomp
   backend.  In order to exclude these libraries build with `-nostdlib` and/or
   `-nostdlib++`.
+- Remove emterpreter and ``EMTERPRETIFY`` settings.  Emterpreter has largerly
+  been replaced by asyncify and is fastcomp only so due for removing in
+  the near future anyway.
 
 1.39.15: 05/06/2020
 -------------------

docs/emcc.txt

@@ -191,9 +191,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

emcc.py

@@ -104,8 +104,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',
@@ -417,11 +415,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:
@@ -1219,9 +1216,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)')
 
@@ -1459,19 +1453,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")
 
@@ -1635,8 +1616,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:
@@ -1991,9 +1970,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')
 
@@ -2680,14 +2656,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,
@@ -2723,7 +2691,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:
@@ -2747,9 +2715,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()
@@ -3123,64 +3088,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]
-  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')
-
-
 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'),
@@ -3581,28 +3488,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
 
 
@@ -1918,35 +1903,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/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
 --------

site/source/docs/api_reference/preamble.js.rst

@@ -70,7 +70,7 @@ Calling compiled C functions from JavaScript
   :returns: The result of the function call as a native JavaScript value (as in ``returnType``) or, if the ``async`` option is set, a JavaScript Promise of the result.
   :opts: An optional options object. It can contain the following properties:
 
-      - ``async``: If ``true``, implies that the ccall will perform an async operation. This assumes you are using the Emterpreter-Async option for your code.
+      - ``async``: If ``true``, implies that the ccall will perform an async operation. This assumes you are build with asyncify support.
 
   .. note:: Async calls currently don't support promise error handling.
 

site/source/docs/optimizing/Optimizing-Code.rst

@@ -80,7 +80,6 @@ In addition to the above, the following tips can help to reduce code size:
 - Use :ref:`the closure compiler <emcc-closure>` on the non-compiled code: ``--closure 1``. This can hugely reduce the size of the support JavaScript code, and is highly recommended. However, if you add your own additional JavaScript code (in a ``--pre-js``, for example) then you need to make sure it uses `closure annotations properly <https://developers.google.com/closure/compiler/docs/api-tutorial3>`_.
 - `Floh's blogpost on this topic <http://floooh.github.io/2016/08/27/asmjs-diet.html>`_ is very helpful.
 - Make sure to use gzip compression on your webserver, which all browsers now support.
-- You can move some of your code into the `Emterpreter <https://github.com/emscripten-core/emscripten/wiki/Emterpreter>`_, which will then run much slower (as it is interpreted), but it will transfer all that code into a smaller amount of data.
 
 The following compiler settings can help (see ``src/settings.js`` for more details):
 

site/source/docs/porting/asyncify.rst

@@ -303,10 +303,10 @@ later callback, when nothing else is on the stack.
 Migrating from older APIs
 #########################
 
-If you have code using the Emterpreter-Async API, or the old Asyncify, then the
-new API is somewhat different, and you may need some minor changes:
+If you have code uses the old Emterpreter-Async API, or the old Asyncify, then
+the new API is somewhat different, and you may need some minor changes:
 
- * The Emterpreter has "yielding" as a concept, but it isn't needed in Asyncify.
+ * The Emterpreter had "yielding" as a concept, but it isn't needed in Asyncify.
    You can replace ``emscripten_sleep_with_yield()`` calls with ``emscripten_sleep()``.
  * The JS API is different. See notes above on ``Asyncify.handleSleep()``, and
    see ``src/library_async.js`` for more examples.