Merge tag '1.37.2' of https://github.com/kripken/emscripten into 1.37.2-unity

Author: marco trivellato

AUTHORS

@@ -272,3 +272,5 @@ a license to everyone to use it as detailed in LICENSE.)
 * Christophe Gragnic <[email protected]>
 * Murphy McCauley <[email protected]>
 * Anatoly Trosinenko <[email protected]>
+* Brad Grantham <[email protected]>
+

emcc.py

@@ -1255,6 +1255,11 @@ def check(input_file):
         os.environ['EMCC_WASM_BACKEND_BINARYEN'] = '1'
 
       if shared.Settings.BINARYEN:
+        # set file locations, so that JS glue can find what it needs
+        shared.Settings.WASM_TEXT_FILE = os.path.basename(wasm_text_target)
+        shared.Settings.WASM_BINARY_FILE = os.path.basename(wasm_binary_target)
+        shared.Settings.ASMJS_CODE_FILE = os.path.basename(asm_target)
+
         shared.Settings.ASM_JS = 2 # when targeting wasm, we use a wasm Memory, but that is not compatible with asm.js opts
         debug_level = max(1, debug_level) # keep whitespace readable, for asm.js parser simplicity
         shared.Settings.GLOBAL_BASE = 1024 # leave some room for mapping global vars
@@ -1282,6 +1287,20 @@ def check(input_file):
         if shared.Building.is_wasm_only() and shared.Settings.EVAL_CTORS:
           logging.debug('disabling EVAL_CTORS, as in wasm-only mode it hurts more than it helps. TODO: a wasm version of it')
           shared.Settings.EVAL_CTORS = 0
+        # enable async compilation if optimizing and not turned off manually
+        if opt_level > 0:
+          if 'BINARYEN_ASYNC_COMPILATION=0' not in settings_changes:
+            shared.Settings.BINARYEN_ASYNC_COMPILATION = 1
+        if shared.Settings.BINARYEN_ASYNC_COMPILATION == 1:
+          if shared.Building.is_wasm_only():
+            # async compilation requires a swappable module - we swap it in when it's ready
+            shared.Settings.SWAPPABLE_ASM_MODULE = 1
+          else:
+            # if not wasm-only, we can't do async compilation as the build can run in other
+            # modes than wasm (like asm.js) which may not support an async step
+            shared.Settings.BINARYEN_ASYNC_COMPILATION = 0
+            if 'BINARYEN_ASYNC_COMPILATION=1' in settings_changes:
+              logging.warning('BINARYEN_ASYNC_COMPILATION requested, but disabled since not in wasm-only mode')
 
       # wasm outputs are only possible with a side wasm
       if target.endswith(WASM_ENDINGS):
@@ -1643,9 +1662,11 @@ def save_intermediate(name=None, suffix='js'):
       if DEBUG: save_intermediate('original')
 
       if shared.Settings.WASM_BACKEND:
-        # we also received wasm at this stage
-        wasm_temp = final[:-3] + '.wast'
-        shutil.move(wasm_temp, wasm_text_target)
+        # we also received wast and wasm at this stage
+        temp_basename = final[:-3]
+        wast_temp = temp_basename + '.wast'
+        shutil.move(wast_temp, wasm_text_target)
+        shutil.move(temp_basename + '.wasm', wasm_binary_target)
         open(wasm_text_target + '.mappedGlobals', 'w').write('{}') # no need for mapped globals for now, but perhaps some day
 
       if shared.Settings.CYBERDWARF:
@@ -1685,20 +1706,6 @@ def save_intermediate(name=None, suffix='js'):
         file_code = execute([shared.PYTHON, shared.FILE_PACKAGER, unsuffixed(target) + '.data'] + file_args, stdout=PIPE)[0]
         pre_js = file_code + pre_js
 
-      if shared.Settings.BINARYEN:
-        # add in the glue integration code as a pre-js, so it is optimized together with everything else
-        wasm_js_glue = open(os.path.join(shared.Settings.BINARYEN_ROOT, 'src', 'js', 'wasm.js-post.js')).read()
-        wasm_js_glue = wasm_js_glue.replace('{{{ asmjsCodeFile }}}', '"' + os.path.basename(asm_target) + '"')
-        wasm_js_glue = wasm_js_glue.replace('{{{ wasmTextFile }}}', '"' + os.path.basename(wasm_text_target) + '"')
-        wasm_js_glue = wasm_js_glue.replace('{{{ wasmBinaryFile }}}', '"' + os.path.basename(wasm_binary_target) + '"')
-        if shared.Settings.BINARYEN_METHOD:
-          wasm_js_glue = wasm_js_glue.replace('{{{ wasmJSMethod }}}', '(Module[\'wasmJSMethod\'] || "' + shared.Settings.BINARYEN_METHOD + '")')
-        else:
-          wasm_js_glue = wasm_js_glue.replace('{{{ wasmJSMethod }}}', 'null')
-        wasm_js_glue = wasm_js_glue.replace('{{{ WASM_BACKEND }}}', str(shared.Settings.WASM_BACKEND)) # if wasm backend, wasm contains memory segments
-        wasm_js_glue += '\nintegrateWasmJS(Module);\n' # add a call
-        post_module += str(wasm_js_glue) # we can set up the glue once we have the module
-
       # Apply pre and postjs files
       if pre_js or post_module or post_js:
         logging.debug('applying pre/postjses')
@@ -2060,10 +2067,8 @@ def do_minify(): # minifies the code. this is also when we do certain optimizati
       # Separate out the asm.js code, if asked. Or, if necessary for another option
       if (separate_asm or shared.Settings.BINARYEN) and not shared.Settings.WASM_BACKEND:
         logging.debug('separating asm')
-        with misc_temp_files.get_file(suffix='.js') as temp_target:
-          subprocess.check_call([shared.PYTHON, shared.path_from_root('tools', 'separate_asm.py'), js_target, asm_target, temp_target])
-          generated_text_files_with_native_eols += [asm_target]
-          shutil.move(temp_target, js_target)
+        subprocess.check_call([shared.PYTHON, shared.path_from_root('tools', 'separate_asm.py'), js_target, asm_target, js_target])
+        generated_text_files_with_native_eols += [asm_target]
 
         # extra only-my-code logic
         if shared.Settings.ONLY_MY_CODE:
@@ -2121,26 +2126,27 @@ def do_minify(): # minifies the code. this is also when we do certain optimizati
             cmd += ['--mem-max=' + str(shared.Settings.BINARYEN_MEM_MAX)]
           if shared.Building.is_wasm_only():
             cmd += ['--wasm-only'] # this asm.js is code not intended to run as asm.js, it is only ever going to be wasm, an can contain special fastcomp-wasm support
+          if debug_level >= 2 or profiling_funcs:
+            cmd += ['-g']
+          if emit_symbol_map or shared.Settings.CYBERDWARF:
+            cmd += ['--symbolmap=' + target + '.symbols']
+          cmd += ['-o', wasm_binary_target]
           logging.debug('asm2wasm (asm.js => WebAssembly): ' + ' '.join(cmd))
           TimeLogger.update()
-          subprocess.check_call(cmd, stdout=open(wasm_text_target, 'w'))
+          subprocess.check_call(cmd)
           if import_mem_init:
             # remove and forget about the mem init file in later processing; it does not need to be prefetched in the html, etc.
             os.unlink(memfile)
             memory_init_file = False
           log_time('asm2wasm')
         if shared.Settings.BINARYEN_PASSES:
-          shutil.move(wasm_text_target, wasm_text_target + '.pre')
-          cmd = [os.path.join(binaryen_bin, 'wasm-opt'), wasm_text_target + '.pre', '-o', wasm_text_target] + map(lambda p: '--' + p, shared.Settings.BINARYEN_PASSES.split(','))
+          shutil.move(wasm_binary_target, wasm_binary_target + '.pre')
+          cmd = [os.path.join(binaryen_bin, 'wasm-opt'), wasm_binary_target + '.pre', '-o', wasm_binary_target] + map(lambda p: '--' + p, shared.Settings.BINARYEN_PASSES.split(','))
           logging.debug('wasm-opt on BINARYEN_PASSES: ' + ' '.join(cmd))
           subprocess.check_call(cmd)
-        if 'native-wasm' in shared.Settings.BINARYEN_METHOD or 'interpret-binary' in shared.Settings.BINARYEN_METHOD:
-          cmd = [os.path.join(binaryen_bin, 'wasm-as'), wasm_text_target, '-o', wasm_binary_target]
-          if debug_level >= 2 or profiling_funcs:
-            cmd += ['-g']
-          if emit_symbol_map or shared.Settings.CYBERDWARF:
-            cmd += ['--symbolmap=' + target + '.symbols']
-          logging.debug('wasm-as (text => binary): ' + ' '.join(cmd))
+        if 'interpret-s-expr' in shared.Settings.BINARYEN_METHOD:
+          cmd = [os.path.join(binaryen_bin, 'wasm-dis'), wasm_binary_target, '-o', wasm_text_target]
+          logging.debug('wasm-dis (binary => text): ' + ' '.join(cmd))
           subprocess.check_call(cmd)
         if shared.Settings.BINARYEN_SCRIPTS:
           binaryen_scripts = os.path.join(shared.Settings.BINARYEN_ROOT, 'scripts')

emscripten-version.txt

@@ -1 +1 @@
-"1.37.1"
+"1.37.2"

emscripten.py

@@ -1405,7 +1405,8 @@ def emscript_wasm_backend(infile, settings, outfile, libraries=None, compiler_en
       shutil.copyfile(temp_s, os.path.join(shared.CANONICAL_TEMP_DIR, 'emcc-llvm-backend-output.s'))
 
     assert shared.Settings.BINARYEN_ROOT, 'need BINARYEN_ROOT config set so we can use Binaryen s2wasm on the backend output'
-    wasm = outfile.name[:-3] + '.wast'
+    basename = outfile.name[:-3]
+    wast = basename + '.wast'
     s2wasm_args = [os.path.join(shared.Settings.BINARYEN_ROOT, 'bin', 's2wasm'), temp_s]
     s2wasm_args += ['--emscripten-glue']
     s2wasm_args += ['--global-base=%d' % shared.Settings.GLOBAL_BASE]
@@ -1418,21 +1419,26 @@ def compiler_rt_fail(): raise Exception('Expected wasm_compiler_rt.a to already
       logging.debug('emscript: binaryen s2wasm: ' + ' '.join(s2wasm_args))
       t = time.time()
       #s2wasm_args += ['--debug']
-    shared.check_call(s2wasm_args, stdout=open(wasm, 'w'))
+    shared.check_call(s2wasm_args, stdout=open(wast, 'w'))
+    # Also convert wasm text to binary
+    wasm_as_args = [os.path.join(shared.Settings.BINARYEN_ROOT, 'bin', 'wasm-as'),
+                    wast, '-o', basename + '.wasm']
+    logging.debug('  emscript: binaryen wasm-as: ' + ' '.join(wasm_as_args))
+    shared.check_call(wasm_as_args)
 
   if DEBUG:
     logging.debug('  emscript: binaryen s2wasm took %s seconds' % (time.time() - t))
     t = time.time()
     import shutil
-    shutil.copyfile(wasm, os.path.join(shared.CANONICAL_TEMP_DIR, 'emcc-s2wasm-output.wast'))
+    shutil.copyfile(wast, os.path.join(shared.CANONICAL_TEMP_DIR, 'emcc-s2wasm-output.wast'))
 
   # js compiler
 
   if DEBUG: logging.debug('emscript: js compiler glue')
 
   # Integrate info from backend
 
-  output = open(wasm).read()
+  output = open(wast).read()
   parts = output.split('\n;; METADATA:')
   assert len(parts) == 2
   metadata_raw = parts[1]
@@ -1468,7 +1474,7 @@ def asmjs_mangle(name):
   metadata['initializers'] = [asmjs_mangle(i) for i in metadata['initializers']]
 
   # TODO: emit it from s2wasm; for now, we parse it right here
-  for line in open(wasm).readlines():
+  for line in open(wast).readlines():
     if line.startswith('  (import '):
       parts = line.split()
       # Don't include Invoke wrapper names (for asm.js-style exception handling)
@@ -1635,7 +1641,7 @@ def math_fix(g):
 
   # Asm.js-style exception handling: invoke wrapper generation
   invoke_wrappers = ''
-  with open(wasm) as f:
+  with open(wast) as f:
     for line in f:
       if line.startswith('  (import '):
         parts = line.split()

site/source/docs/porting/multimedia_and_graphics/OpenGL-support.rst

@@ -63,7 +63,7 @@ In this mode (``-s LEGACY_GL_EMULATION=1``), there are a few extra flags that ca
 What if my codebase depends on an desktop OpenGL feature that is currently unsupported?
 ---------------------------------------------------------------------------------------
 
-You can consider building the codebase against the `Regal <https://github.com/p3/regal>`_ Desktop OpenGL emulation library. That project offers a more complete set of emulated Desktop OpenGL features on top of OpenGL ES 2.0. If the built-in Desktop OpenGL emulation works but is too slow, it may also be possible to get better performance by using Regal.
+You can consider building the codebase against the `Regal <https://github.com/p3/regal>`_ Desktop OpenGL emulation library, which aims to support Desktop OpenGL features on top of OpenGL ES 2.0. This may work better or worse than Emscripten's GL emulation depending on the project.
 
 OpenGL ES extensions
 ====================
@@ -86,4 +86,4 @@ The Emscripten :ref:`bug tracker <bug-reports>` has labels specific to OpenGL an
 
 **Footnotes:**
 
-.. [#f1] Client-side arrays are missing from WebGL because they are less efficient than properly using GPU-side data.
+.. [#f1] Client-side arrays are missing from WebGL because they are less efficient than properly using GPU-side data.

src/Fetch.js

@@ -478,7 +478,7 @@ function emscripten_start_fetch(fetch, successcb, errorcb, progresscb) {
 #if FETCH_DEBUG
     console.log('fetch: operation success. e: ' + e);
 #endif
-    if (onsuccess && Runtime.dynCall) Runtime.dynCall('vi', onsuccess, [fetch]);
+    if (onsuccess && Runtime.dynCall) Module['dynCall_vi'](onsuccess, fetch);
     else if (successcb) successcb(fetch);
   };
 
@@ -497,20 +497,20 @@ function emscripten_start_fetch(fetch, successcb, errorcb, progresscb) {
 #endif
     };
     __emscripten_fetch_cache_data(Fetch.dbInstance, fetch, xhr.response, storeSuccess, storeError);
-    if (onsuccess && Runtime.dynCall) Runtime.dynCall('vi', onsuccess, [fetch]);
+    if (onsuccess && Runtime.dynCall) Module['dynCall_vi'](onsuccess, fetch);
     else if (successcb) successcb(fetch);
   };
 
   var reportProgress = function(fetch, xhr, e) {
-    if (onprogress && Runtime.dynCall) Runtime.dynCall('vi', onprogress, [fetch]);      
+    if (onprogress && Runtime.dynCall) Module['dynCall_vi'](onprogress, fetch);
     else if (progresscb) progresscb(fetch);
   };
 
   var reportError = function(fetch, xhr, e) {
 #if FETCH_DEBUG
     console.error('fetch: operation failed: ' + e);
 #endif
-    if (onerror && Runtime.dynCall) Runtime.dynCall('vi', onerror, [fetch]);
+    if (onerror && Runtime.dynCall) Module['dynCall_vi'](onerror, fetch);
     else if (errorcb) errorcb(fetch);
   };
 

src/deps_info.json

@@ -10,7 +10,7 @@
   "realloc": ["malloc", "free"],
   "getlogin": ["malloc"],
   "tmpnam": ["malloc"],
-  "mmap": ["malloc"],
+  "mmap": ["memalign"],
   "realpath": ["malloc"],
   "strerror": ["malloc"],
   "__ctype_b_loc": ["malloc"],

src/library.js

@@ -951,15 +951,15 @@ LibraryManager.library = {
   llvm_ctlz_i8: function(x, isZeroUndef) {
     x = x | 0;
     isZeroUndef = isZeroUndef | 0;
-    return (Math_clz32(x) | 0) - 24 | 0;
+    return (Math_clz32(x & 0xff) | 0) - 24 | 0;
   },
 
   llvm_ctlz_i16__asm: true,
   llvm_ctlz_i16__sig: 'ii',
   llvm_ctlz_i16: function(x, isZeroUndef) {
     x = x | 0;
     isZeroUndef = isZeroUndef | 0;
-    return (Math_clz32(x) | 0) - 16 | 0
+    return (Math_clz32(x & 0xffff) | 0) - 16 | 0
   },
 
   llvm_ctlz_i64__asm: true,
@@ -1092,10 +1092,10 @@ LibraryManager.library = {
       if (info.refcount === 0 && !info.rethrown) {
         if (info.destructor) {
 #if WASM_BACKEND == 0
-          Runtime.dynCall('vi', info.destructor, [ptr]);
+          Module['dynCall_vi'](info.destructor, ptr);
 #else
           // In Wasm, destructors return 'this' as in ARM
-          Runtime.dynCall('ii', info.destructor, [ptr]);
+          Module['dynCall_ii'](info.destructor, ptr);
 #endif
         }
         delete EXCEPTIONS.infos[ptr];
@@ -4192,7 +4192,7 @@ LibraryManager.library = {
     var trace = _emscripten_get_callstack_js();
     var parts = trace.split('\n');
     for (var i = 0; i < parts.length; i++) {
-      var ret = Runtime.dynCall('iii', [0, arg]);
+      var ret = Module['dynCall_iii'](func, 0, arg);
       if (ret !== 0) return;
     }
   },

src/library_async.js

@@ -189,7 +189,31 @@ mergeInto(LibraryManager.library, {
   emscripten_yield__asm: true,
   emscripten_yield: function() {
     ___async = 1;
-  }
+  },
+
+  emscripten_wget__deps: ['emscripten_async_resume', '$PATH', '$Browser'],
+  emscripten_wget: function(url, file) {
+    var _url = Pointer_stringify(url);
+    var _file = Pointer_stringify(file);
+    _file = PATH.resolve(FS.cwd(), _file);
+    asm.setAsync();
+    Module['noExitRuntime'] = true;
+    var destinationDirectory = PATH.dirname(_file);
+    FS.createPreloadedFile(
+      destinationDirectory,
+      PATH.basename(_file),
+      _url, true, true,
+      _emscripten_async_resume,
+      _emscripten_async_resume,
+      undefined, // dontCreateFile
+      undefined, // canOwn
+      function() { // preFinish
+        // if the destination directory does not yet exist, create it
+        FS.mkdirTree(destinationDirectory);
+      }
+    );
+  },
+
 #else // ASYNCIFY
 
 #if EMTERPRETIFY_ASYNC
@@ -344,12 +368,53 @@ mergeInto(LibraryManager.library, {
     }, true);
   },
 
-#else
+  emscripten_wget__deps: ['$EmterpreterAsync', '$PATH', '$FS', '$Browser'],
+  emscripten_wget: function(url, file) {
+    EmterpreterAsync.handle(function(resume) {
+      var _url = Pointer_stringify(url);
+      var _file = Pointer_stringify(file);
+      _file = PATH.resolve(FS.cwd(), _file);
+      var destinationDirectory = PATH.dirname(_file);
+      FS.createPreloadedFile(
+        destinationDirectory,
+        PATH.basename(_file),
+        _url, true, true,
+        resume,
+        resume,
+        undefined, // dontCreateFile
+        undefined, // canOwn
+        function() { // preFinish
+          // if the destination directory does not yet exist, create it
+          FS.mkdirTree(destinationDirectory);
+        }
+      );
+    });
+  },
+
+  emscripten_wget_data__deps: ['$EmterpreterAsync', '$Browser'],
+  emscripten_wget_data: function(url, pbuffer, pnum, perror) {
+    EmterpreterAsync.handle(function(resume) {
+      Browser.asyncLoad(Pointer_stringify(url), function(byteArray) {
+        resume(function() {
+          // can only allocate the buffer after the resume, not during an asyncing
+          var buffer = _malloc(byteArray.length); // must be freed by caller!
+          HEAPU8.set(byteArray, buffer);
+          {{{ makeSetValueAsm('pbuffer', 0, 'buffer', 'i32') }}};
+          {{{ makeSetValueAsm('pnum',  0, 'byteArray.length', 'i32') }}};
+          {{{ makeSetValueAsm('perror',  0, '0', 'i32') }}};
+        });
+      }, function() {
+        {{{ makeSetValueAsm('perror',  0, '1', 'i32') }}};
+        resume();
+      }, true /* no need for run dependency, this is async but will not do any prepare etc. step */ );
+    });
+  },
+
+#else // EMTERPRETIFY_ASYNC
+
   emscripten_sleep: function() {
     throw 'Please compile your program with async support in order to use asynchronous operations like emscripten_sleep';
   },
-#endif
-
   emscripten_coroutine_create: function() {
     throw 'Please compile your program with async support in order to use asynchronous operations like emscripten_coroutine_create';
   },
@@ -358,7 +423,14 @@ mergeInto(LibraryManager.library, {
   },
   emscripten_yield: function() {
     throw 'Please compile your program with async support in order to use asynchronous operations like emscripten_yield';
-  }
-#endif
+  },
+  emscripten_wget: function(url, file) {
+    throw 'Please compile your program with async support in order to use asynchronous operations like emscripten_wget';
+  },
+  emscripten_wget_data: function(url, file) {
+    throw 'Please compile your program with async support in order to use asynchronous operations like emscripten_wget_data';
+  },
+#endif // EMTERPRETIFY_ASYNC
+#endif // ASYNCIFY
 });