From 91d6303b960ba6b974ba39bd1f9d74a1ff95b7d9 Mon Sep 17 00:00:00 2001
From: Ryan Sturgell <ryan.sturgell@gmail.com>
Date: Tue, 8 Apr 2014 15:17:36 -0700
Subject: [PATCH 01/24] Add Ryan Sturgell to AUTHORS

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index 7994f80e26ba4..48a47f75f6418 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -138,3 +138,4 @@ a license to everyone to use it as detailed in LICENSE.)
 * Guillaume Blanc <guillaumeblanc.sc@gmail.com>
 * Usagi Ito <usagi@WonderRabbitProject.net>
 * Camilo Polymeris <cpolymeris@gmail.com>
+* Ryan Sturgell <ryan.sturgell@gmail.com> (copyright owned by Google, Inc.)

From 932106193279f333a849653daa284069e3583f55 Mon Sep 17 00:00:00 2001
From: Ryan Sturgell <ryan.sturgell@gmail.com>
Date: Tue, 8 Apr 2014 14:49:28 -0700
Subject: [PATCH 02/24] Extract helper functions from main link loop.

This enables future changes which will re-scan archives for objects
(either grouped with -Wl,--start-group, -Wl,--end-group or some new
emcc specific flag).

This is mostly moving lines around and adding some comments. The only
functional change is that if you specify the same archive multiple times
(a workaround for the lack of grouping flags), we will now only extract
it once instead of multiple times. But it will still be scanned multiple
times.
---
 tools/shared.py | 134 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 88 insertions(+), 46 deletions(-)

diff --git a/tools/shared.py b/tools/shared.py
index 826baa832caba..63367c30fdcef 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -1145,62 +1145,104 @@ def link(files, target, force_archive_contents=False):
     resolved_symbols = set()
     temp_dirs = []
     files = map(os.path.abspath, 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 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:
+        #print >> sys.stderr, '  adding object', content, '\n'
+        # 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)
+        #print >> sys.stderr, '  undef are now ', unresolved_symbols, '\n'
+        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'))
+        #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))
+          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
+      #print >> sys.stderr, '  initial undef are now ', unresolved_symbols, '\n'
+      contents = get_archive_contents(f)
+      while loop_again: # repeatedly traverse until we have everything we need
+        #print >> sys.stderr, '  running loop of archive including for', f
+        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)
+          #print >> sys.stderr, 'need', content, '?', unresolved_symbols, 'and we can supply', new_symbols.defs
+          #print >> sys.stderr, content, 'DEF', new_symbols.defs, '\n'
+          if consider_object(content, force_add=force_add_all):
+            added_contents.add(content)
+            loop_again = True
+            added_any_objects = True
+      #print >> sys.stderr, '  done running loop of archive including for', f
+      return added_any_objects
+
     for f in files:
       if 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)
+
     try_delete(target)
 
     # Finish link

From 6556a69f282ec534512c3e6a119328fe98886a97 Mon Sep 17 00:00:00 2001
From: Ryan Sturgell <ryan.sturgell@gmail.com>
Date: Tue, 8 Apr 2014 16:26:32 -0700
Subject: [PATCH 03/24] Track original flag positions in emcc.

Source files, libs, and linker flags all need to be separately
processed.  This allows them to be correctly shuffled back together for
further link processing.
---
 emcc | 97 +++++++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 63 insertions(+), 34 deletions(-)

diff --git a/emcc b/emcc
index 1629f5c74fa78..6941170fb343d 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)
@@ -1329,7 +1350,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):
@@ -1363,12 +1385,13 @@ 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))
+    logging.debug("running (for precompiled headers: " + call + ' ' + ' '.join(args))
     execute([call] + args) # let compiler frontend print directly, so colors are saved (PIPE kills that)
     sys.exit(0)
 
@@ -1386,12 +1409,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
@@ -1405,18 +1428,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)
@@ -1428,10 +1451,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)
@@ -1439,26 +1462,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)
 
@@ -1471,7 +1498,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 = []
 
@@ -1479,18 +1506,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')
 

From 2fdc694d1a1bec91578cfcdbb0d829dcc58d1957 Mon Sep 17 00:00:00 2001
From: Ryan Sturgell <ryan.sturgell@gmail.com>
Date: Thu, 1 May 2014 12:06:40 -0700
Subject: [PATCH 04/24] Add support for archive groups.

emcc now understands -Wl,--start-group, -Wl,--end-group to group static
libraries. Static libraries in a group need not be specified in
dependent to dependency order and can have circular dependencies.
---
 tests/test_other.py | 77 ++++++++++++++++++++++++++++++++++++++++++++-
 tools/shared.py     | 33 +++++++++++++++++--
 2 files changed, 106 insertions(+), 4 deletions(-)

diff --git a/tests/test_other.py b/tests/test_other.py
index 137a83b136727..966d99f4a17d6 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/shared.py b/tools/shared.py
index 63367c30fdcef..8b98ac0da887a 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -1144,14 +1144,20 @@ 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
@@ -1229,8 +1235,26 @@ def consider_archive(f):
       #print >> sys.stderr, '  done running loop of archive including for', 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
+          while loop_again:
+            loop_again = False
+            for archive in current_archive_group:
+              if consider_archive(archive):
+                loop_again = True
+          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:
             consider_object(f, force_add=True)
@@ -1242,6 +1266,9 @@ def consider_archive(f):
         # 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)
         consider_archive(f)
+        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)
 

From dc79f4645bb306bd8defd4d6d5014f9611e142dd Mon Sep 17 00:00:00 2001
From: Ophir LOJKINE <pere.jobs@gmail.com>
Date: Sun, 11 May 2014 08:41:37 +0200
Subject: [PATCH 05/24] Optimize ccall and cwrap

---
 src/preamble.js | 190 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 128 insertions(+), 62 deletions(-)

diff --git a/src/preamble.js b/src/preamble.js
index 2aec94c6a9293..1859c1342de34 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -129,7 +129,7 @@ function SAFE_HEAP_LOAD(dest, type, unsigned, ignore) {
 
 #if SAFE_HEAP_LOG
     Module.print('SAFE_HEAP load: ' + [dest, type, getValue(dest, type, 1), ignore]);
-#endif
+#endif  
 
 #if USE_TYPED_ARRAYS == 2
   // Check alignment
@@ -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) Runtime.stackRestore(stack);
+    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 litterally '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

From e25a2b096f09be2e8f37e49c17d9062b816eaa02 Mon Sep 17 00:00:00 2001
From: Ophir LOJKINE <pere.jobs@gmail.com>
Date: Sun, 11 May 2014 08:44:22 +0200
Subject: [PATCH 06/24] Remove useless spaces

---
 src/preamble.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/preamble.js b/src/preamble.js
index 1859c1342de34..c2ee63dcb4628 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -129,7 +129,7 @@ function SAFE_HEAP_LOAD(dest, type, unsigned, ignore) {
 
 #if SAFE_HEAP_LOG
     Module.print('SAFE_HEAP load: ' + [dest, type, getValue(dest, type, 1), ignore]);
-#endif  
+#endif
 
 #if USE_TYPED_ARRAYS == 2
   // Check alignment

From f0489213abd2235a7fc81ab558b5a234ceeee9e3 Mon Sep 17 00:00:00 2001
From: Ophir LOJKINE <pere.jobs@gmail.com>
Date: Sun, 11 May 2014 13:16:07 +0200
Subject: [PATCH 07/24] Fix typo: 'litterally' -> 'literally'
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In French, it's spelled 'littéralement', with 2 't' ;)
---
 src/preamble.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/preamble.js b/src/preamble.js
index c2ee63dcb4628..0e0101f220a2d 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -437,7 +437,7 @@ var cwrap, ccall;
       }
     }
 
-    // When the code is compressed, the name of cfunc is not litterally 'cfunc' anymore
+    // 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(',') + ');';

From deb10f42434a8992b67b72d0dc3bf993b5fe410f Mon Sep 17 00:00:00 2001
From: Ophir LOJKINE <pere.jobs@gmail.com>
Date: Sun, 18 May 2014 01:13:22 +0200
Subject: [PATCH 08/24] Correct indentation

---
 src/preamble.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/preamble.js b/src/preamble.js
index 0e0101f220a2d..4fa9ee064ded8 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -391,9 +391,9 @@ var cwrap, ccall;
 
   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]}
+    // 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) {

From ba00e71ac68819df214fdfc57dda71c5bb58e887 Mon Sep 17 00:00:00 2001
From: Ophir LOJKINE <pere.jobs@gmail.com>
Date: Sun, 18 May 2014 01:20:13 +0200
Subject: [PATCH 09/24] Use JSfuncs.stackrestore instead of duplicating its
 code

---
 src/preamble.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/preamble.js b/src/preamble.js
index 4fa9ee064ded8..f46119c723fb2 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -385,7 +385,7 @@ var cwrap, ccall;
     }
     var ret = func.apply(null, cArgs);
     if (returnType === 'string') ret = Pointer_stringify(ret);
-    if (stack !== 0) Runtime.stackRestore(stack);
+    if (stack !== 0) JSfuncs['stackRestore']();
     return ret;
   }
 

From a4ae7a1c29e7873f77ea4168e1c8c2c66a7cb34a Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 19 May 2014 10:45:29 -0700
Subject: [PATCH 10/24] do not move around loop variable incrementations when
 the helper is used outside the loop

---
 tools/eliminator/asm-eliminator-test-output.js | 14 ++++++++++++++
 tools/eliminator/asm-eliminator-test.js        | 17 ++++++++++++++++-
 tools/js-optimizer.js                          |  4 +++-
 3 files changed, 33 insertions(+), 2 deletions(-)

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..0cd27aa87a316 100644
--- a/tools/js-optimizer.js
+++ b/tools/js-optimizer.js
@@ -3704,9 +3704,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);

From 4ed0af723b235ae2504c65b6aaeb4b7c57fa435a Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 19 May 2014 11:14:43 -0700
Subject: [PATCH 11/24] add line bisector tool

---
 tools/bisect_pair_lines.py | 63 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 tools/bisect_pair_lines.py

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)
+

From 4de2914fe17f3b3e169329ad35022e3ee124114a Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 19 May 2014 11:51:06 -0700
Subject: [PATCH 12/24] fix emitsBoolean handling of conditional, and add
 handling of num

---
 tools/js-optimizer.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js
index 0cd27aa87a316..d89145d5a7adc 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;
   }
 

From a89d3e95a760f8ed931a762a60d3103cb526d7dc Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 19 May 2014 11:51:53 -0700
Subject: [PATCH 13/24] add conditional to hasSideEffects

---
 tools/js-optimizer.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js
index d89145d5a7adc..088c4f0f3684f 100644
--- a/tools/js-optimizer.js
+++ b/tools/js-optimizer.js
@@ -1033,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;
   }
 }

From 5338d4b9c548e4949ef4ee01cc6085a8de3bbf45 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 19 May 2014 11:52:45 -0700
Subject: [PATCH 14/24] add testcases for last few commits

---
 tools/test-js-optimizer-asm-pre-output.js | 4 ++++
 tools/test-js-optimizer-asm-pre.js        | 4 ++++
 2 files changed, 8 insertions(+)

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"]

From f1be27928f95ada02836e0b955b03997be85a70a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Mon, 19 May 2014 01:31:34 +0300
Subject: [PATCH 15/24] Implement Web Audio API playback backend to SDL Mix_*
 interface. This fixes
 https://github.com/kripken/emscripten/commit/5b41371bb5897a49e1fdcad18d053f775105c846
 when Web Audio API is available, and works around the Firefox bug
 https://bugzilla.mozilla.org/show_bug.cgi?id=654787.

---
 src/library_sdl.js    | 273 ++++++++++++++++++++++++------------------
 tests/sdl_audio_mix.c |   2 +
 2 files changed, 160 insertions(+), 115 deletions(-)

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/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;
   };
 }

From 751756ddffdbdf8061b4b73ac6848c0a1f5e61b7 Mon Sep 17 00:00:00 2001
From: Ryan Kelly <ryan@rfk.id.au>
Date: Tue, 20 May 2014 15:17:18 +1000
Subject: [PATCH 16/24] Fix elimination of conditional expressions in
 registerizeHarder.

Previously, attempts to eliminate a side-effect-free conditional
expression would corrupt internal block state, because the sub-nodes
belong to a different block than the one containing the expression.
This fixes the problem by not splitting side-effect free conditionals
across multiple blocks.
---
 tools/js-optimizer.js                         | 34 +++++++++++++------
 ...est-js-optimizer-asm-regs-harder-output.js |  5 +++
 tools/test-js-optimizer-asm-regs-harder.js    |  8 ++++-
 3 files changed, 35 insertions(+), 12 deletions(-)

diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js
index 088c4f0f3684f..2004efdac9e08 100644
--- a/tools/js-optimizer.js
+++ b/tools/js-optimizer.js
@@ -2237,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':
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"]
 

From 6ccf5ba0e4ac62d1a68ace805b08ccb5800c0e04 Mon Sep 17 00:00:00 2001
From: Ryan Sturgell <ryan.sturgell@gmail.com>
Date: Mon, 19 May 2014 23:15:17 -0700
Subject: [PATCH 17/24] Archive groups code review changes.

---
 emcc            |  2 +-
 tools/shared.py | 15 +++++++--------
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/emcc b/emcc
index 6941170fb343d..7064d7d7378f0 100755
--- a/emcc
+++ b/emcc
@@ -1391,7 +1391,7 @@ try:
     args = newargs + shared.EMSDK_CXX_OPTS + headers
     if specified_target:
       args += ['-o', specified_target]
-    logging.debug("running (for precompiled headers: " + call + ' ' + ' '.join(args))
+    logging.debug("running (for precompiled headers): " + call + ' ' + ' '.join(args))
     execute([call] + args) # let compiler frontend print directly, so colors are saved (PIPE kills that)
     sys.exit(0)
 
diff --git a/tools/shared.py b/tools/shared.py
index 8b98ac0da887a..e7107443463c5 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -1172,14 +1172,13 @@ 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:
-        #print >> sys.stderr, '  adding object', content, '\n'
+        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)
-        #print >> sys.stderr, '  undef are now ', unresolved_symbols, '\n'
         actual_files.append(f)
       return do_add
 
@@ -1194,7 +1193,6 @@ def get_archive_contents(f):
         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:
@@ -1218,21 +1216,18 @@ def get_archive_contents(f):
     def consider_archive(f):
       added_any_objects = False
       loop_again = True
-      #print >> sys.stderr, '  initial undef are now ', unresolved_symbols, '\n'
+      logging.debug('considering archive %s' % (f))
       contents = get_archive_contents(f)
       while loop_again: # repeatedly traverse until we have everything we need
-        #print >> sys.stderr, '  running loop of archive including for', f
         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)
-          #print >> sys.stderr, 'need', content, '?', unresolved_symbols, 'and we can supply', new_symbols.defs
-          #print >> sys.stderr, content, 'DEF', new_symbols.defs, '\n'
           if consider_object(content, force_add=force_add_all):
             added_contents.add(content)
             loop_again = True
             added_any_objects = True
-      #print >> sys.stderr, '  done running loop of archive including for', f
+      logging.debug('done running loop of archive %s' % (f))
       return added_any_objects
 
     current_archive_group = None
@@ -1246,11 +1241,13 @@ def consider_archive(f):
           # 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)
@@ -1266,6 +1263,8 @@ def consider_archive(f):
         # 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)
         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'

From 3a89259c2451d8a8b3d5524705f8cf2b09fc2a0c Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 20 May 2014 10:20:10 -0700
Subject: [PATCH 18/24] fix life compilation warning

---
 tests/life.c | 2 ++
 1 file changed, 2 insertions(+)

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);
     }
   }

From 1c8f88f0f870716be6ec0ce76770dc007621016f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 20 May 2014 10:21:42 -0700
Subject: [PATCH 19/24] update relooper fuzzer

---
 src/relooper/fuzzer.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/relooper/fuzzer.py b/src/relooper/fuzzer.py
index 18db997e7c7b1..156adb76d9268 100644
--- a/src/relooper/fuzzer.py
+++ b/src/relooper/fuzzer.py
@@ -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:

From 881f94c087e4417c874dc136d01c31011c24684f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 20 May 2014 10:23:11 -0700
Subject: [PATCH 20/24] do not optimize out breaks if it causes excessive
 nesting

---
 src/relooper/Relooper.cpp |   9 ++-
 src/relooper/test.cpp     |  31 ++++++++
 src/relooper/test.txt     | 153 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 189 insertions(+), 4 deletions(-)

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/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();
+ 
+

From 1d05dabfb0c12052326fbefbde4dc7e79010d257 Mon Sep 17 00:00:00 2001
From: Ophir LOJKINE <pere.jobs@gmail.com>
Date: Tue, 20 May 2014 21:13:25 +0200
Subject: [PATCH 21/24] Add @lovasoa to the AUTHORS

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index 137efb000e3cc..18a7f86777992 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -139,3 +139,4 @@ 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>

From 72dbb4c60a4ee7d786e3ffaddf94fc7a7b7d2e19 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 20 May 2014 12:57:41 -0700
Subject: [PATCH 22/24] fuzz larger testcases in relooper fuzzer

---
 src/relooper/fuzzer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/relooper/fuzzer.py b/src/relooper/fuzzer.py
index 156adb76d9268..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

From 492b230a84c5cd39585d6c06edeb2bca7709abaa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Tue, 20 May 2014 15:23:45 +0300
Subject: [PATCH 23/24] Migrate is*, to* and stro* to use musl libc.

---
 src/library.js                               | 181 -------------------
 system/lib/libc.symbols                      |  11 ++
 system/lib/libc/musl/src/compat/readme.txt   |   2 +
 system/lib/libc/musl/src/compat/strlwr.c     |  10 +
 system/lib/libc/musl/src/compat/strtol_l.c   |  22 +++
 system/lib/libc/musl/src/compat/strupr.c     |  10 +
 system/lib/libc/musl/src/ctype/isalnum.c     |   6 +
 system/lib/libc/musl/src/ctype/isalpha.c     |   7 +
 system/lib/libc/musl/src/ctype/isascii.c     |   6 +
 system/lib/libc/musl/src/ctype/isblank.c     |   6 +
 system/lib/libc/musl/src/ctype/iscntrl.c     |   6 +
 system/lib/libc/musl/src/ctype/isdigit.c     |   7 +
 system/lib/libc/musl/src/ctype/isgraph.c     |   4 +
 system/lib/libc/musl/src/ctype/islower.c     |   7 +
 system/lib/libc/musl/src/ctype/isprint.c     |   4 +
 system/lib/libc/musl/src/ctype/ispunct.c     |   6 +
 system/lib/libc/musl/src/ctype/isspace.c     |   6 +
 system/lib/libc/musl/src/ctype/isupper.c     |   7 +
 system/lib/libc/musl/src/ctype/isxdigit.c    |   6 +
 system/lib/libc/musl/src/ctype/toascii.c     |   7 +
 system/lib/libc/musl/src/ctype/tolower.c     |   7 +
 system/lib/libc/musl/src/ctype/toupper.c     |   7 +
 system/lib/libc/musl/src/locale/isalnum_l.c  |   6 +
 system/lib/libc/musl/src/locale/isalpha_l.c  |   6 +
 system/lib/libc/musl/src/locale/isblank_l.c  |   6 +
 system/lib/libc/musl/src/locale/iscntrl_l.c  |   6 +
 system/lib/libc/musl/src/locale/isdigit_l.c  |   6 +
 system/lib/libc/musl/src/locale/isgraph_l.c  |   6 +
 system/lib/libc/musl/src/locale/islower_l.c  |   6 +
 system/lib/libc/musl/src/locale/isprint_l.c  |   6 +
 system/lib/libc/musl/src/locale/ispunct_l.c  |   6 +
 system/lib/libc/musl/src/locale/isspace_l.c  |   6 +
 system/lib/libc/musl/src/locale/isupper_l.c  |   6 +
 system/lib/libc/musl/src/locale/isxdigit_l.c |   6 +
 system/lib/libc/musl/src/locale/tolower_l.c  |   6 +
 system/lib/libc/musl/src/locale/toupper_l.c  |   6 +
 system/lib/libc/musl/src/stdlib/strtol.c     |  64 +++++++
 system/lib/libcextra.symbols                 |  32 +++-
 tools/system_libs.py                         |  42 ++++-
 39 files changed, 372 insertions(+), 185 deletions(-)
 create mode 100644 system/lib/libc/musl/src/compat/readme.txt
 create mode 100644 system/lib/libc/musl/src/compat/strlwr.c
 create mode 100644 system/lib/libc/musl/src/compat/strtol_l.c
 create mode 100644 system/lib/libc/musl/src/compat/strupr.c
 create mode 100644 system/lib/libc/musl/src/ctype/isalnum.c
 create mode 100644 system/lib/libc/musl/src/ctype/isalpha.c
 create mode 100644 system/lib/libc/musl/src/ctype/isascii.c
 create mode 100644 system/lib/libc/musl/src/ctype/isblank.c
 create mode 100644 system/lib/libc/musl/src/ctype/iscntrl.c
 create mode 100644 system/lib/libc/musl/src/ctype/isdigit.c
 create mode 100644 system/lib/libc/musl/src/ctype/isgraph.c
 create mode 100644 system/lib/libc/musl/src/ctype/islower.c
 create mode 100644 system/lib/libc/musl/src/ctype/isprint.c
 create mode 100644 system/lib/libc/musl/src/ctype/ispunct.c
 create mode 100644 system/lib/libc/musl/src/ctype/isspace.c
 create mode 100644 system/lib/libc/musl/src/ctype/isupper.c
 create mode 100644 system/lib/libc/musl/src/ctype/isxdigit.c
 create mode 100644 system/lib/libc/musl/src/ctype/toascii.c
 create mode 100644 system/lib/libc/musl/src/ctype/tolower.c
 create mode 100644 system/lib/libc/musl/src/ctype/toupper.c
 create mode 100644 system/lib/libc/musl/src/locale/isalnum_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isalpha_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isblank_l.c
 create mode 100644 system/lib/libc/musl/src/locale/iscntrl_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isdigit_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isgraph_l.c
 create mode 100644 system/lib/libc/musl/src/locale/islower_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isprint_l.c
 create mode 100644 system/lib/libc/musl/src/locale/ispunct_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isspace_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isupper_l.c
 create mode 100644 system/lib/libc/musl/src/locale/isxdigit_l.c
 create mode 100644 system/lib/libc/musl/src/locale/tolower_l.c
 create mode 100644 system/lib/libc/musl/src/locale/toupper_l.c
 create mode 100644 system/lib/libc/musl/src/stdlib/strtol.c

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/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/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',

From 56ba073185622b130874d458dc5162ecfe15e06d Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 20 May 2014 16:11:18 -0700
Subject: [PATCH 24/24] 1.18.3

---
 emscripten-version.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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