Merge branch 'master' of https://github.com/kripken/emscripten into 1.37.0-unity

Author: jechter

AUTHORS

@@ -267,3 +267,5 @@ a license to everyone to use it as detailed in LICENSE.)
 * Christopher Serr <[email protected]>
 * Aaron Ruß <[email protected]> (copyright owned by DFKI GmbH)
 * Vilibald Wanča <[email protected]>
+* Alex Hixon <[email protected]>
+* Vladimir Davidovich <[email protected]>

cmake/Modules/Platform/Emscripten.cmake

@@ -134,8 +134,6 @@ if (EMSCRIPTEN_FORCE_COMPILERS)
 	set(CMAKE_CXX_COMPILER_ID Clang)
 	set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT 98)
 
-	set(CMAKE_C_COMPILER_TARGET "asmjs-unknown-emscripten")
-	set(CMAKE_CXX_COMPILER_TARGET "asmjs-unknown-emscripten")
 	set(CMAKE_C_PLATFORM_ID "emscripten")
 	set(CMAKE_CXX_PLATFORM_ID "emscripten")
 

emcc.py

@@ -115,6 +115,8 @@ def run():
   if len(sys.argv) <= 1 or ('--help' not in sys.argv and len(sys.argv) >= 2 and sys.argv[1] != '--version'):
     shared.check_sanity(force=DEBUG)
 
+  misc_temp_files = shared.configuration.get_temp_files()
+
   # Handle some global flags
 
   if len(sys.argv) == 1:
@@ -181,6 +183,22 @@ def run():
     print shared.get_llvm_target()
     exit(0)
 
+  elif '--cflags' in sys.argv:
+    # fake running the command, to see the full args we pass to clang
+    debug_env = os.environ.copy()
+    debug_env['EMCC_DEBUG'] = '1'
+    args = filter(lambda x: x != '--cflags', sys.argv)
+    with misc_temp_files.get_file(suffix='.o') as temp_target:
+      input_file = 'hello_world.c'
+      out, err = subprocess.Popen([shared.PYTHON] + args + [shared.path_from_root('tests', input_file), '-c', '-o', temp_target], stderr=subprocess.PIPE, env=debug_env).communicate()
+      lines = filter(lambda x: shared.CLANG_CC in x and input_file in x, err.split(os.linesep))
+      line = lines[0]
+      assert 'running:' in line
+      parts = line.split(' ')[2:]
+      parts = filter(lambda x: x != '-c' and x != '-o' and input_file not in x and temp_target not in x and '-emit-llvm' not in x, parts)
+      print ' '.join(parts)
+    exit(0)
+
   def is_minus_s_for_emcc(newargs, i):
     assert newargs[i] == '-s'
     if i+1 < len(newargs) and '=' in newargs[i+1] and not newargs[i+1].startswith('-'): # -s OPT=VALUE is for us, -s by itself is a linker option
@@ -250,7 +268,11 @@ def filter_emscripten_options(argv):
     if compiler == shared.EMCC: compiler = [shared.PYTHON, shared.EMCC]
     else: compiler = [compiler]
     cmd = compiler + list(filter_emscripten_options(sys.argv[1:]))
-    if not use_js: cmd += shared.EMSDK_OPTS + ['-D__EMSCRIPTEN__', '-DEMSCRIPTEN']
+    if not use_js:
+      cmd += shared.EMSDK_OPTS + ['-D__EMSCRIPTEN__']
+      # The preprocessor define EMSCRIPTEN is deprecated. Don't pass it to code in strict mode. Code should use the define __EMSCRIPTEN__ instead.
+      if not shared.Settings.STRICT:
+        cmd += ['-DEMSCRIPTEN']
     if use_js: cmd += ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=1'] # configure tests should fail when an undefined symbol exists
 
     logging.debug('just configuring: ' + ' '.join(cmd))
@@ -397,8 +419,6 @@ def log_time(name):
 
   use_cxx = True
 
-  misc_temp_files = shared.configuration.get_temp_files()
-
   try:
     with ToolchainProfiler.profile_block('parse arguments and setup'):
       ## Parse args
@@ -918,6 +938,29 @@ def detect_fixed_language_mode(args):
       if separate_asm:
         shared.Settings.SEPARATE_ASM = os.path.basename(asm_target)
 
+      if 'EMCC_STRICT' in os.environ:
+        shared.Settings.STRICT = os.environ.get('EMCC_STRICT') != '0'
+
+      # Libraries are searched before settings_changes are applied, so apply the value for STRICT and ERROR_ON_MISSING_LIBRARIES from
+      # command line already now.
+
+      def get_last_setting_change(setting):
+        return ([None] + filter(lambda x: x.startswith(setting + '='), settings_changes))[-1]
+
+      strict_cmdline = get_last_setting_change('STRICT')
+      if strict_cmdline:
+        shared.Settings.STRICT = int(strict_cmdline[len('STRICT='):])
+
+      if shared.Settings.STRICT:
+        shared.Settings.ERROR_ON_UNDEFINED_SYMBOLS = 1
+        shared.Settings.ERROR_ON_MISSING_LIBRARIES = 1
+
+      error_on_missing_libraries_cmdline = get_last_setting_change('ERROR_ON_MISSING_LIBRARIES')
+      if error_on_missing_libraries_cmdline:
+        shared.Settings.ERROR_ON_MISSING_LIBRARIES = int(error_on_missing_libraries_cmdline[len('ERROR_ON_MISSING_LIBRARIES='):])
+
+      system_js_libraries = []
+
       # Find library files
       for i, lib in libs:
         logging.debug('looking for library "%s"', lib)
@@ -934,8 +977,13 @@ def detect_fixed_language_mode(args):
                 break
             if found: break
           if found: break
-        if not found and lib not in ['GL', 'GLU', 'glut', 'm', 'c', 'SDL', 'stdc++', 'pthread']: # whitelist our default libraries
-          logging.warning('emcc: cannot find library "%s"', lib)
+        if not found:
+          system_js_libraries += shared.Building.path_to_system_js_libraries(lib)
+
+      # Certain linker flags imply some link libraries to be pulled in by default.
+      system_js_libraries += shared.Building.path_to_system_js_libraries_for_settings(settings_changes)
+
+      settings_changes.append('SYSTEM_JS_LIBRARIES="' + ','.join(system_js_libraries) + '"')
 
       # If not compiling to JS, then we are compiling to an intermediate bitcode objects or library, so
       # ignore dynamic linking, since multiple dynamic linkings can interfere with each other
@@ -999,6 +1047,15 @@ def check(input_file):
       if shared.get_llvm_target() == shared.WASM_TARGET:
         shared.Settings.WASM_BACKEND = 1
 
+      if not shared.Settings.STRICT:
+        # The preprocessor define EMSCRIPTEN is deprecated. Don't pass it to code in strict mode. Code should use the define __EMSCRIPTEN__ instead.
+        shared.COMPILER_OPTS += ['-DEMSCRIPTEN']
+
+        # The system include path system/include/emscripten/ is deprecated, i.e. instead of #include <emscripten.h>, one should pass in #include <emscripten/emscripten.h>.
+        # This path is not available in Emscripten strict mode.
+        if shared.USE_EMSDK:
+          shared.C_INCLUDE_PATHS += [shared.path_from_root('system', 'include', 'emscripten')]
+
       # Use settings
 
       try:
@@ -1052,10 +1109,6 @@ def check(input_file):
         assert not use_closure_compiler, 'cannot use closure compiler on shared modules'
         assert not shared.Settings.ALLOW_MEMORY_GROWTH, 'memory growth is not supported with shared modules yet'
 
-      if shared.Settings.ALLOW_MEMORY_GROWTH:
-        logging.warning('not all asm.js optimizations are possible with ALLOW_MEMORY_GROWTH, disabling those')
-        shared.Settings.ASM_JS = 2 # memory growth does not validate as asm.js http://discourse.wicg.io/t/request-for-comments-switching-resizing-heaps-in-asm-js/641/23
-
       if shared.Settings.EMULATE_FUNCTION_POINTER_CASTS:
         shared.Settings.ALIASING_FUNCTION_POINTERS = 0
 
@@ -1155,13 +1208,16 @@ def check(input_file):
 
       if shared.Settings.USE_PTHREADS:
         if shared.Settings.LINKABLE:
-          logging.error('-s LINKABLE=1 is not supported with -s USE_PTHREADS=1!')
+          logging.error('-s LINKABLE=1 is not supported with -s USE_PTHREADS>0!')
           exit(1)
         if shared.Settings.SIDE_MODULE:
-          logging.error('-s SIDE_MODULE=1 is not supported with -s USE_PTHREADS=1!')
+          logging.error('-s SIDE_MODULE=1 is not supported with -s USE_PTHREADS>0!')
           exit(1)
         if shared.Settings.MAIN_MODULE:
-          logging.error('-s MAIN_MODULE=1 is not supported with -s USE_PTHREADS=1!')
+          logging.error('-s MAIN_MODULE=1 is not supported with -s USE_PTHREADS>0!')
+          exit(1)
+        if shared.Settings.EMTERPRETIFY:
+          logging.error('-s EMTERPRETIFY=1 is not supported with -s USE_PTHREADS>0!')
           exit(1)
 
       if shared.Settings.OUTLINING_LIMIT:
@@ -1216,6 +1272,12 @@ def check(input_file):
         #  * and js mem inits are useful for avoiding a side file, but the wasm module avoids that anyhow
         memory_init_file = True
 
+      if shared.Settings.ALLOW_MEMORY_GROWTH and shared.Settings.ASM_JS == 1:
+        # this is an issue in asm.js, but not wasm
+        if not shared.Settings.WASM or 'asmjs' in shared.Settings.BINARYEN_METHOD:
+          logging.warning('not all asm.js optimizations are possible with ALLOW_MEMORY_GROWTH, disabling those')
+          shared.Settings.ASM_JS = 2 # memory growth does not validate as asm.js http://discourse.wicg.io/t/request-for-comments-switching-resizing-heaps-in-asm-js/641/23
+
       if js_opts:
         shared.Settings.RUNNING_JS_OPTS = 1
 
@@ -1987,6 +2049,14 @@ def do_minify(): # minifies the code. this is also when we do certain optimizati
           print jsrun.run_js(shared.path_from_root('tools', 'js-optimizer.js'), shared.NODE_JS, args=[asm_target, 'eliminateDeadGlobals', 'last', 'asm'], stdout=open(temp, 'w'))
           shutil.move(temp, asm_target)
 
+      if shared.Settings.BINARYEN_METHOD:
+        methods = shared.Settings.BINARYEN_METHOD.split(',')
+        valid_methods = ['asmjs', 'native-wasm', 'interpret-s-expr', 'interpret-binary', 'interpret-asm2wasm']
+        for m in methods:
+          if not m.strip() in valid_methods:
+            logging.error('Unrecognized BINARYEN_METHOD "' + m.strip() + '" specified! Please pass a comma-delimited list containing one or more of: ' + ','.join(valid_methods))
+            sys.exit(1)
+
       if shared.Settings.BINARYEN:
         logging.debug('using binaryen, with method: ' + shared.Settings.BINARYEN_METHOD)
         binaryen_bin = os.path.join(shared.Settings.BINARYEN_ROOT, 'bin')

emscripten-version.txt

@@ -1 +1 @@
-"1.36.14"
+"1.37.0"

emscripten.py

@@ -1329,7 +1329,7 @@ def emscript_wasm_backend(infile, settings, outfile, libraries=None, compiler_en
                     '-o', temp_s]
     backend_args += ['-thread-model=single'] # no threads support in backend, tell llc to not emit atomics
     # disable slow and relatively unimportant optimization passes
-    backend_args += ['-combiner-alias-analysis=false', '-combiner-global-alias-analysis=false']
+    backend_args += ['-combiner-global-alias-analysis=false']
 
     # asm.js-style exception handling
     if settings['DISABLE_EXCEPTION_CATCHING'] != 1:
@@ -1422,21 +1422,29 @@ def asmjs_mangle(name):
       # in metadata[declares], the invoke wrappers will be generated in
       # this script later.
       import_type = parts[3][1:]
+      import_name = parts[2][1:-1]
       if import_type == 'memory':
         continue
-      assert import_type == 'func', 'No support for imports other than functions and memories'
-      func_name = parts[2][1:-1]
-      if not func_name.startswith('invoke_'):
-        metadata['declares'].append(func_name)
+      elif import_type == 'func':
+        if not import_name.startswith('invoke_'):
+          metadata['declares'].append(import_name)
+      elif import_type == 'global':
+        metadata['externs'].append('_' + import_name)
+      else:
+        assert False, 'Unhandled import type "%s"' % import_type
     elif line.startswith('  (func '):
       parts = line.split()
       func_name = parts[1][1:]
       metadata['implementedFunctions'].append(func_name)
     elif line.startswith('  (export '):
       parts = line.split()
       export_name = parts[1][1:-1]
-      assert asmjs_mangle(export_name) not in metadata['exports']
-      metadata['exports'].append(export_name)
+      export_type = parts[2][1:]
+      if export_type == 'func':
+        assert asmjs_mangle(export_name) not in metadata['exports']
+        metadata['exports'].append(export_name)
+      else:
+        assert False, 'Unhandled export type "%s"' % export_type
 
   metadata['declares'] = filter(lambda x: not x.startswith('emscripten_asm_const'), metadata['declares']) # we emit those ourselves
 

site/source/docs/compiling/Building-Projects.rst

@@ -268,17 +268,22 @@ The :ref:`Tutorial` showed how :ref:`emcc <emccdoc>` can be used to compile sing
 In addition to the capabilities it shares with *gcc*, *emcc* supports options to optimize code, control what debug information is emitted, generate HTML and other output formats, etc. These options are documented in the :ref:`emcc tool reference <emccdoc>` (``./emcc --help`` on the command line).
 
 
-Alternatives to emcc
-====================
-
-.. tip:: Do not attempt to bypass *emcc* and call the Emscripten tools directly from your build system. 
-
-You can in theory call *clang*, *llvm-ld*, and the other tools yourself. This is however considered dangerous because by default:
-
-- *Clang* does not use the Emscripten-bundled headers, which can lead to various errors. 
-- *llvm-ld* uses unsafe/unportable LLVM optimizations. 
+Detecting Emscripten in Preprocessor
+====================================
 
-*Emcc* automatically ensures the tools are configured and used properly.
+Emscripten provides the following preprocessor macros that can be used to identify the compiler version and platform:
+
+ * The preprocessor define ``__EMSCRIPTEN__`` is always defined when compiling programs with Emscripten.
+ * The preprocessor variables ``__EMSCRIPTEN_major__``, ``__EMSCRIPTEN_minor__`` and ``__EMSCRIPTEN_tiny__`` specify, as integers, the currently used Emscripten compiler version.
+ * Emscripten behaves like a variant of Unix, so the preprocessor defines ``unix``, ``__unix`` and ``__unix__`` are always present when compiling code with Emscripten.
+ * Emscripten uses Clang/LLVM as its underlying codegen compiler, so the preprocessor defines ``__llvm__`` and ``__clang__`` are defined, and the preprocessor defines ``__clang_major__``, ``__clang_minor__`` and ``__clang_patchlevel__`` indicate the version of Clang that is used.
+ * Clang/LLVM is GCC-compatible, so the preprocessor defines ``__GNUC__``, ``__GNUC_MINOR__`` and ``__GNUC_PATCHLEVEL__`` are also defined to represent the level of GCC compatibility that Clang/LLVM provides.
+ * The preprocessor string ``__VERSION__`` indicates the GCC compatible version, which is expanded to also show Emscripten version information.
+ * Likewise, ``__clang_version__`` is present and indicates both Emscripten and LLVM version information.
+ * Emscripten is a 32-bit platform, so ``size_t`` is a 32-bit unsigned integer, ``__POINTER_WIDTH__=32``, ``__SIZEOF_LONG__=4`` and ``__LONG_MAX__`` equals ``2147483647L``.
+ * When targeting asm.js, the preprocessor defines ``__asmjs`` and ``__asmjs__`` are present.
+ * When targeting SSEx SIMD APIs using one of the command line compiler flags ``-msse``, ``-msse2``, ``-msse3``, ``-mssse3``, or ``-msse4.1``, one or more of the preprocessor flags ``__SSE__``, ``__SSE2__``, ``__SSE3__``, ``__SSSE3__``, ``__SSE4_1__`` will be present to indicate available support for these instruction sets.
+ * If targeting the pthreads multithreading support with the compiler & linker flag ``-s USE_PTHREADS=1``, the preprocessor define ``__EMSCRIPTEN_PTHREADS__`` will be present.
 
 
 Examples / test code

site/source/docs/tools_reference/emcc.rst

@@ -450,6 +450,9 @@ Options that are modified or new in *emcc* are listed below:
 ``--output-eol windows|linux``
 	Specifies the line ending to generate for the text files that are outputted. If "--output-eol windows" is passed, the final output files will have Windows \r\n line endings in them. With "--output-eol linux", the final generated files will be written with Unix \n line endings.
 
+``--cflags``
+	Prints out the flags ``emcc`` would pass to ``clang`` to compile source code to object/bitcode form. You can use this to invoke clang yourself, and then run ``emcc`` on those outputs just for the final linking+conversion to JS.
+
 .. _emcc-environment-variables:
 
 Environment variables

src/deps_info.json

@@ -20,7 +20,7 @@
   "freelocale": ["free"],
   "nl_langinfo": ["malloc"],
   "inet_ntoa": ["malloc"],
-  "gethostbyname": ["malloc"],
+  "gethostbyname": ["malloc", "htons"],
   "gethostbyname_r": ["free"],
   "getaddrinfo": ["malloc", "htonl", "htons", "ntohs"],
   "_inet_ntop6_raw": ["ntohs"],
@@ -44,6 +44,8 @@
   "bind": ["htonl", "htons", "ntohs"],
   "connect": ["htonl", "htons", "ntohs"],
   "socket": ["htonl", "htons", "ntohs"],
-  "sleep": ["usleep"]
+  "sleep": ["usleep"],
+  "recv": ["htons"],
+  "send": ["htons"]
 }
 

src/embind/embind.js

@@ -144,6 +144,7 @@ var LibraryEmbind = {
     }
     else {
         Module[name] = value;
+        Module[name].argCount = numArguments;
     }
   },
 
@@ -1949,6 +1950,8 @@ var LibraryEmbind = {
             // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types
             // are resolved. If multiple overloads are registered for this function, the function goes into an overload table.
             if (undefined === proto[methodName].overloadTable) {
+                // Set argCount in case an overload is registered later
+                memberFunction.argCount = argCount - 2;
                 proto[methodName] = memberFunction;
             } else {
                 proto[methodName].overloadTable[argCount - 2] = memberFunction;

src/jsifier.js

@@ -299,7 +299,10 @@ function JSify(data, functionsOnly) {
           print('// STATICTOP = STATIC_BASE + ' + Runtime.alignMemory(Variables.nextIndexedOffset) + ';\n'); // comment as metadata only
         }
         if (BINARYEN) {
+          // export static base and bump, needed for linking in wasm binary's memory, dynamic linking, etc.
           print('var STATIC_BUMP = {{{ STATIC_BUMP }}};');
+          print('Module["STATIC_BASE"] = STATIC_BASE;');
+          print('Module["STATIC_BUMP"] = STATIC_BUMP;');
         }
       }
       var generated = itemsDict.function.concat(itemsDict.type).concat(itemsDict.GlobalVariableStub).concat(itemsDict.GlobalVariable);