diff --git a/AUTHORS b/AUTHORS
index 137efb000e3cc..dc848d343384c 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -139,3 +139,6 @@ a license to everyone to use it as detailed in LICENSE.)
 * Usagi Ito <usagi@WonderRabbitProject.net>
 * Camilo Polymeris <cpolymeris@gmail.com>
 * Markus Henschel <markus.henschel@yager.de>
+* Ophir Lojkine <ophir.lojkine@eleves.ec-nantes.fr>
+* Ryan Sturgell <ryan.sturgell@gmail.com> (copyright owned by Google, Inc.)
+
diff --git a/emcc b/emcc
index 2dc525af461e6..1a645965741dc 100755
--- a/emcc
+++ b/emcc
@@ -1098,12 +1098,24 @@ try:
 
   # Find input files
 
+  # These three arrays are used to store arguments of different types for
+  # type-specific processing. In order to shuffle the arguments back together
+  # after processing, all of these arrays hold tuples (original_index, value).
+  # Note that the index part of the tuple can have a fractional part for input
+  # arguments that expand into multiple processed arguments, as in -Wl,-f1,-f2.
   input_files = []
+  libs = []
+  link_flags = []
+
+  # All of the above arg lists entries contain indexes into the full argument
+  # list. In order to add extra implicit args (embind.cc, etc) below, we keep a
+  # counter for the next index that should be used.
+  next_arg_index = len(newargs)
+
   has_source_inputs = False
   has_header_inputs = False
   lib_dirs = [shared.path_from_root('system', 'local', 'lib'),
               shared.path_from_root('system', 'lib')]
-  libs = []
   for i in range(len(newargs)): # find input files XXX this a simple heuristic. we should really analyze based on a full understanding of gcc params,
                                 # right now we just assume that what is left contains no more |-x OPT| things
     arg = newargs[i]
@@ -1124,13 +1136,13 @@ try:
       if arg_ending.endswith(SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS + HEADER_ENDINGS) or shared.Building.is_ar(arg): # we already removed -o <target>, so all these should be inputs
         newargs[i] = ''
         if arg_ending.endswith(SOURCE_ENDINGS):
-          input_files.append(arg)
+          input_files.append((i, arg))
           has_source_inputs = True
         elif arg_ending.endswith(HEADER_ENDINGS):
-          input_files.append(arg)
+          input_files.append((i, arg))
           has_header_inputs = True
         elif arg_ending.endswith(ASSEMBLY_ENDINGS) or shared.Building.is_bitcode(arg): # this should be bitcode, make sure it is valid
-          input_files.append(arg)
+          input_files.append((i, arg))
         elif arg_ending.endswith(STATICLIB_ENDINGS + DYNAMICLIB_ENDINGS):
           # if it's not, and it's a library, just add it to libs to find later
           l = unsuffixed_basename(arg)
@@ -1139,7 +1151,7 @@ try:
             if l.startswith(prefix):
               l = l[len(prefix):]
               break
-          libs.append(l)
+          libs.append((i, l))
           newargs[i] = ''
         else:
           logging.warning(arg + ' is not valid LLVM bitcode')
@@ -1157,7 +1169,15 @@ try:
       lib_dirs.append(arg[2:])
       newargs[i] = ''
     elif arg.startswith('-l'):
-      libs.append(arg[2:])
+      libs.append((i, arg[2:]))
+      newargs[i] = ''
+    elif arg.startswith('-Wl,'):
+      # Multiple comma separated link flags can be specified. Create fake
+      # fractional indices for these: -Wl,a,b,c,d at index 4 becomes:
+      # (4, a), (4.25, b), (4.5, c), (4.75, d)
+      link_flags_to_add = arg.split(',')[1:]
+      for flag_index, flag in enumerate(link_flags_to_add):
+        link_flags.append((i + float(flag_index) / len(link_flags_to_add), flag))
       newargs[i] = ''
 
   original_input_files = input_files[:]
@@ -1173,7 +1193,7 @@ try:
   final_ending = ('.' + final_suffix) if len(final_suffix) > 0 else ''
 
   # Find library files
-  for lib in libs:
+  for i, lib in libs:
     logging.debug('looking for library "%s"', lib)
     found = False
     for prefix in LIB_PREFIXES:
@@ -1183,7 +1203,7 @@ try:
           path = os.path.join(lib_dir, name)
           if os.path.exists(path):
             logging.debug('found library "%s" at %s', lib, path)
-            input_files.append(path)
+            input_files.append((i, path))
             found = True
             break
         if found: break
@@ -1199,7 +1219,7 @@ try:
         return False
       else:
         return True
-    input_files = [input_file for input_file in input_files if check(input_file)]
+    input_files = [(i, input_file) for (i, input_file) in input_files if check(input_file)]
 
   if len(input_files) == 0:
     logging.error('no input files\nnote that input files without a known suffix are ignored, make sure your input files end with one of: ' + str(SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + STATICLIB_ENDINGS + ASSEMBLY_ENDINGS + HEADER_ENDINGS))
@@ -1211,7 +1231,8 @@ try:
 
   # If we are using embind and generating JS, now is the time to link in bind.cpp
   if bind and final_suffix in JS_CONTAINING_SUFFIXES:
-    input_files.append(shared.path_from_root('system', 'lib', 'embind', 'bind.cpp'))
+    input_files.append((next_arg_index, shared.path_from_root('system', 'lib', 'embind', 'bind.cpp')))
+    next_arg_index += 1
 
   # Apply optimization level settings
   shared.Settings.apply_opt_level(opt_level, noisy=True)
@@ -1331,7 +1352,8 @@ try:
     logging.warning('ALIASING_FUNCTION_POINTERS is on, function pointer comparisons may be invalid across types')
 
   if shared.Settings.STB_IMAGE and final_suffix in JS_CONTAINING_SUFFIXES:
-    input_files.append(shared.path_from_root('third_party', 'stb_image.c'))
+    input_files.append((next_arg_index, shared.path_from_root('third_party', 'stb_image.c')))
+    next_arg_index += 1
     shared.Settings.EXPORTED_FUNCTIONS += ['_stbi_load', '_stbi_load_from_memory', '_stbi_image_free']
 
   if type(shared.Settings.EXPORTED_FUNCTIONS) in (list, tuple):
@@ -1365,9 +1387,10 @@ try:
 
   # Precompiled headers support
   if has_header_inputs:
-    for header in input_files:
-      assert header.endswith(HEADER_ENDINGS), 'if you have one header input, we assume you want to precompile headers, and cannot have source files or other inputs as well: ' + str(input_files) + ' : ' + header
-    args = newargs + shared.EMSDK_CXX_OPTS + input_files
+    headers = [header for _, header in input_files]
+    for header in headers:
+      assert header.endswith(HEADER_ENDINGS), 'if you have one header input, we assume you want to precompile headers, and cannot have source files or other inputs as well: ' + str(headers) + ' : ' + header
+    args = newargs + shared.EMSDK_CXX_OPTS + headers
     if specified_target:
       args += ['-o', specified_target]
     logging.debug("running (for precompiled headers): " + call + ' ' + ' '.join(args))
@@ -1388,12 +1411,12 @@ try:
     return in_temp(unsuffixed(uniquename(input_file)) + default_object_extension)
 
   # First, generate LLVM bitcode. For each input file, we get base.o with bitcode
-  for input_file in input_files:
+  for i, input_file in input_files:
     file_ending = filename_type_ending(input_file)
     if file_ending.endswith(SOURCE_ENDINGS):
       logging.debug('compiling source file: ' + input_file)
       output_file = get_bitcode_file(input_file)
-      temp_files.append(output_file)
+      temp_files.append((i, output_file))
       args = newargs + ['-emit-llvm', '-c', input_file, '-o', output_file]
       if file_ending.endswith(CXX_ENDINGS):
         args += shared.EMSDK_CXX_OPTS
@@ -1407,18 +1430,18 @@ try:
         logging.debug('copying bitcode file: ' + input_file)
         temp_file = in_temp(unsuffixed(uniquename(input_file)) + '.o')
         shutil.copyfile(input_file, temp_file)
-        temp_files.append(temp_file)
+        temp_files.append((i, temp_file))
       elif file_ending.endswith(DYNAMICLIB_ENDINGS) or shared.Building.is_ar(input_file):
         logging.debug('copying library file: ' + input_file)
         temp_file = in_temp(uniquename(input_file))
         shutil.copyfile(input_file, temp_file)
-        temp_files.append(temp_file)
+        temp_files.append((i, temp_file))
       elif file_ending.endswith(ASSEMBLY_ENDINGS):
         if not LEAVE_INPUTS_RAW:
           logging.debug('assembling assembly file: ' + input_file)
           temp_file = in_temp(unsuffixed(uniquename(input_file)) + '.o')
           shared.Building.llvm_as(input_file, temp_file)
-          temp_files.append(temp_file)
+          temp_files.append((i, temp_file))
       else:
         logging.error(input_file + ': Unknown file suffix when compiling to LLVM bitcode!')
         sys.exit(1)
@@ -1430,10 +1453,10 @@ try:
 
     # Optimize source files
     if llvm_opts > 0:
-      for i, input_file in enumerate(input_files):
+      for pos, (_, input_file) in enumerate(input_files):
         file_ending = filename_type_ending(input_file)
         if file_ending.endswith(SOURCE_ENDINGS):
-          temp_file = temp_files[i]
+          (_, temp_file) = temp_files[pos]
           logging.debug('optimizing %s', input_file)
           #if DEBUG: shutil.copyfile(temp_file, os.path.join(TEMP_DIR, 'to_opt.bc') # useful when LLVM opt aborts
           shared.Building.llvm_opt(temp_file, llvm_opts)
@@ -1441,26 +1464,30 @@ try:
   # If we were just asked to generate bitcode, stop there
   if final_suffix not in JS_CONTAINING_SUFFIXES:
     if not specified_target:
-      for input_file in input_files:
+      for _, input_file in input_files:
         safe_move(get_bitcode_file(input_file), unsuffixed_basename(input_file) + final_ending)
     else:
       if len(input_files) == 1:
-        safe_move(temp_files[0], specified_target if specified_target else unsuffixed_basename(input_file) + final_ending)
-        temp_output_base = unsuffixed(temp_files[0])
+        _, input_file = input_files[0]
+        _, temp_file = temp_files[0]
+        safe_move(temp_file, specified_target if specified_target else unsuffixed_basename(input_file) + final_ending)
+        temp_output_base = unsuffixed(temp_file)
         if os.path.exists(temp_output_base + '.d'):
           # There was a .d file generated, from -MD or -MMD and friends, save a copy of it to where the output resides,
           # adjusting the target name away from the temporary file name to the specified target.
           # It will be deleted with the rest of the temporary directory.
           deps = open(temp_output_base + '.d').read()
           deps = deps.replace(temp_output_base + default_object_extension, specified_target)
-          with open(os.path.join(os.path.dirname(specified_target), os.path.basename(unsuffixed(input_files[0]) + '.d')), "w") as out_dep:
+          with open(os.path.join(os.path.dirname(specified_target), os.path.basename(unsuffixed(input_file) + '.d')), "w") as out_dep:
             out_dep.write(deps)
       else:
         assert len(original_input_files) == 1 or not has_dash_c, 'fatal error: cannot specify -o with -c with multiple files' + str(sys.argv) + ':' + str(original_input_files)
         # We have a specified target (-o <target>), which is not JavaScript or HTML, and
         # we have multiple files: Link them
         logging.debug('link: ' + str(temp_files) + specified_target)
-        shared.Building.link(temp_files, specified_target)
+        # Sort arg tuples and pass the extracted values to link.
+        link_args = [f for (i, f) in sorted(temp_files)]
+        shared.Building.link(link_args, specified_target)
     logging.debug('stopping at bitcode')
     exit(0)
 
@@ -1473,7 +1500,7 @@ try:
   if not LEAVE_INPUTS_RAW and \
      not shared.Settings.BUILD_AS_SHARED_LIB and \
      not shared.Settings.SIDE_MODULE: # shared libraries/side modules link no C libraries, need them in parent
-    extra_files_to_link = system_libs.calculate(temp_files, in_temp, stdout, stderr)
+    extra_files_to_link = system_libs.calculate([f for _, f in sorted(temp_files)], in_temp, stdout, stderr)
   else:
     extra_files_to_link = []
 
@@ -1481,18 +1508,20 @@ try:
 
   # First, combine the bitcode files if there are several. We must also link if we have a singleton .a
   if len(input_files) + len(extra_files_to_link) > 1 or \
-     (not LEAVE_INPUTS_RAW and not (suffix(temp_files[0]) in BITCODE_ENDINGS or suffix(temp_files[0]) in DYNAMICLIB_ENDINGS) and shared.Building.is_ar(temp_files[0])):
-    linker_inputs = temp_files + extra_files_to_link
+     (not LEAVE_INPUTS_RAW and not (suffix(temp_files[0][1]) in BITCODE_ENDINGS or suffix(temp_files[0][1]) in DYNAMICLIB_ENDINGS) and shared.Building.is_ar(temp_files[0][1])):
+    linker_inputs = [val for _, val in sorted(temp_files + link_flags)] + extra_files_to_link
     logging.debug('linking: ' + str(linker_inputs))
-    shared.Building.link(linker_inputs, in_temp(target_basename + '.bc'), force_archive_contents=len([temp for temp in temp_files if not temp.endswith(STATICLIB_ENDINGS)]) == 0)
+    shared.Building.link(linker_inputs, in_temp(target_basename + '.bc'), force_archive_contents=len([temp for i, temp in temp_files if not temp.endswith(STATICLIB_ENDINGS)]) == 0)
     final = in_temp(target_basename + '.bc')
   else:
     if not LEAVE_INPUTS_RAW:
-      shutil.move(temp_files[0], in_temp(target_basename + '.bc'))
+      _, temp_file = temp_files[0]
+      shutil.move(temp_file, in_temp(target_basename + '.bc'))
       final = in_temp(target_basename + '.bc')
     else:
-      final = in_temp(input_files[0])
-      shutil.copyfile(input_files[0], final)
+      _, input_file = input_files[0]
+      final = in_temp(input_file)
+      shutil.copyfile(input_file, final)
 
   log_time('link')
 
diff --git a/emscripten-version.txt b/emscripten-version.txt
index 1992f2ad5b1af..18abf253a38f3 100644
--- a/emscripten-version.txt
+++ b/emscripten-version.txt
@@ -1,2 +1,2 @@
-1.18.2
+1.18.3
 
diff --git a/src/library.js b/src/library.js
index 0d649258a3e5d..9dd2aedc8149b 100644
--- a/src/library.js
+++ b/src/library.js
@@ -3222,39 +3222,6 @@ LibraryManager.library = {
     {{{ makeStructuralReturn([makeGetTempDouble(0, 'i32'), makeGetTempDouble(1, 'i32')]) }}};
   },
 #endif
-  strtoll__deps: ['_parseInt64'],
-  strtoll: function(str, endptr, base) {
-    return __parseInt64(str, endptr, base, '-9223372036854775808', '9223372036854775807');  // LLONG_MIN, LLONG_MAX.
-  },
-  strtoll_l__deps: ['strtoll'],
-  strtoll_l: function(str, endptr, base) {
-    return _strtoll(str, endptr, base); // no locale support yet
-  },
-  strtol__deps: ['_parseInt'],
-  strtol: function(str, endptr, base) {
-    return __parseInt(str, endptr, base, -2147483648, 2147483647, 32);  // LONG_MIN, LONG_MAX.
-  },
-  strtol_l__deps: ['strtol'],
-  strtol_l: function(str, endptr, base) {
-    return _strtol(str, endptr, base); // no locale support yet
-  },
-  strtoul__deps: ['_parseInt'],
-  strtoul: function(str, endptr, base) {
-    return __parseInt(str, endptr, base, 0, 4294967295, 32, true);  // ULONG_MAX.
-  },
-  strtoul_l__deps: ['strtoul'],
-  strtoul_l: function(str, endptr, base) {
-    return _strtoul(str, endptr, base); // no locale support yet
-  },
-  strtoull__deps: ['_parseInt64'],
-  strtoull: function(str, endptr, base) {
-    return __parseInt64(str, endptr, base, 0, '18446744073709551615', true);  // ULONG_MAX.
-  },
-  strtoull_l__deps: ['strtoull'],
-  strtoull_l: function(str, endptr, base) {
-    return _strtoull(str, endptr, base); // no locale support yet
-  },
-
   environ: 'allocate(1, "i32*", ALLOC_STATIC)',
   __environ__deps: ['environ'],
   __environ: '_environ',
@@ -3619,28 +3586,6 @@ LibraryManager.library = {
     return pdest|0;
   },
 
-  strlwr__deps:['tolower'],
-  strlwr: function(pstr){
-    var i = 0;
-    while(1) {
-      var x = {{{ makeGetValue('pstr', 'i', 'i8') }}};
-      if (x == 0) break;
-      {{{ makeSetValue('pstr', 'i', '_tolower(x)', 'i8') }}};
-      i++;
-    }
-  },
-
-  strupr__deps:['toupper'],
-  strupr: function(pstr){
-    var i = 0;
-    while(1) {
-      var x = {{{ makeGetValue('pstr', 'i', 'i8') }}};
-      if (x == 0) break;
-      {{{ makeSetValue('pstr', 'i', '_toupper(x)', 'i8') }}};
-      i++;
-    }
-  },
-
   strcat__asm: true,
   strcat__sig: 'iii',
   strcat__deps: ['strlen'],
@@ -3681,132 +3626,6 @@ LibraryManager.library = {
   // ctype.h
   // ==========================================================================
 
-  isascii: function(chr) {
-    return chr >= 0 && (chr & 0x80) == 0;
-  },
-  toascii: function(chr) {
-    return chr & 0x7F;
-  },
-  toupper: function(chr) {
-    if (chr >= {{{ charCode('a') }}} && chr <= {{{ charCode('z') }}}) {
-      return chr - {{{ charCode('a') }}} + {{{ charCode('A') }}};
-    } else {
-      return chr;
-    }
-  },
-  _toupper: 'toupper',
-  toupper_l__deps: ['toupper'],
-  toupper_l: function(str, endptr, base) {
-    return _toupper(str, endptr, base); // no locale support yet
-  },
-
-  tolower__asm: true,
-  tolower__sig: 'ii',
-  tolower: function(chr) {
-    chr = chr|0;
-    if ((chr|0) < {{{ charCode('A') }}}) return chr|0;
-    if ((chr|0) > {{{ charCode('Z') }}}) return chr|0;
-    return (chr - {{{ charCode('A') }}} + {{{ charCode('a') }}})|0;
-  },
-  _tolower: 'tolower',
-  tolower_l__deps: ['tolower'],
-  tolower_l: function(chr) {
-    return _tolower(chr); // no locale support yet
-  },
-
-  // The following functions are defined as macros in glibc.
-  islower: function(chr) {
-    return chr >= {{{ charCode('a') }}} && chr <= {{{ charCode('z') }}};
-  },
-  islower_l__deps: ['islower'],
-  islower_l: function(chr) {
-    return _islower(chr); // no locale support yet
-  },
-  isupper: function(chr) {
-    return chr >= {{{ charCode('A') }}} && chr <= {{{ charCode('Z') }}};
-  },
-  isupper_l__deps: ['isupper'],
-  isupper_l: function(chr) {
-    return _isupper(chr); // no locale support yet
-  },
-  isalpha: function(chr) {
-    return (chr >= {{{ charCode('a') }}} && chr <= {{{ charCode('z') }}}) ||
-           (chr >= {{{ charCode('A') }}} && chr <= {{{ charCode('Z') }}});
-  },
-  isalpha_l__deps: ['isalpha'],
-  isalpha_l: function(chr) {
-    return _isalpha(chr); // no locale support yet
-  },
-  isdigit: function(chr) {
-    return chr >= {{{ charCode('0') }}} && chr <= {{{ charCode('9') }}};
-  },
-  isdigit_l__deps: ['isdigit'],
-  isdigit_l: function(chr) {
-    return _isdigit(chr); // no locale support yet
-  },
-  isxdigit: function(chr) {
-    return (chr >= {{{ charCode('0') }}} && chr <= {{{ charCode('9') }}}) ||
-           (chr >= {{{ charCode('a') }}} && chr <= {{{ charCode('f') }}}) ||
-           (chr >= {{{ charCode('A') }}} && chr <= {{{ charCode('F') }}});
-  },
-  isxdigit_l__deps: ['isxdigit'],
-  isxdigit_l: function(chr) {
-    return _isxdigit(chr); // no locale support yet
-  },
-  isalnum: function(chr) {
-    return (chr >= {{{ charCode('0') }}} && chr <= {{{ charCode('9') }}}) ||
-           (chr >= {{{ charCode('a') }}} && chr <= {{{ charCode('z') }}}) ||
-           (chr >= {{{ charCode('A') }}} && chr <= {{{ charCode('Z') }}});
-  },
-  isalnum_l__deps: ['isalnum'],
-  isalnum_l: function(chr) {
-    return _isalnum(chr); // no locale support yet
-  },
-  ispunct: function(chr) {
-    return (chr >= {{{ charCode('!') }}} && chr <= {{{ charCode('/') }}}) ||
-           (chr >= {{{ charCode(':') }}} && chr <= {{{ charCode('@') }}}) ||
-           (chr >= {{{ charCode('[') }}} && chr <= {{{ charCode('`') }}}) ||
-           (chr >= {{{ charCode('{') }}} && chr <= {{{ charCode('~') }}});
-  },
-  ispunct_l__deps: ['ispunct'],
-  ispunct_l: function(chr) {
-    return _ispunct(chr); // no locale support yet
-  },
-  isspace: function(chr) {
-    return (chr == 32) || (chr >= 9 && chr <= 13);
-  },
-  isspace_l__deps: ['isspace'],
-  isspace_l: function(chr) {
-    return _isspace(chr); // no locale support yet
-  },
-  isblank: function(chr) {
-    return chr == {{{ charCode(' ') }}} || chr == {{{ charCode('\t') }}};
-  },
-  isblank_l__deps: ['isblank'],
-  isblank_l: function(chr) {
-    return _isblank(chr); // no locale support yet
-  },
-  iscntrl: function(chr) {
-    return (0 <= chr && chr <= 0x1F) || chr === 0x7F;
-  },
-  iscntrl_l__deps: ['iscntrl'],
-  iscntrl_l: function(chr) {
-    return _iscntrl(chr); // no locale support yet
-  },
-  isprint: function(chr) {
-    return 0x1F < chr && chr < 0x7F;
-  },
-  isprint_l__deps: ['isprint'],
-  isprint_l: function(chr) {
-    return _isprint(chr); // no locale support yet
-  },
-  isgraph: function(chr) {
-    return 0x20 < chr && chr < 0x7F;
-  },
-  isgraph_l__deps: ['isgraph'],
-  isgraph_l: function(chr) {
-    return _isgraph(chr); // no locale support yet
-  },
   // Lookup tables for glibc ctype implementation.
   __ctype_b_loc__deps: ['malloc'],
   __ctype_b_loc: function() {
diff --git a/src/library_sdl.js b/src/library_sdl.js
index eabfe3e5eb817..d9639907b852e 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -943,11 +943,67 @@ var LibrarySDL = {
       var ret = info.volume * 128; // MIX_MAX_VOLUME
       if (volume != -1) {
         info.volume = volume / 128;
-        if (info.audio) info.audio.volume = info.volume;
+        if (info.audio) {
+          info.audio.volume = info.volume; // For <audio> element
+          if (info.audio.webAudioGainNode) info.audio.webAudioGainNode['gain']['value'] = info.volume; // For WebAudio playback
+        }
       }
       return ret;
     },
 
+    // Plays out an SDL audio resource that was loaded with the Mix_Load APIs, when using Web Audio..
+    playWebAudio: function(audio) {
+      if (!audio) return;
+      if (audio.webAudioNode) return; // This instance is already playing, don't start again.
+      if (!SDL.webAudioAvailable()) return;
+      var webAudio = audio.resource.webAudio;
+      audio.paused = false;
+      if (!webAudio.decodedBuffer) {
+        if (webAudio.onDecodeComplete === undefined) abort("Cannot play back audio object that was not loaded");
+        webAudio.onDecodeComplete.push(function() { if (!audio.paused) SDL.playWebAudio(audio); });
+        return;
+      }
+      audio.webAudioNode = SDL.audioContext['createBufferSource']();
+      audio.webAudioNode['buffer'] = webAudio.decodedBuffer;
+      audio.webAudioNode['loop'] = audio.loop;
+      audio.webAudioNode['onended'] = function() { audio.onended(); } // For <media> element compatibility, route the onended signal to the instance.
+
+      // Add an intermediate gain node to control volume.
+      audio.webAudioGainNode = SDL.audioContext['createGain']();
+      audio.webAudioGainNode['gain']['value'] = audio.volume;
+      audio.webAudioNode['connect'](audio.webAudioGainNode);
+      audio.webAudioGainNode['connect'](SDL.audioContext['destination']);
+      audio.webAudioNode['start'](0, audio.currentPosition);
+      audio.startTime = SDL.audioContext['currentTime'] - audio.currentPosition;
+    },
+
+    // Pausea an SDL audio resource that was played with Web Audio..
+    pauseWebAudio: function(audio) {
+      if (!audio) return;
+      if (audio.webAudioNode) {
+        // Remember where we left off, so that if/when we resume, we can restart the playback at a proper place.
+        audio.currentPosition = (SDL.audioContext['currentTime'] - audio.startTime) % audio.resource.webAudio.decodedBuffer.duration;
+        // Important: When we reach here, the audio playback is stopped by the user. But when calling .stop() below, the Web Audio
+        // graph will send the onended signal, but we don't want to process that, since pausing should not clear/destroy the audio
+        // channel.
+        audio.webAudioNode['onended'] = undefined;
+        audio.webAudioNode.stop();
+        audio.webAudioNode = undefined;
+      }
+      audio.paused = true;
+    },
+
+    openAudioContext: function() {
+      // Initialize Web Audio API if we haven't done so yet. Note: Only initialize Web Audio context ever once on the web page,
+      // since initializing multiple times fails on Chrome saying 'audio resources have been exhausted'.
+      if (!SDL.audioContext) {
+        if (typeof(AudioContext) !== 'undefined') SDL.audioContext = new AudioContext();
+        else if (typeof(webkitAudioContext) !== 'undefined') SDL.audioContext = new webkitAudioContext();
+      }
+    },
+
+    webAudioAvailable: function() { return !!SDL.audioContext; },
+
     fillWebAudioBufferFromHeap: function(heapPtr, sizeSamplesPerChannel, dstAudioBuffer) {
       // The input audio data is interleaved across the channels, i.e. [L, R, L, R, L, R, ...] and is either 8-bit or 16-bit as
       // supported by the SDL API. The output audio wave data for Web Audio API must be in planar buffers of [-1,1]-normalized Float32 data,
@@ -1250,11 +1306,11 @@ var LibrarySDL = {
     for (var i = 0; i < SDL.numChannels; ++i) {
       if (SDL.channels[i].audio) {
         SDL.channels[i].audio.pause();
+        SDL.channels[i].audio = undefined;
       }
     }
-    if (SDL.music.audio) {
-      SDL.music.audio.pause();
-    }
+    if (SDL.music.audio) SDL.music.audio.pause();
+    SDL.music.audio = undefined;
     Module.print('SDL_Quit called (and ignored)');
   },
 
@@ -2004,15 +2060,8 @@ var LibrarySDL = {
       } else {
         // Initialize Web Audio API if we haven't done so yet. Note: Only initialize Web Audio context ever once on the web page,
         // since initializing multiple times fails on Chrome saying 'audio resources have been exhausted'.
-        if (!SDL.audioContext) {
-          if (typeof(AudioContext) !== 'undefined') {
-            SDL.audioContext = new AudioContext();
-          } else if (typeof(webkitAudioContext) !== 'undefined') {
-            SDL.audioContext = new webkitAudioContext();
-          } else {
-            throw 'Web Audio API is not available!';
-          }
-        }
+        SDL.openAudioContext();
+        if (!SDL.audioContext) throw 'Web Audio API is not available!';
         SDL.audio.soundSource = new Array(); // Use an array of sound sources as a ring buffer to queue blocks of synthesized audio to Web Audio API.
         SDL.audio.nextSoundSource = 0; // Index of the next sound buffer in the ring buffer queue to play.
         SDL.audio.nextPlayTime = 0; // Time in seconds when the next audio block is due to start.
@@ -2195,6 +2244,7 @@ var LibrarySDL = {
   Mix_Quit: function(){},
 
   Mix_OpenAudio: function(frequency, format, channels, chunksize) {
+    SDL.openAudioContext();
     SDL.allocateChannels(32);
     // Just record the values for a later call to Mix_QuickLoad_RAW
     SDL.mixerFrequency = frequency;
@@ -2237,6 +2287,7 @@ var LibrarySDL = {
 
     var filename = '';
     var audio;
+    var webAudio;
     var bytes;
 
     if (rwops.filename !== undefined) {
@@ -2244,7 +2295,7 @@ var LibrarySDL = {
       var raw = Module["preloadedAudios"][filename];
       if (!raw) {
         if (raw === null) Module.printErr('Trying to reuse preloaded audio, but freePreloadedMediaOnUse is set!');
-        Runtime.warnOnce('Cannot find preloaded audio ' + filename);
+        if (!Module.noAudioDecoding) Runtime.warnOnce('Cannot find preloaded audio ' + filename);
 
         // see if we can read the file-contents from the in-memory FS
         try {
@@ -2260,15 +2311,33 @@ var LibrarySDL = {
       audio = raw;
     }
     else if (rwops.bytes !== undefined) {
-      bytes = HEAPU8.subarray(rwops.bytes, rwops.bytes + rwops.count);
+      // For Web Audio context buffer decoding, we must make a clone of the audio data, but for <media> element,
+      // a view to existing data is sufficient.
+      if (SDL.webAudioAvailable()) bytes = HEAPU8.buffer.slice(rwops.bytes, rwops.bytes + rwops.count);
+      else bytes = HEAPU8.subarray(rwops.bytes, rwops.bytes + rwops.count);
     }
     else {
       return 0;
     }
 
-    // Here, we didn't find a preloaded audio but we either were passed a filepath for
-    // which we loaded bytes, or we were passed some bytes
-    if (audio === undefined && bytes) {
+    if (bytes !== undefined && SDL.webAudioAvailable()) {
+      audio = undefined;
+      webAudio = {};
+      // The audio decoding process is asynchronous, which gives trouble if user code plays the audio data back immediately
+      // after loading. Therefore prepare an array of callback handlers to run when this audio decoding is complete, which
+      // will then start the playback (with some delay).
+      webAudio.onDecodeComplete = []; // While this member array exists, decoding hasn't finished yet.
+      function onDecodeComplete(data) {
+        webAudio.decodedBuffer = data;
+        // Call all handlers that were waiting for this decode to finish, and clear the handler list.
+        webAudio.onDecodeComplete.forEach(function(e) { e(); });
+        webAudio.onDecodeComplete = undefined; // Don't allow more callback handlers since audio has finished decoding.
+      }
+
+      SDL.audioContext['decodeAudioData'](bytes.buffer || bytes, onDecodeComplete);
+    } else if (audio === undefined && bytes) {
+      // Here, we didn't find a preloaded audio but we either were passed a filepath for
+      // which we loaded bytes, or we were passed some bytes
       var blob = new Blob([bytes], {type: rwops.mimetype});
       var url = URL.createObjectURL(blob);
       audio = new Audio();
@@ -2280,27 +2349,39 @@ var LibrarySDL = {
     // Keep the loaded audio in the audio arrays, ready for playback
     SDL.audios.push({
       source: filename,
-      audio: audio
+      audio: audio, // Points to the <audio> element, if loaded
+      webAudio: webAudio // Points to a Web Audio -specific resource object, if loaded
     });
     return id;
   },
 
   Mix_QuickLoad_RAW: function(mem, len) {
-    var audio = new Audio();
-    audio.mozAudioChannelType = 'content'; // bugzilla 910340
-    // Record the number of channels and frequency for later usage
-    audio.numChannels = SDL.mixerNumChannels;
-    audio.frequency = SDL.mixerFrequency;
+    var audio;
+    var webAudio;
+
     var numSamples = len >> 1; // len is the length in bytes, and the array contains 16-bit PCM values
     var buffer = new Float32Array(numSamples);
     for (var i = 0; i < numSamples; ++i) {
       buffer[i] = ({{{ makeGetValue('mem', 'i*2', 'i16', 0, 0) }}}) / 0x8000; // hardcoded 16-bit audio, signed (TODO: reSign if not ta2?)
     }
-    // FIXME: doesn't make sense to keep the audio element in the buffer
+
+    if (SDL.webAudioAvailable()) {
+      webAudio = {};
+      webAudio.decodedBuffer = buffer;
+    } else {
+      var audio = new Audio();
+      audio.mozAudioChannelType = 'content'; // bugzilla 910340
+      // Record the number of channels and frequency for later usage
+      audio.numChannels = SDL.mixerNumChannels;
+      audio.frequency = SDL.mixerFrequency;
+      // FIXME: doesn't make sense to keep the audio element in the buffer
+    }
+
     var id = SDL.audios.length;
     SDL.audios.push({
       source: '',
       audio: audio,
+      webAudio: webAudio,
       buffer: buffer
     });
     return id;
@@ -2313,13 +2394,12 @@ var LibrarySDL = {
     SDL.channelMinimumNumber = num;
   },
   Mix_PlayChannel: function(channel, id, loops) {
-    // TODO: handle loops
+    // TODO: handle fixed amount of N loops. Currently loops either 0 or infinite times.
 
     // Get the audio element associated with the ID
     var info = SDL.audios[id];
     if (!info) return -1;
-    var audio = info.audio;
-    if (!audio) return -1;
+    if (!info.audio && !info.webAudio) return -1;
 
     // If the user asks us to allocate a channel automatically, get the first
     // free one.
@@ -2335,73 +2415,33 @@ var LibrarySDL = {
         return -1;
       }
     }
-    // We clone the audio node to utilize the preloaded audio buffer, since
-    // the browser has already preloaded the audio file.
     var channelInfo = SDL.channels[channel];
-    channelInfo.audio = audio = audio.cloneNode(true);
-    audio.numChannels = info.audio.numChannels;
-    audio.frequency = info.audio.frequency;
-    // TODO: handle N loops. Behavior matches Mix_PlayMusic
-    audio.loop = loops != 0; 
-    audio['onended'] = function SDL_audio_onended() { // TODO: cache these
-      channelInfo.audio = null;
-      if (SDL.channelFinished) {
-        Runtime.getFuncWrapper(SDL.channelFinished, 'vi')(channel);
-      }
-    }
-    // Either play the element, or load the dynamic data into it
-    if (info.buffer) {
-      var contextCtor = null;
-      if (audio && ('mozSetup' in audio)) { // Audio Data API
-        try {
-          audio['mozSetup'](audio.numChannels, audio.frequency);
-          audio["mozWriteAudio"](info.buffer);
-        } catch (e) {
-          // Workaround for Firefox bug 783052
-          // ignore this exception!
-        }
-      /*
-      } else if (contextCtor = (window.AudioContext || // WebAudio API
-                                window.webkitAudioContext)) {
-        var currentIndex = 0;
-        var numChannels = parseInt(audio.numChannels);
-        var context = new contextCtor();
-        var source = context.createBufferSource();
-        source.loop = false;
-        source.buffer = context.createBuffer(numChannels, 1, audio.frequency);
-        var jsNode = context.createJavaScriptNode(2048, numChannels, numChannels);
-        jsNode.onaudioprocess = function jsNode_onaudioprocess(event) {
-          var buffers = new Array(numChannels);
-          for (var i = 0; i < numChannels; ++i) {
-            buffers[i] = event.outputBuffer.getChannelData(i);
-          }
-          var remaining = info.buffer.length - currentIndex;
-          if (remaining > 2048) {
-            remaining = 2048;
-          }
-          for (var i = 0; i < remaining;) {
-            for (var j = 0; j < numChannels; ++j) {
-              buffers[j][i] = info.buffer[currentIndex + i + j] * audio.volume;
-            }
-            i += j;
-          }
-          currentIndex += remaining * numChannels;
-          for (var i = remaining; i < 2048;) {
-            for (var j = 0; j < numChannels; ++j) {
-              buffers[j][i] = 0; // silence
-            }
-            i += j;
-          }
-        };
-        source.connect(jsNode);
-        jsNode.connect(context.destination);
-        source.noteOn(0);
-      */
-      }
+    var audio;
+    if (info.webAudio) {
+      // Create an instance of the WebAudio object.
+      audio = {};
+      audio.resource = info; // This new object is an instance that refers to this existing resource.
+      audio.paused = false;
+      audio.currentPosition = 0;
+      // Make our instance look similar to the instance of a <media> to make api simple.
+      audio.play = function() { SDL.playWebAudio(this); }
+      audio.pause = function() { SDL.pauseWebAudio(this); }
     } else {
-      audio.play();
+      // We clone the audio node to utilize the preloaded audio buffer, since
+      // the browser has already preloaded the audio file.
+      audio = info.audio.cloneNode(true);
+      audio.numChannels = info.audio.numChannels;
+      audio.frequency = info.audio.frequency;
+    }
+    audio['onended'] = function SDL_audio_onended() { // TODO: cache these
+      if (channelInfo.audio == this) { channelInfo.audio.paused = true; channelInfo.audio = null; }
+      if (SDL.channelFinished) Runtime.getFuncWrapper(SDL.channelFinished, 'vi')(channel);
     }
+    channelInfo.audio = audio;
+    // TODO: handle N loops. Behavior matches Mix_PlayMusic
+    audio.loop = loops != 0;
     audio.volume = channelInfo.volume;
+    audio.play();
     return channel;
   },
   Mix_PlayChannelTimed: 'Mix_PlayChannel', // XXX ignore Timing
@@ -2454,46 +2494,51 @@ var LibrarySDL = {
 
   Mix_PlayMusic__deps: ['Mix_HaltMusic'],
   Mix_PlayMusic: function(id, loops) {
-    loops = Math.max(loops, 1);
-    var audio = SDL.audios[id].audio;
-    if (!audio) return 0;
-    audio.loop = loops != 0; // TODO: handle N loops for finite N
-    if (SDL.audios[id].buffer) {
-      audio["mozWriteAudio"](SDL.audios[id].buffer);
-    } else {
-      audio.play();
-    }
-    audio.volume = SDL.music.volume;
-    audio['onended'] = _Mix_HaltMusic; // will send callback
+    // Pause old music if it exists.
     if (SDL.music.audio) {
-      if (!SDL.music.audio.paused) {
-        Module.printErr('Music is already playing. ' + SDL.music.source);
-      }
+      if (!SDL.music.audio.paused) Module.printErr('Music is already playing. ' + SDL.music.source);
       SDL.music.audio.pause();
     }
+    var info = SDL.audios[id];
+    var audio;
+    if (info.webAudio) { // Play via Web Audio API
+      // Create an instance of the WebAudio object.
+      audio = {};
+      audio.resource = info; // This new webAudio object is an instance that refers to this existing resource.
+      audio.paused = false;
+      audio.currentPosition = 0;
+      audio.play = function() { SDL.playWebAudio(this); }
+      audio.pause = function() { SDL.pauseWebAudio(this); }
+    } else if (info.audio) { // Play via the <audio> element
+      audio = info.audio;
+    }
+    audio['onended'] = function() { if (SDL.music.audio == this) _Mix_HaltMusic(); } // will send callback
+    audio.loop = loops != 0; // TODO: handle N loops for finite N
+    audio.volume = SDL.music.volume;
     SDL.music.audio = audio;
+    audio.play();
     return 0;
   },
 
   Mix_PauseMusic: function() {
     var audio = SDL.music.audio;
-    if (!audio) return 0;
-    audio.pause();
+    if (audio) audio.pause();
     return 0;
   },
 
   Mix_ResumeMusic: function() {
     var audio = SDL.music.audio;
-    if (!audio) return 0;
-    audio.play();
+    if (audio) audio.play();
     return 0;
   },
 
   Mix_HaltMusic: function() {
     var audio = SDL.music.audio;
-    if (!audio) return 0;
-    audio.src = audio.src; // rewind
-    audio.pause();
+    if (audio) {
+      audio.src = audio.src; // rewind <media> element
+      audio.currentPosition = 0; // rewind Web Audio graph playback.
+      audio.pause();
+    }
     SDL.music.audio = null;
     if (SDL.hookMusicFinished) {
       Runtime.dynCall('v', SDL.hookMusicFinished);
@@ -2570,9 +2615,7 @@ var LibrarySDL = {
       return;
     }
     var info = SDL.channels[channel];
-    if (info && info.audio) {
-      info.audio.play();
-    }
+    if (info && info.audio) info.audio.play();
   },
 
   // SDL TTF
diff --git a/src/preamble.js b/src/preamble.js
index 2aec94c6a9293..f46119c723fb2 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -310,28 +310,6 @@ function assert(condition, text) {
 
 var globalScope = this;
 
-// C calling interface. A convenient way to call C functions (in C files, or
-// defined with extern "C").
-//
-// Note: LLVM optimizations can inline and remove functions, after which you will not be
-//       able to call them. Closure can also do so. To avoid that, add your function to
-//       the exports using something like
-//
-//         -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
-//
-// @param ident      The name of the C function (note that C++ functions will be name-mangled - use extern "C")
-// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
-//                   'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
-// @param argTypes   An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
-//                   except that 'array' is not possible (there is no way for us to know the length of the array)
-// @param args       An array of the arguments to the function, as native JS values (as in returnType)
-//                   Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
-// @return           The return value, as a native JS value (as in returnType)
-function ccall(ident, returnType, argTypes, args) {
-  return ccallFunc(getCFunc(ident), returnType, argTypes, args);
-}
-Module["ccall"] = ccall;
-
 // Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
 function getCFunc(ident) {
   try {
@@ -343,53 +321,141 @@ function getCFunc(ident) {
   return func;
 }
 
-// Internal function that does a C call using a function, not an identifier
-function ccallFunc(func, returnType, argTypes, args) {
+var cwrap, ccall;
+(function(){
   var stack = 0;
-  function toC(value, type) {
-    if (type == 'string') {
-      if (value === null || value === undefined || value === 0) return 0; // null string
-      value = intArrayFromString(value);
-      type = 'array';
-    }
-    if (type == 'array') {
-      if (!stack) stack = Runtime.stackSave();
-      var ret = Runtime.stackAlloc(value.length);
-      writeArrayToMemory(value, ret);
+  var JSfuncs = {
+    'stackSave' : function() {
+      stack = Runtime.stackSave();
+    },
+    'stackRestore' : function() {
+      Runtime.stackRestore(stack);
+    },
+    // type conversion from js to c
+    'arrayToC' : function(arr) {
+      var ret = Runtime.stackAlloc(arr.length);
+      writeArrayToMemory(arr, ret);
+      return ret;
+    },
+    'stringToC' : function(str) {
+      var ret = 0;
+      if (str !== null && str !== undefined && str !== 0) { // null string
+        ret = Runtime.stackAlloc(str.length + 1); // +1 for the trailing '\0'
+        writeStringToMemory(str, ret);
+      }
       return ret;
     }
-    return value;
-  }
-  function fromC(value, type) {
-    if (type == 'string') {
-      return Pointer_stringify(value);
+  };
+  // For fast lookup of conversion functions
+  var toC = {'string' : JSfuncs['stringToC'], 'array' : JSfuncs['arrayToC']};
+
+  // C calling interface. A convenient way to call C functions (in C files, or
+  // defined with extern "C").
+  //
+  // Note: LLVM optimizations can inline and remove functions, after which you will not be
+  //       able to call them. Closure can also do so. To avoid that, add your function to
+  //       the exports using something like
+  //
+  //         -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+  //
+  // @param ident      The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+  // @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+  //                   'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+  // @param argTypes   An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+  //                   except that 'array' is not possible (there is no way for us to know the length of the array)
+  // @param args       An array of the arguments to the function, as native JS values (as in returnType)
+  //                   Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+  // @return           The return value, as a native JS value (as in returnType)
+  ccall = function ccallFunc(ident, returnType, argTypes, args) {
+    var func = getCFunc(ident);
+    var cArgs = [];
+#if ASSERTIONS
+    assert(returnType !== 'array', 'Return type should not be "array".');
+#endif
+    if (args) {
+      for (var i = 0; i < args.length; i++) {
+        var converter = toC[argTypes[i]];
+        if (converter) {
+          if (stack === 0) stack = Runtime.stackSave();
+          cArgs[i] = converter(args[i]);
+        } else {
+          cArgs[i] = args[i];
+        }
+      }
     }
-    assert(type != 'array');
-    return value;
+    var ret = func.apply(null, cArgs);
+    if (returnType === 'string') ret = Pointer_stringify(ret);
+    if (stack !== 0) JSfuncs['stackRestore']();
+    return ret;
   }
-  var i = 0;
-  var cArgs = args ? args.map(function(arg) {
-    return toC(arg, argTypes[i++]);
-  }) : [];
-  var ret = fromC(func.apply(null, cArgs), returnType);
-  if (stack) Runtime.stackRestore(stack);
-  return ret;
-}
 
-// Returns a native JS wrapper for a C function. This is similar to ccall, but
-// returns a function you can call repeatedly in a normal way. For example:
-//
-//   var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
-//   alert(my_function(5, 22));
-//   alert(my_function(99, 12));
-//
-function cwrap(ident, returnType, argTypes) {
-  var func = getCFunc(ident);
-  return function() {
-    return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+  var sourceRegex = /^function \((.*)\)\s*{\s*([^]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
+  function parseJSFunc(jsfunc) {
+    // Match the body and the return value of a javascript function source
+    var parsed = jsfunc.toString().match(sourceRegex).slice(1);
+    return {arguments : parsed[0], body : parsed[1], returnValue: parsed[2]}
   }
-}
+  var JSsource = {};
+  for (var fun in JSfuncs) {
+    if (JSfuncs.hasOwnProperty(fun)) {
+      // Elements of toCsource are arrays of three items:
+      // the code, and the return value
+      JSsource[fun] = parseJSFunc(JSfuncs[fun]);
+    }
+  }
+  // Returns a native JS wrapper for a C function. This is similar to ccall, but
+  // returns a function you can call repeatedly in a normal way. For example:
+  //
+  //   var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+  //   alert(my_function(5, 22));
+  //   alert(my_function(99, 12));
+  //
+  cwrap = function cwrap(ident, returnType, argTypes) {
+    var cfunc = getCFunc(ident);
+    // When the function takes numbers and returns a number, we can just return
+    // the original function
+    var numericArgs = argTypes.every(function(type){ return type === 'number'});
+    var numericRet = (returnType !== 'string');
+    if ( numericRet && numericArgs) {
+      return cfunc;
+    }
+    // Creation of the arguments list (["$1","$2",...,"$nargs"])
+    var argNames = argTypes.map(function(x,i){return '$'+i});
+    var funcstr = "(function(" + argNames.join(',') + ") {";
+    var nargs = argTypes.length;
+    if (!numericArgs) {
+      // Generate the code needed to convert the arguments from javascript
+      // values to pointers
+      funcstr += JSsource['stackSave'].body + ';';
+      for (var i = 0; i < nargs; i++) {
+        var arg = argNames[i], type = argTypes[i];
+        if (type === 'number') continue;
+        var convertCode = JSsource[type + 'ToC']; // [code, return]
+        funcstr += 'var ' + convertCode.arguments + ' = ' + arg + ';';
+        funcstr += convertCode.body + ';';
+        funcstr += arg + '=' + convertCode.returnValue + ';';
+      }
+    }
+
+    // When the code is compressed, the name of cfunc is not literally 'cfunc' anymore
+    var cfuncname = parseJSFunc(function(){return cfunc}).returnValue;
+    // Call the function
+    funcstr += 'var ret = ' + cfuncname + '(' + argNames.join(',') + ');';
+    if (!numericRet) { // Return type can only by 'string' or 'number'
+      // Convert the result to a string
+      var strgfy = parseJSFunc(function(){return Pointer_stringify}).returnValue;
+      funcstr += 'ret = ' + strgfy + '(ret);';
+    }
+    if (!numericArgs) {
+      // If we had a stack, restore it
+      funcstr += JSsource['stackRestore'].body + ';';
+    }
+    funcstr += 'return ret})';
+    return eval(funcstr);
+  };
+})();
 Module["cwrap"] = cwrap;
+Module["ccall"] = ccall;
 
 // Sets a value in memory in a dynamic way at run-time. Uses the
 // type data. This is the same as makeSetValue, except that
diff --git a/src/relooper/Relooper.cpp b/src/relooper/Relooper.cpp
index 568dd381d9046..9e469ec4ec388 100644
--- a/src/relooper/Relooper.cpp
+++ b/src/relooper/Relooper.cpp
@@ -1097,7 +1097,7 @@ void Relooper::Calculate(Block *Entry) {
     // Remove unneeded breaks and continues.
     // A flow operation is trivially unneeded if the shape we naturally get to by normal code
     // execution is the same as the flow forces us to.
-    void RemoveUnneededFlows(Shape *Root, Shape *Natural=NULL, LoopShape *LastLoop=NULL) {
+    void RemoveUnneededFlows(Shape *Root, Shape *Natural=NULL, LoopShape *LastLoop=NULL, unsigned Depth=0) {
       BlockSet NaturalBlocks;
       FollowNaturalFlow(Natural, NaturalBlocks);
       Shape *Next = Root;
@@ -1108,7 +1108,7 @@ void Relooper::Calculate(Block *Entry) {
           if (Simple->Inner->BranchVar) LastLoop = NULL; // a switch clears out the loop (TODO: only for breaks, not continue)
 
           if (Simple->Next) {
-            if (!Simple->Inner->BranchVar && Simple->Inner->ProcessedBranchesOut.size() == 2) {
+            if (!Simple->Inner->BranchVar && Simple->Inner->ProcessedBranchesOut.size() == 2 && Depth < 20) {
               // If there is a next block, we already know at Simple creation time to make direct branches,
               // and we can do nothing more in general. But, we try to optimize the case of a break and
               // a direct: This would normally be  if (break?) { break; } ..  but if we
@@ -1144,6 +1144,7 @@ void Relooper::Calculate(Block *Entry) {
                   }
                 }
               }
+              Depth++; // this optimization increases depth, for us and all our next chain (i.e., until this call returns)
             }
             Next = Simple->Next;
           } else {
@@ -1168,11 +1169,11 @@ void Relooper::Calculate(Block *Entry) {
           }
         }, {
           for (IdShapeMap::iterator iter = Multiple->InnerMap.begin(); iter != Multiple->InnerMap.end(); iter++) {
-            RemoveUnneededFlows(iter->second, Multiple->Next, Multiple->Breaks ? NULL : LastLoop);
+            RemoveUnneededFlows(iter->second, Multiple->Next, Multiple->Breaks ? NULL : LastLoop, Depth+1);
           }
           Next = Multiple->Next;
         }, {
-          RemoveUnneededFlows(Loop->Inner, Loop->Inner, Loop);
+          RemoveUnneededFlows(Loop->Inner, Loop->Inner, Loop, Depth+1);
           Next = Loop->Next;
         });
       }
diff --git a/src/relooper/fuzzer.py b/src/relooper/fuzzer.py
index 18db997e7c7b1..313f4d5e7fbf9 100644
--- a/src/relooper/fuzzer.py
+++ b/src/relooper/fuzzer.py
@@ -3,7 +3,7 @@
 
 while True:
   # Random decisions
-  num = random.randint(2, 250)
+  num = random.randint(2, 500)
   density = random.random() * random.random()
   decisions = [random.randint(1, num*20) for x in range(num*3)]
   branches = [0]*num
@@ -123,14 +123,14 @@
   open('fuzz.slow.js', 'w').write(slow)
   open('fuzz.cpp', 'w').write(fast)
   print '_'
-  slow_out = subprocess.Popen(['mozjs', '-m', '-n', 'fuzz.slow.js'], stdout=subprocess.PIPE).communicate()[0]
+  slow_out = subprocess.Popen(['mozjs', 'fuzz.slow.js'], stdout=subprocess.PIPE).communicate()[0]
 
   print '.'
   subprocess.call(['g++', 'fuzz.cpp', 'Relooper.o', '-o', 'fuzz', '-g'])
   print '*'
   subprocess.call(['./fuzz'], stdout=open('fuzz.fast.js', 'w'))
   print '-'
-  fast_out = subprocess.Popen(['mozjs', '-m', '-n', 'fuzz.fast.js'], stdout=subprocess.PIPE).communicate()[0]
+  fast_out = subprocess.Popen(['mozjs', 'fuzz.fast.js'], stdout=subprocess.PIPE).communicate()[0]
   print
 
   if slow_out != fast_out:
diff --git a/src/relooper/test.cpp b/src/relooper/test.cpp
index 9f3ddcebcd48b..f319757b1b6be 100644
--- a/src/relooper/test.cpp
+++ b/src/relooper/test.cpp
@@ -1,4 +1,6 @@
 
+#include <vector>
+
 #include "Relooper.h"
 
 int main() {
@@ -435,5 +437,34 @@ int main() {
 
     puts(r.GetOutputBuffer());
   }
+
+  if (1) {
+    Relooper::MakeOutputBuffer(10);
+
+    printf("\n\n-- lots of exits to an unwind block, possible nesting --\n\n");
+
+    const int DEPTH = 40;
+
+    std::vector<Block*> blocks;
+    for (int i = 0; i < DEPTH; i++) blocks.push_back(new Block("// block\n", NULL));
+    Block *last = new Block("// last\nreturn;\n", NULL);
+    Block *UW = new Block("// UW\nresumeException();\n\n", NULL);
+
+    for (int i = 0; i < DEPTH; i++) {
+      Block *b = blocks[i];
+      b->AddBranchTo(i+1 < DEPTH ? blocks[i+1] : last, "check()", NULL);
+      b->AddBranchTo(UW, NULL, NULL);
+    }
+
+    Relooper r;
+    for (int i = 0; i < DEPTH; i++) r.AddBlock(blocks[i]);
+    r.AddBlock(last);
+    r.AddBlock(UW);
+
+    r.Calculate(blocks[0]);
+    r.Render();
+
+    puts(r.GetOutputBuffer());
+  }
 }
 
diff --git a/src/relooper/test.txt b/src/relooper/test.txt
index d53aeeb1ef129..2ae331c0691a9 100644
--- a/src/relooper/test.txt
+++ b/src/relooper/test.txt
@@ -417,3 +417,156 @@
  }
  // block D
 
+
+
+-- lots of exits to an unwind block, possible nesting --
+
+ // block
+ do {
+  if (check()) {
+   // block
+   if (check()) {
+    // block
+    if (check()) {
+     // block
+     if (check()) {
+      // block
+      if (check()) {
+       // block
+       if (check()) {
+        // block
+        if (check()) {
+         // block
+         if (check()) {
+          // block
+          if (check()) {
+           // block
+           if (check()) {
+            // block
+            if (check()) {
+             // block
+             if (check()) {
+              // block
+              if (check()) {
+               // block
+               if (check()) {
+                // block
+                if (check()) {
+                 // block
+                 if (check()) {
+                  // block
+                  if (check()) {
+                   // block
+                   if (check()) {
+                    // block
+                    if (check()) {
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // block
+                     if (!(check())) {
+                      break;
+                     }
+                     // last
+                     return;
+                    }
+                   }
+                  }
+                 }
+                }
+               }
+              }
+             }
+            }
+           }
+          }
+         }
+        }
+       }
+      }
+     }
+    }
+   }
+  }
+ } while(0);
+ // UW
+ resumeException();
+ 
+
diff --git a/system/lib/libc.symbols b/system/lib/libc.symbols
index eb2053ce095a7..d889d509f8017 100644
--- a/system/lib/libc.symbols
+++ b/system/lib/libc.symbols
@@ -40,6 +40,7 @@
          W _Znwj
          W _ZnwjRKSt9nothrow_t
          T __floatscan
+         T __intscan
          T __overflow
          T __shgetc
          T __shlim
@@ -57,6 +58,9 @@
          W free
          W independent_calloc
          W independent_comalloc
+         T isdigit
+         T isspace
+         T isupper
          W mallinfo
          W malloc
          W malloc_footprint
@@ -77,6 +81,12 @@
          T memcmp
          T memcpy
          T strtod
+         T strtoull
+         T strtoll
+         T strtoul
+         T strtol
+         T strtoimax
+         T strtoumax
          T strcoll
          T __strcoll_l
          W strcoll_l
@@ -89,4 +99,5 @@
          T strtof_l
          T strtold
          T strtold_l
+         T tolower
          W valloc
diff --git a/system/lib/libc/musl/src/compat/readme.txt b/system/lib/libc/musl/src/compat/readme.txt
new file mode 100644
index 0000000000000..c96c613641c52
--- /dev/null
+++ b/system/lib/libc/musl/src/compat/readme.txt
@@ -0,0 +1,2 @@
+Files in this directory are not strictly standard musl libc, but implemented here for compatibility for Emscripten purposes.
+
diff --git a/system/lib/libc/musl/src/compat/strlwr.c b/system/lib/libc/musl/src/compat/strlwr.c
new file mode 100644
index 0000000000000..90d6c106d883c
--- /dev/null
+++ b/system/lib/libc/musl/src/compat/strlwr.c
@@ -0,0 +1,10 @@
+#include <ctype.h>
+
+void strlwr(char *str)
+{
+	while(*str)
+	{
+		*str = tolower(*str);
+		++str;
+	}
+}
diff --git a/system/lib/libc/musl/src/compat/strtol_l.c b/system/lib/libc/musl/src/compat/strtol_l.c
new file mode 100644
index 0000000000000..58b46186941c2
--- /dev/null
+++ b/system/lib/libc/musl/src/compat/strtol_l.c
@@ -0,0 +1,22 @@
+#include <stdlib.h>
+#include <ctype.h>
+
+unsigned long long strtoull_l(const char *restrict s, char **restrict p, int base, locale_t loc)
+{
+	return strtoull(s, p, base);
+}
+
+long long strtoll_l(const char *restrict s, char **restrict p, int base, locale_t loc)
+{
+	return strtoll(s, p, base);
+}
+
+unsigned long strtoul_l(const char *restrict s, char **restrict p, int base, locale_t loc)
+{
+	return strtoul(s, p, base);
+}
+
+long strtol_l(const char *restrict s, char **restrict p, int base, locale_t loc)
+{
+	return strtol(s, p, base);
+}
diff --git a/system/lib/libc/musl/src/compat/strupr.c b/system/lib/libc/musl/src/compat/strupr.c
new file mode 100644
index 0000000000000..2b1d97bb06e92
--- /dev/null
+++ b/system/lib/libc/musl/src/compat/strupr.c
@@ -0,0 +1,10 @@
+#include <ctype.h>
+
+void strupr(char *str)
+{
+	while(*str)
+	{
+		*str = toupper(*str);
+		++str;
+	}
+}
diff --git a/system/lib/libc/musl/src/ctype/isalnum.c b/system/lib/libc/musl/src/ctype/isalnum.c
new file mode 100644
index 0000000000000..e3d2cf0b4ee32
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isalnum.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isalnum(int c)
+{
+	return isalpha(c) || isdigit(c);
+}
diff --git a/system/lib/libc/musl/src/ctype/isalpha.c b/system/lib/libc/musl/src/ctype/isalpha.c
new file mode 100644
index 0000000000000..53e115c29df71
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isalpha.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+#undef isalpha
+
+int isalpha(int c)
+{
+	return ((unsigned)c|32)-'a' < 26;
+}
diff --git a/system/lib/libc/musl/src/ctype/isascii.c b/system/lib/libc/musl/src/ctype/isascii.c
new file mode 100644
index 0000000000000..3af0a10d4f097
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isascii.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isascii(int c)
+{
+	return !(c&~0x7f);
+}
diff --git a/system/lib/libc/musl/src/ctype/isblank.c b/system/lib/libc/musl/src/ctype/isblank.c
new file mode 100644
index 0000000000000..957400b2bbe2a
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isblank.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isblank(int c)
+{
+	return (c == ' ' || c == '\t');
+}
diff --git a/system/lib/libc/musl/src/ctype/iscntrl.c b/system/lib/libc/musl/src/ctype/iscntrl.c
new file mode 100644
index 0000000000000..92ed7f0e9adcb
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/iscntrl.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int iscntrl(int c)
+{
+	return (unsigned)c < 0x20 || c == 0x7f;
+}
diff --git a/system/lib/libc/musl/src/ctype/isdigit.c b/system/lib/libc/musl/src/ctype/isdigit.c
new file mode 100644
index 0000000000000..0bc82a6d76d8e
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isdigit.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+#undef isdigit
+
+int isdigit(int c)
+{
+	return (unsigned)c-'0' < 10;
+}
diff --git a/system/lib/libc/musl/src/ctype/isgraph.c b/system/lib/libc/musl/src/ctype/isgraph.c
new file mode 100644
index 0000000000000..98979d1e898b9
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isgraph.c
@@ -0,0 +1,4 @@
+int isgraph(int c)
+{
+	return (unsigned)c-0x21 < 0x5e;
+}
diff --git a/system/lib/libc/musl/src/ctype/islower.c b/system/lib/libc/musl/src/ctype/islower.c
new file mode 100644
index 0000000000000..d72fb212f2459
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/islower.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+#undef islower
+
+int islower(int c)
+{
+	return (unsigned)c-'a' < 26;
+}
diff --git a/system/lib/libc/musl/src/ctype/isprint.c b/system/lib/libc/musl/src/ctype/isprint.c
new file mode 100644
index 0000000000000..504e66ed127f7
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isprint.c
@@ -0,0 +1,4 @@
+int isprint(int c)
+{
+	return (unsigned)c-0x20 < 0x5f;
+}
diff --git a/system/lib/libc/musl/src/ctype/ispunct.c b/system/lib/libc/musl/src/ctype/ispunct.c
new file mode 100644
index 0000000000000..fc455352b5148
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/ispunct.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int ispunct(int c)
+{
+	return isgraph(c) && !isalnum(c);
+}
diff --git a/system/lib/libc/musl/src/ctype/isspace.c b/system/lib/libc/musl/src/ctype/isspace.c
new file mode 100644
index 0000000000000..8e535aa1dc59e
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isspace.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isspace(int c)
+{
+	return c == ' ' || (unsigned)c-'\t' < 5;
+}
diff --git a/system/lib/libc/musl/src/ctype/isupper.c b/system/lib/libc/musl/src/ctype/isupper.c
new file mode 100644
index 0000000000000..f09d88c57c34a
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isupper.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+#undef isupper
+
+int isupper(int c)
+{
+	return (unsigned)c-'A' < 26;
+}
diff --git a/system/lib/libc/musl/src/ctype/isxdigit.c b/system/lib/libc/musl/src/ctype/isxdigit.c
new file mode 100644
index 0000000000000..ae68a3dc9249b
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/isxdigit.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isxdigit(int c)
+{
+	return isdigit(c) || ((unsigned)c|32)-'a' < 6;
+}
diff --git a/system/lib/libc/musl/src/ctype/toascii.c b/system/lib/libc/musl/src/ctype/toascii.c
new file mode 100644
index 0000000000000..f0e48e8e91761
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/toascii.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+
+/* nonsense function that should NEVER be used! */
+int toascii(int c)
+{
+	return c & 0x7f;
+}
diff --git a/system/lib/libc/musl/src/ctype/tolower.c b/system/lib/libc/musl/src/ctype/tolower.c
new file mode 100644
index 0000000000000..b56f3c5094a24
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/tolower.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+
+int tolower(int c)
+{
+	if (isupper(c)) return c | 32;
+	return c;
+}
diff --git a/system/lib/libc/musl/src/ctype/toupper.c b/system/lib/libc/musl/src/ctype/toupper.c
new file mode 100644
index 0000000000000..1799f0307789a
--- /dev/null
+++ b/system/lib/libc/musl/src/ctype/toupper.c
@@ -0,0 +1,7 @@
+#include <ctype.h>
+
+int toupper(int c)
+{
+	if (islower(c)) return c & 0x5f;
+	return c;
+}
diff --git a/system/lib/libc/musl/src/locale/isalnum_l.c b/system/lib/libc/musl/src/locale/isalnum_l.c
new file mode 100644
index 0000000000000..b8a6eef373f0b
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isalnum_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isalnum_l(int c, locale_t l)
+{
+	return isalnum(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isalpha_l.c b/system/lib/libc/musl/src/locale/isalpha_l.c
new file mode 100644
index 0000000000000..2e1205c617e70
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isalpha_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isalpha_l(int c, locale_t l)
+{
+	return isalpha(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isblank_l.c b/system/lib/libc/musl/src/locale/isblank_l.c
new file mode 100644
index 0000000000000..27479aa151fba
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isblank_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isblank_l(int c, locale_t l)
+{
+	return isblank(c);
+}
diff --git a/system/lib/libc/musl/src/locale/iscntrl_l.c b/system/lib/libc/musl/src/locale/iscntrl_l.c
new file mode 100644
index 0000000000000..ca596fa9d7c76
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/iscntrl_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int iscntrl_l(int c, locale_t l)
+{
+	return iscntrl(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isdigit_l.c b/system/lib/libc/musl/src/locale/isdigit_l.c
new file mode 100644
index 0000000000000..c8ae7bd319037
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isdigit_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isdigit_l(int c, locale_t l)
+{
+	return isdigit(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isgraph_l.c b/system/lib/libc/musl/src/locale/isgraph_l.c
new file mode 100644
index 0000000000000..713a86e6956ac
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isgraph_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isgraph_l(int c, locale_t l)
+{
+	return isgraph(c);
+}
diff --git a/system/lib/libc/musl/src/locale/islower_l.c b/system/lib/libc/musl/src/locale/islower_l.c
new file mode 100644
index 0000000000000..25ec97a12a415
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/islower_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int islower_l(int c, locale_t l)
+{
+	return islower(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isprint_l.c b/system/lib/libc/musl/src/locale/isprint_l.c
new file mode 100644
index 0000000000000..79ef351426975
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isprint_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isprint_l(int c, locale_t l)
+{
+	return isprint(c);
+}
diff --git a/system/lib/libc/musl/src/locale/ispunct_l.c b/system/lib/libc/musl/src/locale/ispunct_l.c
new file mode 100644
index 0000000000000..1c0bd046ab61b
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/ispunct_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int ispunct_l(int c, locale_t l)
+{
+	return ispunct(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isspace_l.c b/system/lib/libc/musl/src/locale/isspace_l.c
new file mode 100644
index 0000000000000..e1a0efed92059
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isspace_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isspace_l(int c, locale_t l)
+{
+	return isspace(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isupper_l.c b/system/lib/libc/musl/src/locale/isupper_l.c
new file mode 100644
index 0000000000000..11ba703638b53
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isupper_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isupper_l(int c, locale_t l)
+{
+	return isupper(c);
+}
diff --git a/system/lib/libc/musl/src/locale/isxdigit_l.c b/system/lib/libc/musl/src/locale/isxdigit_l.c
new file mode 100644
index 0000000000000..68649d093ad9b
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/isxdigit_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int isxdigit_l(int c, locale_t l)
+{
+	return isxdigit(c);
+}
diff --git a/system/lib/libc/musl/src/locale/tolower_l.c b/system/lib/libc/musl/src/locale/tolower_l.c
new file mode 100644
index 0000000000000..ba277919e2193
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/tolower_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int tolower_l(int c, locale_t l)
+{
+	return tolower(c);
+}
diff --git a/system/lib/libc/musl/src/locale/toupper_l.c b/system/lib/libc/musl/src/locale/toupper_l.c
new file mode 100644
index 0000000000000..73f2f39be13a1
--- /dev/null
+++ b/system/lib/libc/musl/src/locale/toupper_l.c
@@ -0,0 +1,6 @@
+#include <ctype.h>
+
+int toupper_l(int c, locale_t l)
+{
+	return toupper(c);
+}
diff --git a/system/lib/libc/musl/src/stdlib/strtol.c b/system/lib/libc/musl/src/stdlib/strtol.c
new file mode 100644
index 0000000000000..730bf2d7bd6d7
--- /dev/null
+++ b/system/lib/libc/musl/src/stdlib/strtol.c
@@ -0,0 +1,64 @@
+#include "stdio_impl.h"
+#include "intscan.h"
+#include "shgetc.h"
+#include <inttypes.h>
+#include <limits.h>
+#include <ctype.h>
+#include "libc.h"
+
+static unsigned long long strtox(const char *s, char **p, int base, unsigned long long lim)
+{
+	/* FIXME: use a helper function or macro to setup the FILE */
+	FILE f;
+	f.flags = 0;
+	f.buf = f.rpos = (void *)s;
+	if ((size_t)s > (size_t)-1/2)
+		f.rend = (void *)-1;
+	else
+		f.rend = (unsigned char *)s+(size_t)-1/2;
+	f.lock = -1;
+	shlim(&f, 0);
+	unsigned long long y = __intscan(&f, base, 1, lim);
+	if (p) {
+		size_t cnt = shcnt(&f);
+		*p = (char *)s + cnt;
+	}
+	return y;
+}
+
+unsigned long long strtoull(const char *restrict s, char **restrict p, int base)
+{
+	return strtox(s, p, base, ULLONG_MAX);
+}
+
+long long strtoll(const char *restrict s, char **restrict p, int base)
+{
+	return strtox(s, p, base, LLONG_MIN);
+}
+
+unsigned long strtoul(const char *restrict s, char **restrict p, int base)
+{
+	return strtox(s, p, base, ULONG_MAX);
+}
+
+long strtol(const char *restrict s, char **restrict p, int base)
+{
+	return strtox(s, p, base, 0UL+LONG_MIN);
+}
+
+intmax_t strtoimax(const char *restrict s, char **restrict p, int base)
+{
+	return strtoll(s, p, base);
+}
+
+uintmax_t strtoumax(const char *restrict s, char **restrict p, int base)
+{
+	return strtoull(s, p, base);
+}
+
+weak_alias(strtol, __strtol_internal);
+weak_alias(strtoul, __strtoul_internal);
+weak_alias(strtoll, __strtoll_internal);
+weak_alias(strtoull, __strtoull_internal);
+weak_alias(strtoimax, __strtoimax_internal);
+weak_alias(strtoumax, __strtoumax_internal);
diff --git a/system/lib/libcextra.symbols b/system/lib/libcextra.symbols
index 64ba670a0fef4..17e524e669574 100644
--- a/system/lib/libcextra.symbols
+++ b/system/lib/libcextra.symbols
@@ -1,7 +1,6 @@
          T __cos
          T __cosdf
          T __fputwc_unlocked
-         T __intscan
          W __iswctype_l
          T __lgamma_r
          T __lgammaf_r
@@ -46,6 +45,27 @@
          T ilogbf
          T ilogbl
          T index
+         T isascii
+         T islower
+         T islower_l
+         T isupper_l
+         T isalpha
+         T isalpha_l
+         T isblank_l
+         T isdigit_l
+         T isxdigit
+         T isxdigit_l
+         T isalnum
+         T isalnum_l
+         T ispunct
+         T ispunct_l
+         T isspace_l
+         T iscntrl
+         T iscntrl_l
+         T isprint
+         T isprint_l
+         T isgraph
+         T isgraph_l
          T iswalnum
          T iswalnum_l
          T iswalpha
@@ -122,6 +142,7 @@
          T strfmon_l
          T strlcat
          T strlcpy
+         T strlwr
          T strncasecmp_l
          T strncat
          T strndup
@@ -133,6 +154,11 @@
          T strstr
          T strtok
          T strtok_r
+         T strtoull_l
+         T strtoll_l
+         T strtoul_l
+         T strtol_l
+         T strupr
          T strverscmp
          T strxfrm
          W strxfrm_l
@@ -140,6 +166,10 @@
          T tgamma
          T tgammaf
          T tgammal
+         T toascii
+         T toupper
+         T toupper_l
+         T tolower_l
          T towctrans
          T towctrans_l
          T towlower
diff --git a/tests/life.c b/tests/life.c
index 4ce8d3850ff69..263fa0e631229 100644
--- a/tests/life.c
+++ b/tests/life.c
@@ -67,7 +67,9 @@ void game(int w, int h, int i)
       i--;
       nudge(univ, w, h); // keep it interesting for benchmark
     } else {
+#if !__EMSCRIPTEN__
       usleep(20000);
+#endif
       show(univ, w, h);
     }
   }
diff --git a/tests/sdl_audio_mix.c b/tests/sdl_audio_mix.c
index a1c0485d18173..422fc12208be3 100644
--- a/tests/sdl_audio_mix.c
+++ b/tests/sdl_audio_mix.c
@@ -58,7 +58,9 @@ void one_iter() {
       Mix_HaltChannel(soundChannel);
       Mix_HaltMusic();
       int result = 1;
+#ifdef REPORT_RESULT
       REPORT_RESULT();
+#endif
       break;
   };
 }
diff --git a/tests/test_other.py b/tests/test_other.py
index 4a6296e0215a3..5553a7b13282f 100644
--- a/tests/test_other.py
+++ b/tests/test_other.py
@@ -1027,10 +1027,85 @@ def test_multiply_defined_libsymbols_2(self):
     Building.emar('cr', lib_name, [a_name + '.o', b_name + '.o']) # libLIB.a with a and b
 
     # a is in the lib AND in an .o, so should be ignored in the lib. We do still need b from the lib though
-    Building.emcc(main_name, ['-L.', '-lLIB', a_name+'.o', c_name + '.o'], output_filename='a.out.js')
+    Building.emcc(main_name, [a_name+'.o', c_name + '.o', '-L.', '-lLIB'], output_filename='a.out.js')
 
     self.assertContained('result: 62', run_js(os.path.join(self.get_dir(), 'a.out.js')))
 
+  def test_link_group_asserts(self):
+    lib_src_name = os.path.join(self.get_dir(), 'lib.c')
+    open(lib_src_name, 'w').write('int x() { return 42; }')
+
+    main_name = os.path.join(self.get_dir(), 'main.c')
+    open(main_name, 'w').write(r'''
+      #include <stdio.h>
+      int x();
+      int main() {
+        printf("result: %d\n", x());
+        return 0;
+      }
+    ''')
+
+    Building.emcc(lib_src_name) # lib.c.o
+    lib_name = os.path.join(self.get_dir(), 'libLIB.a')
+    Building.emar('cr', lib_name, [lib_src_name + '.o']) # libLIB.a with lib.c.o
+
+    def test(lib_args, err_expected):
+      output = Popen([PYTHON, EMCC, main_name, '-o', 'a.out.js'] + lib_args, stdout=PIPE, stderr=PIPE).communicate()
+      if err_expected:
+        self.assertContained(err_expected, output[1])
+      else:
+        out_js = os.path.join(self.get_dir(), 'a.out.js')
+        assert os.path.exists(out_js), '\n'.join(output)
+        self.assertContained('result: 42', run_js(out_js))
+
+    test(['-Wl,--start-group', lib_name], '--start-group without matching --end-group')
+    test(['-Wl,--start-group', lib_name, '-Wl,--start-group'], 'Nested --start-group, missing --end-group?')
+    test(['-Wl,--end-group', lib_name, '-Wl,--start-group'], '--end-group without --start-group')
+    test(['-Wl,--start-group', lib_name, '-Wl,--end-group'], None)
+
+  def test_circular_libs(self):
+    def tmp_source(name, code):
+      file_name = os.path.join(self.get_dir(), name)
+      open(file_name, 'w').write(code)
+      return file_name
+
+    a = tmp_source('a.c', 'int z(); int x() { return z(); }')
+    b = tmp_source('b.c', 'int x(); int y() { return x(); } int z() { return 42; }')
+    c = tmp_source('c.c', 'int q() { return 0; }')
+    main = tmp_source('main.c', r'''
+      #include <stdio.h>
+      int y();
+      int main() {
+        printf("result: %d\n", y());
+        return 0;
+      }
+    ''')
+
+    Building.emcc(a) # a.c.o
+    Building.emcc(b) # b.c.o
+    Building.emcc(c) # c.c.o
+    lib_a = os.path.join(self.get_dir(), 'libA.a')
+    Building.emar('cr', lib_a, [a + '.o', c + '.o']) # libA.a with a.c.o,c.c.o
+    lib_b = os.path.join(self.get_dir(), 'libB.a')
+    Building.emar('cr', lib_b, [b + '.o', c + '.o']) # libB.a with b.c.o,c.c.o
+
+    args = ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=1', main, '-o', 'a.out.js']
+    libs = [lib_a, lib_b]
+
+    # lib_a does not satisfy any symbols from main, so it will not be included,
+    # and there will be an unresolved symbol.
+    output = Popen([PYTHON, EMCC] + args + libs, stdout=PIPE, stderr=PIPE).communicate()
+    self.assertContained('error: unresolved symbol: x', output[1])
+
+    # -Wl,--start-group and -Wl,--end-group around the libs will cause a rescan
+    # of lib_a after lib_b adds undefined symbol "x", so a.c.o will now be
+    # included (and the link will succeed).
+    libs = ['-Wl,--start-group'] + libs + ['-Wl,--end-group']
+    output = Popen([PYTHON, EMCC] + args + libs, stdout=PIPE, stderr=PIPE).communicate()
+    out_js = os.path.join(self.get_dir(), 'a.out.js')
+    assert os.path.exists(out_js), '\n'.join(output)
+    self.assertContained('result: 42', run_js(out_js))
+
   def test_redundant_link(self):
     lib = "int mult() { return 1; }"
     lib_name = os.path.join(self.get_dir(), 'libA.c')
diff --git a/tools/bisect_pair_lines.py b/tools/bisect_pair_lines.py
new file mode 100644
index 0000000000000..f698ef2a74756
--- /dev/null
+++ b/tools/bisect_pair_lines.py
@@ -0,0 +1,63 @@
+'''
+Given two similar files, for example one with an additional optimization pass,
+and with different results, will bisect between them to find the smallest
+diff that makes the outputs different.
+Unlike bisect_pairs, this uses lines instead of diffs. We replace line by line. This assumes
+the programs differ on each line but lines have not been added or removed
+'''
+
+import os, sys, shutil
+from subprocess import Popen, PIPE, STDOUT
+
+__rootpath__ = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+exec(open(path_from_root('tools', 'shared.py'), 'r').read())
+
+file1 = open(sys.argv[1]).read()
+file2 = open(sys.argv[2]).read()
+
+leftf = open('left', 'w')
+leftf.write(file1)
+leftf.close()
+
+rightf = open('right', 'w')
+rightf.write(file2)
+rightf.close()
+
+def run_code(name):
+  ret = run_js(name, stderr=PIPE, full_output=True)
+  # fix stack traces
+  ret = filter(lambda line: not line.startswith('    at ') and not name in line, ret.split('\n'))
+  return '\n'.join(ret)
+
+print 'running files'
+left_result = run_code('left')
+right_result = run_code('right') # right as in left-right, not as in correct
+assert left_result != right_result
+
+low = 0
+high = file1.count('\n')
+
+print 'beginning bisection, %d lines' % high
+
+left_lines = file1.split('\n')
+right_lines = file2.split('\n')
+
+while True:
+  mid = int((low + high)/2)
+  print low, high, '  current: %d' % mid,
+  open('middle', 'w').write('\n'.join(left_lines[:mid] + right_lines[mid:]))
+  shutil.copyfile('middle', 'middle' + str(mid))
+  result = run_code('middle')
+  print result == left_result, result == right_result#, 'XXX', left_result, 'YYY', result, 'ZZZ', right_result
+  if mid == low or mid == high: break
+  if result == right_result:
+    low = mid
+  elif result == left_result:
+    high = mid
+  else:
+    raise Exception('new result!?!?')
+
+print 'middle%d is like left, middle%d is like right' % (mid+1, mid)
+
diff --git a/tools/eliminator/asm-eliminator-test-output.js b/tools/eliminator/asm-eliminator-test-output.js
index d530a90cad87b..ab4c13cc7506b 100644
--- a/tools/eliminator/asm-eliminator-test-output.js
+++ b/tools/eliminator/asm-eliminator-test-output.js
@@ -954,4 +954,18 @@ function loopVarWithContinue() {
   }
  }
 }
+function helperExtraUse() {
+ var i = 0, i$looptemp = 0;
+ i = 0;
+ while (1) {
+  i$looptemp = i;
+  i = i + 1;
+  work(i$looptemp);
+  work(i);
+  if (check()) {
+   break;
+  }
+ }
+ return i;
+}
 
diff --git a/tools/eliminator/asm-eliminator-test.js b/tools/eliminator/asm-eliminator-test.js
index 8c469964a51d8..7b949c44d6948 100644
--- a/tools/eliminator/asm-eliminator-test.js
+++ b/tools/eliminator/asm-eliminator-test.js
@@ -1208,5 +1208,20 @@ function loopVarWithContinue() {
     }
   }
 }
-// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2", "watIf", "select2", "binary", "cute", "selfAssign", "elimOneLoopVar", "elimOneLoopVar2", "elimOneLoopVar3", "elimOneLoopVar4", "elimOneLoopVarStillUsed", "elimOneLoopVarStillUsedSE", "elimOneLoopVar5"]
+function helperExtraUse() {
+ var i = 0, inc = 0;
+ i = 0;
+ while (1) {
+  inc = i + 1;
+  work(i);
+  work(inc);
+  if (check()) {
+   break;
+  } else {
+   i = inc;
+  }
+ }
+ return inc;
+}
+// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2", "watIf", "select2", "binary", "cute", "selfAssign", "elimOneLoopVar", "elimOneLoopVar2", "elimOneLoopVar3", "elimOneLoopVar4", "elimOneLoopVarStillUsed", "elimOneLoopVarStillUsedSE", "elimOneLoopVar5", "helperExtraUse"]
 
diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js
index c0096df420653..2004efdac9e08 100644
--- a/tools/js-optimizer.js
+++ b/tools/js-optimizer.js
@@ -750,9 +750,12 @@ function simplifyExpressions(ast) {
   }
 
   function emitsBoolean(node) {
+    if (node[0] === 'num') {
+      return node[1] === 0 || node[1] === 1;
+    }
     if (node[0] === 'binary') return node[1] in COMPARE_OPS;
     if (node[0] === 'unary-prefix') return node[1] === '!';
-    if (node[0] === 'conditional') return true;
+    if (node[0] === 'conditional') return emitsBoolean(node[2]) && emitsBoolean(node[3]);
     return false;
   }
 
@@ -1030,6 +1033,7 @@ function hasSideEffects(node) { // this is 99% incomplete!
       }
       return false;
     }
+    case 'conditional': return hasSideEffects(node[1]) || hasSideEffects(node[2]) || hasSideEffects(node[3]); 
     default: return true;
   }
 }
@@ -2233,18 +2237,30 @@ function registerizeHarder(ast) {
           break;
         case 'conditional':
           isInExpr++;
-          buildFlowGraph(node[1]);
-          var jEnter = markJunction();
-          var jExit = addJunction();
-          if (node[2]) {
-            buildFlowGraph(node[2]);
-          }
-          joinJunction(jExit);
-          setJunction(jEnter);
-          if (node[3]) {
-            buildFlowGraph(node[3]);
+          // If the conditional has no side-effects, we can treat it as a single
+          // block, which might open up opportunities to remove it entirely.
+          if (!hasSideEffects(node)) {
+            buildFlowGraph(node[1]);
+            if (node[2]) {
+              buildFlowGraph(node[2]);
+            }
+            if (node[3]) {
+              buildFlowGraph(node[3]);
+            }
+          } else {
+            buildFlowGraph(node[1]);
+            var jEnter = markJunction();
+            var jExit = addJunction();
+            if (node[2]) {
+              buildFlowGraph(node[2]);
+            }
+            joinJunction(jExit);
+            setJunction(jEnter);
+            if (node[3]) {
+              buildFlowGraph(node[3]);
+            }
+            joinJunction(jExit);
           }
-          joinJunction(jExit);
           isInExpr--;
           break;
         case 'while':
@@ -3704,9 +3720,11 @@ function eliminate(ast, memSafe) {
               }
               if (firstLooperUsage >= 0) {
                 // the looper is used, we cannot simply merge the two variables
-                if ((firstHelperUsage < 0 || firstHelperUsage > lastLooperUsage) && lastLooperUsage+1 < stats.length && triviallySafeToMove(stats[found], asmData)) {
+                if ((firstHelperUsage < 0 || firstHelperUsage > lastLooperUsage) && lastLooperUsage+1 < stats.length && triviallySafeToMove(stats[found], asmData) &&
+                    seenUses[helper] === namings[helper]) {
                   // the helper is not used, or it is used after the last use of the looper, so they do not overlap,
                   // and the last looper usage is not on the last line (where we could not append after it), and the
+                  // helper is not used outside of the loop.
                   // just move the looper definition to after the looper's last use
                   stats.splice(lastLooperUsage+1, 0, stats[found]);
                   stats.splice(found, 1);
diff --git a/tools/shared.py b/tools/shared.py
index 5305d46b54fe5..fadec881b6b63 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -1144,63 +1144,131 @@ def link(files, target, force_archive_contents=False):
     unresolved_symbols = set([func[1:] for func in Settings.EXPORTED_FUNCTIONS])
     resolved_symbols = set()
     temp_dirs = []
-    files = map(os.path.abspath, files)
+    def make_paths_absolute(f):
+      if f.startswith('-'): # skip flags
+        return f
+      else:
+        return os.path.abspath(f)
+    files = map(make_paths_absolute, files)
+    # Paths of already included object files from archives.
+    added_contents = set()
+    # Map of archive name to list of extracted object file paths.
+    ar_contents = {}
     has_ar = False
     for f in files:
-      has_ar = has_ar or Building.is_ar(f)
+      if not f.startswith('-'):
+        has_ar = has_ar or Building.is_ar(f)
+
+    # If we have only one archive or the force_archive_contents flag is set,
+    # then we will add every object file we see, regardless of whether it
+    # resolves any undefined symbols.
+    force_add_all = len(files) == 1 or force_archive_contents
+
+    # Considers an object file for inclusion in the link. The object is included
+    # if force_add=True or if the object provides a currently undefined symbol.
+    # If the object is included, the symbol tables are updated and the function
+    # returns True.
+    def consider_object(f, force_add=False):
+      new_symbols = Building.llvm_nm(f)
+      do_add = force_add or not unresolved_symbols.isdisjoint(new_symbols.defs)
+      if do_add:
+        logging.debug('adding object %s to link' % (f))
+        # Update resolved_symbols table with newly resolved symbols
+        resolved_symbols.update(new_symbols.defs)
+        # Update unresolved_symbols table by adding newly unresolved symbols and
+        # removing newly resolved symbols.
+        unresolved_symbols.update(new_symbols.undefs.difference(resolved_symbols))
+        unresolved_symbols.difference_update(new_symbols.defs)
+        actual_files.append(f)
+      return do_add
+
+    def get_archive_contents(f):
+      if f in ar_contents:
+        return ar_contents[f]
+
+      cwd = os.getcwd()
+      try:
+        temp_dir = os.path.join(EMSCRIPTEN_TEMP_DIR, 'ar_output_' + str(os.getpid()) + '_' + str(len(temp_dirs)))
+        temp_dirs.append(temp_dir)
+        safe_ensure_dirs(temp_dir)
+        os.chdir(temp_dir)
+        contents = filter(lambda x: len(x) > 0, Popen([LLVM_AR, 't', f], stdout=PIPE).communicate()[0].split('\n'))
+        if len(contents) == 0:
+          logging.debug('Archive %s appears to be empty (recommendation: link an .so instead of .a)' % f)
+        else:
+          for content in contents: # ar will silently fail if the directory for the file does not exist, so make all the necessary directories
+            dirname = os.path.dirname(content)
+            if dirname:
+              safe_ensure_dirs(dirname)
+          Popen([LLVM_AR, 'xo', f], stdout=PIPE).communicate() # if absolute paths, files will appear there. otherwise, in this directory
+          contents = map(lambda content: os.path.join(temp_dir, content), contents)
+          contents = filter(os.path.exists, map(os.path.abspath, contents))
+          contents = filter(Building.is_bitcode, contents)
+        ar_contents[f] = contents
+      finally:
+        os.chdir(cwd)
+
+      return contents
+
+    # Traverse a single archive. The object files are repeatedly scanned for
+    # newly satisfied symbols until no new symbols are found. Returns true if
+    # any object files were added to the link.
+    def consider_archive(f):
+      added_any_objects = False
+      loop_again = True
+      logging.debug('considering archive %s' % (f))
+      contents = get_archive_contents(f)
+      while loop_again: # repeatedly traverse until we have everything we need
+        loop_again = False
+        for content in contents:
+          if content in added_contents: continue
+          # Link in the .o if it provides symbols, *or* this is a singleton archive (which is apparently an exception in gcc ld)
+          if consider_object(content, force_add=force_add_all):
+            added_contents.add(content)
+            loop_again = True
+            added_any_objects = True
+      logging.debug('done running loop of archive %s' % (f))
+      return added_any_objects
+
+    current_archive_group = None
     for f in files:
-      if not Building.is_ar(f):
+      if f.startswith('-'):
+        if f in ['--start-group', '-(']:
+          assert current_archive_group is None, 'Nested --start-group, missing --end-group?'
+          current_archive_group = []
+        elif f in ['--end-group', '-)']:
+          assert current_archive_group is not None, '--end-group without --start-group'
+          # rescan the archives in the group until we don't find any more
+          # objects to link.
+          loop_again = True
+          logging.debug('starting archive group loop');
+          while loop_again:
+            loop_again = False
+            for archive in current_archive_group:
+              if consider_archive(archive):
+                loop_again = True
+          logging.debug('done with archive group loop');
+          current_archive_group = None
+        else:
+          logging.debug('Ignoring unsupported link flag: %s' % f)
+      elif not Building.is_ar(f):
         if Building.is_bitcode(f):
           if has_ar:
-            new_symbols = Building.llvm_nm(f)
-            resolved_symbols = resolved_symbols.union(new_symbols.defs)
-            unresolved_symbols = unresolved_symbols.union(new_symbols.undefs.difference(resolved_symbols)).difference(new_symbols.defs)
-          actual_files.append(f)
+            consider_object(f, force_add=True)
+          else:
+            # If there are no archives then we can simply link all valid bitcode
+            # files and skip the symbol table stuff.
+            actual_files.append(f)
       else:
         # Extract object files from ar archives, and link according to gnu ld semantics
         # (link in an entire .o from the archive if it supplies symbols still unresolved)
-        cwd = os.getcwd()
-        try:
-          temp_dir = os.path.join(EMSCRIPTEN_TEMP_DIR, 'ar_output_' + str(os.getpid()) + '_' + str(len(temp_dirs)))
-          temp_dirs.append(temp_dir)
-          safe_ensure_dirs(temp_dir)
-          os.chdir(temp_dir)
-          contents = filter(lambda x: len(x) > 0, Popen([LLVM_AR, 't', f], stdout=PIPE).communicate()[0].split('\n'))
-          #print >> sys.stderr, '  considering archive', f, ':', contents
-          if len(contents) == 0:
-            logging.debug('Archive %s appears to be empty (recommendation: link an .so instead of .a)' % f)
-          else:
-            for content in contents: # ar will silently fail if the directory for the file does not exist, so make all the necessary directories
-              dirname = os.path.dirname(content)
-              if dirname:
-                safe_ensure_dirs(dirname)
-            Popen([LLVM_AR, 'xo', f], stdout=PIPE).communicate() # if absolute paths, files will appear there. otherwise, in this directory
-            contents = map(lambda content: os.path.join(temp_dir, content), contents)
-            contents = filter(os.path.exists, map(os.path.abspath, contents))
-            added_contents = set()
-            added = True
-            #print >> sys.stderr, '  initial undef are now ', unresolved_symbols, '\n'
-            while added: # recursively traverse until we have everything we need
-              #print >> sys.stderr, '  running loop of archive including for', f
-              added = False
-              for content in contents:
-                if content in added_contents: continue 
-                new_symbols = Building.llvm_nm(content)
-                # Link in the .o if it provides symbols, *or* this is a singleton archive (which is apparently an exception in gcc ld)
-                #print >> sys.stderr, 'need', content, '?', unresolved_symbols, 'and we can supply', new_symbols.defs
-                #print >> sys.stderr, content, 'DEF', new_symbols.defs, '\n'
-                if new_symbols.defs.intersection(unresolved_symbols) or len(files) == 1 or force_archive_contents:
-                  if Building.is_bitcode(content):
-                    #print >> sys.stderr, '  adding object', content, '\n'
-                    resolved_symbols = resolved_symbols.union(new_symbols.defs)
-                    unresolved_symbols = unresolved_symbols.union(new_symbols.undefs.difference(resolved_symbols)).difference(new_symbols.defs)
-                    #print >> sys.stderr, '  undef are now ', unresolved_symbols, '\n'
-                    actual_files.append(content)
-                    added_contents.add(content)
-                    added = True
-            #print >> sys.stderr, '  done running loop of archive including for', f
-        finally:
-          os.chdir(cwd)
+        consider_archive(f)
+        # If we're inside a --start-group/--end-group section, add to the list
+        # so we can loop back around later.
+        if current_archive_group is not None:
+          current_archive_group.append(f)
+    assert current_archive_group is None, '--start-group without matching --end-group'
+
     try_delete(target)
 
     # Finish link
diff --git a/tools/system_libs.py b/tools/system_libs.py
index 50910a8af6d49..bc81a35104d1c 100644
--- a/tools/system_libs.py
+++ b/tools/system_libs.py
@@ -55,7 +55,14 @@ def create_libc():
       os.path.join('libcxx', 'new.cpp'),
     ]
     musl_files = [
+      ['ctype', [
+       'isdigit.c',
+       'isspace.c',
+       'isupper.c',
+       'tolower.c',
+      ]],
       ['internal', [
+       'intscan.c',
        'floatscan.c',
        'shgetc.c',
       ]],
@@ -74,6 +81,7 @@ def create_libc():
        'atoi.c',
        'atol.c',
        'strtod.c',
+       'strtol.c',
       ]],
       ['string', [
        'memcmp.c',
@@ -103,7 +111,22 @@ def apply_libc(need):
   def create_libcextra():
     logging.debug('building libcextra for cache')
     musl_files = [
+       ['compat', [
+        'strlwr.c',
+        'strtol_l.c',
+        'strupr.c'
+       ]],
        ['ctype', [
+        'isalnum.c',
+        'isalpha.c',
+        'isascii.c',
+        'isblank.c',
+        'iscntrl.c',
+        'isgraph.c',
+        'islower.c',
+        'isprint.c',
+        'ispunct.c',
+        'isxdigit.c',
         'iswalnum.c',
         'iswalpha.c',
         'iswblank.c',
@@ -117,19 +140,30 @@ def create_libcextra():
         'iswspace.c',
         'iswupper.c',
         'iswxdigit.c',
+        'toascii.c',
+        'toupper.c',
         'towctrans.c',
         'wcswidth.c',
         'wctrans.c',
         'wcwidth.c',
        ]],
-       ['internal', [
-        'intscan.c',
-       ]],
        ['legacy', [
         'err.c',
        ]],
        ['locale', [
         'iconv.c',
+        'isalnum_l.c',
+        'isalpha_l.c',
+        'isblank_l.c',
+        'iscntrl_l.c',
+        'isdigit_l.c',
+        'isgraph_l.c',
+        'islower_l.c',
+        'isprint_l.c',
+        'ispunct_l.c',
+        'isspace_l.c',
+        'isupper_l.c',
+        'isxdigit_l.c',
         'iswalnum_l.c',
         'iswalpha_l.c',
         'iswblank_l.c',
@@ -148,6 +182,8 @@ def create_libcextra():
         'strfmon.c',
         'strncasecmp_l.c',
         'strxfrm.c',
+        'tolower_l.c',
+        'toupper_l.c',
         'towctrans_l.c',
         'towlower_l.c',
         'towupper_l.c',
diff --git a/tools/test-js-optimizer-asm-pre-output.js b/tools/test-js-optimizer-asm-pre-output.js
index 31b9cfd70572c..5281b87c99f57 100644
--- a/tools/test-js-optimizer-asm-pre-output.js
+++ b/tools/test-js-optimizer-asm-pre-output.js
@@ -596,6 +596,10 @@ function conditionalizeMe() {
  if (x > 10 | HEAP[20] + 2 > 5) {
   b();
  }
+ print(((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > a % b % c % d ? 1 : $el) | $cheap > 0);
+ print(((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > a % b % c % d ? 1 : -1) | $cheap > 0);
+ print($cheap > 0 ? 1 : (HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > a % b % c % d ? 1 : 0);
+ print(((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > a % b % c % d ? -1 : 1) | $cheap > 0);
  return (((((Math_imul(i6 + 1, i7) | 0) + 17 | 0) % 5 | 0) == 0 ? 1 : ((((Math_imul(i7 + 1, i7) | 0) + 11 | 0) >>> 0) % 3 | 0) == 0) | 0) == 0;
 }
 
diff --git a/tools/test-js-optimizer-asm-pre.js b/tools/test-js-optimizer-asm-pre.js
index 2a6ea4a9be883..d48d736e66f13 100644
--- a/tools/test-js-optimizer-asm-pre.js
+++ b/tools/test-js-optimizer-asm-pre.js
@@ -608,6 +608,10 @@ function conditionalizeMe() {
  if (x > 10 | (HEAP[20] + 2) > 5) {
   b();
  }
+ print( (((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > (a % b % c % d)) ? 1 : $el) | ($cheap > 0) ); // conditional does not always emit boolean
+ print( (((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > (a % b % c % d)) ? 1 : -1) | ($cheap > 0) );
+ print( (((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > (a % b % c % d)) ? 1 : 0) | ($cheap > 0) ); // this one is safe!
+ print( (((HEAP8[a] + HEAP8[b] + HEAP8[c] + HEAP8[d] + HEAP8[e] + HEAP8[f] | 0) > (a % b % c % d)) ? -1 : 1) | ($cheap > 0) );
  return ((((Math_imul(i6+1, i7) | 0) + 17 | 0) % 5 | 0 | 0) == 0 | ((((Math_imul(i7+1, i7) | 0) + 11 | 0) >>> 0) % 3 | 0 | 0) == 0 | 0) == 0;
 }
 // EMSCRIPTEN_GENERATED_FUNCTIONS: ["a", "b", "rett", "ret2t", "retf", "i32_8", "tempDoublePtr", "boxx", "_main", "badf", "badf2", "fcomp", "conditionalizeMe"]
diff --git a/tools/test-js-optimizer-asm-regs-harder-output.js b/tools/test-js-optimizer-asm-regs-harder-output.js
index e1df42cba145b..c3b326f61feef 100644
--- a/tools/test-js-optimizer-asm-regs-harder-output.js
+++ b/tools/test-js-optimizer-asm-regs-harder-output.js
@@ -129,4 +129,9 @@ function linkedVars() {
  }
  return i2 + i1;
 }
+function deadCondExpr(i2) {
+ i2 = i2 | 0;
+ var i1 = 0;
+ return i1 | 0;
+}
 
diff --git a/tools/test-js-optimizer-asm-regs-harder.js b/tools/test-js-optimizer-asm-regs-harder.js
index 0231a2151768c..fa72aab8135a2 100644
--- a/tools/test-js-optimizer-asm-regs-harder.js
+++ b/tools/test-js-optimizer-asm-regs-harder.js
@@ -149,5 +149,11 @@ function linkedVars() {
  }
  return outer1 + outer2;
 }
-// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "_doit", "stackRestore", "switchey", "switchey2", "iffey", "labelledJump", "linkedVars']
+function deadCondExpr(input) {
+  input = input|0;
+  var dead = 0, temp = 0;
+  dead = (!input ? -1 : input)|0;
+  return temp|0;
+}
+// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "_doit", "stackRestore", "switchey", "switchey2", "iffey", "labelledJump", "linkedVars", "deadCondExpr"]