23 files changed, 740 insertions, 74 deletions

diff --git a/emcc b/emcc
index 7460da61..83ce4529 100755
--- a/emcc
+++ b/emcc
@@ -61,6 +61,7 @@ BITCODE_ENDINGS = ('.bc', '.o', '.obj')
 DYNAMICLIB_ENDINGS = ('.dylib', '.so', '.dll')
 STATICLIB_ENDINGS = ('.a',)
 ASSEMBLY_ENDINGS = ('.ll',)
+HEADER_ENDINGS = ('.h', '.hxx', '.hpp', '.hh', '.H', '.HXX', '.HPP', '.HH')
 
 LIB_PREFIXES = ('', 'lib')
 
@@ -159,7 +160,8 @@ Options that are modified or new in %s include:
                            output.
 
   -O3                      As -O2, plus additional optimizations that can
-                           take a significant amount of compilation time.
+                           take a significant amount of compilation time and/or
+                           are relatively new.
 
                            For tips on optimizing your code, see
                            https://github.com/kripken/emscripten/wiki/Optimizing-Code
@@ -484,10 +486,13 @@ Options that are modified or new in %s include:
                            libraries, and after any link-time optimizations
                            (if any).
 
-  --memory-init-file <on>  If on, we generate a separate memory initialization
-                           file. This is more efficient than storing the
-                           memory initialization data embedded inside
-                           JavaScript as text. (default is off)
+  --memory-init-file <on>  0: Do not emit a separate memory initialization
+                              file, keep the static initialization inside
+                              the generated JavaScript as text (default)
+                           1: Emit a separate memory initialization file
+                              in binary format. This is more efficient than
+                              storing it as text inside JavaScript, but does
+                              mean you have another file to publish.
 
   -Wno-warn-absolute-paths If not specified, the compiler will warn about any
                            uses of absolute paths in -I and -L command line
@@ -695,15 +700,12 @@ if len(sys.argv) == 1 or sys.argv[1] in ['x', 't']:
   sys.exit(0)
 
 use_cxx = True
-header = False # pre-compiled headers. We fake that by just copying the file
 
 for i in range(1, len(sys.argv)):
   arg = sys.argv[i]
   if not arg.startswith('-'):
     if arg.endswith(('.c','.m')):
       use_cxx = False
-    if arg.endswith('.h') and sys.argv[i-1] != '-include':
-      header = True
 
 if '-M' in sys.argv or '-MM' in sys.argv:
   # Just output dependencies, do not compile. Warning: clang and gcc behave differently with -MF! (clang seems to not recognize it)
@@ -737,15 +739,6 @@ if '.' in target:
 else:
   final_suffix = ''
 
-if header: # header or such
-  if len(sys.argv) >= 3: # if there is a source and a target, then copy, otherwise do nothing
-    sys.argv = filter(lambda arg: not arg.startswith('-I'), sys.argv)
-    logging.debug('Just copy:' + sys.argv[-1] + target)
-    shutil.copy(sys.argv[-1], target)
-  else:
-    logging.debug('No-op.')
-  exit(0)
-
 if TEMP_DIR:
   temp_dir = TEMP_DIR
   if os.path.exists(temp_dir):
@@ -1062,6 +1055,7 @@ try:
 
   input_files = []
   has_source_inputs = False
+  has_header_inputs = False
   lib_dirs = [shared.path_from_root('system', 'local', 'lib'),
               shared.path_from_root('system', 'lib')]
   libs = []
@@ -1073,7 +1067,7 @@ try:
       prev = newargs[i-1]
       if prev in ['-MT', '-MF', '-MQ', '-D', '-U', '-o', '-x', '-Xpreprocessor', '-include', '-imacros', '-idirafter', '-iprefix', '-iwithprefix', '-iwithprefixbefore', '-isysroot', '-imultilib', '-A', '-isystem', '-iquote', '-install_name', '-compatibility_version', '-current_version', '-I', '-L']: continue # ignore this gcc-style argument
 
-    if (os.path.islink(arg) and os.path.realpath(arg).endswith(SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS)):
+    if (os.path.islink(arg) and os.path.realpath(arg).endswith(SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS + HEADER_ENDINGS)):
       arg = os.path.realpath(arg)
 
     if not arg.startswith('-'):
@@ -1082,11 +1076,14 @@ try:
         exit(1)
 
       arg_ending = filename_type_ending(arg)
-      if arg_ending.endswith(SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS) or shared.Building.is_ar(arg): # we already removed -o <target>, so all these should be inputs
+      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)
           has_source_inputs = True
+        elif arg_ending.endswith(HEADER_ENDINGS):
+          input_files.append(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)
         elif arg_ending.endswith(STATICLIB_ENDINGS + DYNAMICLIB_ENDINGS):
@@ -1125,7 +1122,7 @@ try:
   # -c means do not link in gcc, and for us, the parallel is to not go all the way to JS, but stop at bitcode
   has_dash_c = '-c' in newargs
   if has_dash_c:
-    assert has_source_inputs, 'Must have source code inputs to use -c'
+    assert has_source_inputs or has_header_inputs, 'Must have source code or header inputs to use -c'
     target = target_basename + '.o'
     final_suffix = 'o'
 
@@ -1159,7 +1156,7 @@ try:
     input_files = filter(lambda input_file: check(input_file), input_files)
 
   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))
+    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))
     exit(0)
 
   newargs = CC_ADDITIONAL_ARGS + newargs
@@ -1226,7 +1223,8 @@ try:
     assert not shared.Settings.PGO, 'cannot run PGO in ASM_JS mode'
 
     if shared.Settings.SAFE_HEAP and not js_opts:
-      logging.warning('asm.js+SAFE_HEAP requires js opts to be run (-O1 or above by default)')
+      js_opts = True
+      logging.warning('enabling js opts to allow SAFE_HEAP to work properly')
 
     if shared.Settings.ALLOW_MEMORY_GROWTH:
       logging.error('Cannot enable ALLOW_MEMORY_GROWTH with asm.js, build with -s ASM_JS=0 if you need a growable heap');
@@ -1299,6 +1297,15 @@ try:
 
   log_time('parse arguments and setup')
 
+  # 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
+    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(1)
+
   # First, generate LLVM bitcode. For each input file, we get base.o with bitcode
   for input_file in input_files:
     file_ending = filename_type_ending(input_file)
@@ -1992,12 +1999,12 @@ try:
       else:
         return 'eliminate'
 
-    js_optimizer_queue += [get_eliminate()]
+    if opt_level >= 2:
+      js_optimizer_queue += [get_eliminate()]
 
-    if shared.Settings.AGGRESSIVE_VARIABLE_ELIMINATION:
-      js_optimizer_queue += ['aggressiveVariableElimination']
+      if shared.Settings.AGGRESSIVE_VARIABLE_ELIMINATION:
+        js_optimizer_queue += ['aggressiveVariableElimination']
 
-    if opt_level >= 2:
       js_optimizer_queue += ['simplifyExpressions']
 
   if closure and not shared.Settings.ASM_JS:
@@ -2016,13 +2023,13 @@ try:
       js_optimizer_queue += ['outline']
       js_optimizer_extra_info['sizeToOutline'] = shared.Settings.OUTLINING_LIMIT
 
-    if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and debug_level < 3:
+    if opt_level >= 2 and (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and debug_level < 3:
       if shared.Settings.ASM_JS and opt_level >= 3 and shared.Settings.OUTLINING_LIMIT == 0:
         js_optimizer_queue += ['registerizeHarder']
       else:
         js_optimizer_queue += ['registerize']
 
-    if opt_level > 0:
+    if opt_level >= 2:
       if debug_level < 2 and shared.Settings.ASM_JS: js_optimizer_queue += ['minifyNames']
       if debug_level == 0: js_optimizer_queue += ['minifyWhitespace']
 
diff --git a/emscripten.py b/emscripten.py
index 725f573f..ce929858 100755
--- a/emscripten.py
+++ b/emscripten.py
@@ -1204,7 +1204,7 @@ Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
 
   if DEBUG: logging.debug('  emscript: final python processing took %s seconds' % (time.time() - t))
 
-if os.environ.get('EMCC_FAST_COMPILER'):
+if os.environ.get('EMCC_FAST_COMPILER') == '1':
   emscript = emscript_fast
 
 def main(args, compiler_engine, cache, jcache, relooper, temp_files, DEBUG, DEBUG_CACHE):
diff --git a/src/library.js b/src/library.js
index fc2e8a64..4c0f790f 100644
--- a/src/library.js
+++ b/src/library.js
@@ -162,7 +162,7 @@ LibraryManager.library = {
     if (times) {
       // NOTE: We don't keep track of access timestamps.
       var offset = {{{ C_STRUCTS.utimbuf.modtime }}};
-      time = {{{ makeGetValue('times', 'offset', 'i32') }}}
+      time = {{{ makeGetValue('times', 'offset', 'i32') }}};
       time *= 1000;
     } else {
       time = Date.now();
@@ -1182,7 +1182,7 @@ LibraryManager.library = {
       for (var i = 0; i < length; i++) {
         {{{ makeSetValue('buf', 'i', 'value.charCodeAt(i)', 'i8') }}};
       }
-      if (len > length) {{{ makeSetValue('buf', 'i++', '0', 'i8') }}}
+      if (len > length) {{{ makeSetValue('buf', 'i++', '0', 'i8') }}};
       return i;
     }
   },
@@ -3229,22 +3229,34 @@ LibraryManager.library = {
   strtoll: function(str, endptr, base) {
     return __parseInt64(str, endptr, base, '-9223372036854775808', '9223372036854775807');  // LLONG_MIN, LLONG_MAX.
   },
-  strtoll_l: 'strtoll', // no locale support yet
+  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: 'strtol', // no locale support yet
+  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: 'strtoul', // no locale support yet
+  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: 'strtoull', // no locale support yet
+  strtoull_l__deps: ['strtoull'],
+  strtoull_l: function(str, endptr, base) {
+    return _strtoull(str, endptr, base); // no locale support yet
+  },
 
   atoi__deps: ['strtol'],
   atoi: function(ptr) {
@@ -3735,7 +3747,10 @@ LibraryManager.library = {
   },
   // We always assume ASCII locale.
   strcoll: 'strcmp',
-  strcoll_l: 'strcmp',
+  strcoll_l__deps: ['strcoll'],
+  strcoll_l: function(px, py) {
+    return _strcoll(px, py); // no locale support yet
+  },
 
   strcasecmp__asm: true,
   strcasecmp__sig: 'iii',
@@ -4000,7 +4015,10 @@ LibraryManager.library = {
     }
   },
   _toupper: 'toupper',
-  toupper_l: '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',
@@ -4011,65 +4029,104 @@ LibraryManager.library = {
     return (chr - {{{ charCode('A') }}} + {{{ charCode('a') }}})|0;
   },
   _tolower: 'tolower',
-  tolower_l: '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: 'islower',
+  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: 'isupper',
+  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: 'isalpha',
+  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: 'isdigit',
+  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: 'isxdigit',
+  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: 'isalnum',
+  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: 'ispunct',
+  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: 'isspace',
+  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: 'isblank',
+  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: 'iscntrl',
+  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: 'isprint',
+  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: 'isgraph',
+  isgraph_l__deps: ['isgraph'],
+  isgraph_l: function(chr) {
+    return _isgraph(chr); // no locale support yet
+  },
   // Lookup tables for glibc ctype implementation.
   __ctype_b_loc: function() {
     // http://refspecs.freestandards.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/baselib---ctype-b-loc.html
@@ -4365,8 +4422,8 @@ LibraryManager.library = {
     Module.printErr('Compiled code throwing an exception, ' + [ptr,type,destructor] + ', at ' + stackTrace());
 #endif
     var header = ptr - ___cxa_exception_header_size;
-    {{{ makeSetValue('header', 0, 'type', 'void*') }}}
-    {{{ makeSetValue('header', 4, 'destructor', 'void*') }}}
+    {{{ makeSetValue('header', 0, 'type', 'void*') }}};
+    {{{ makeSetValue('header', 4, 'destructor', 'void*') }}};
     ___cxa_last_thrown_exception = ptr;
     if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
       __ZSt18uncaught_exceptionv.uncaught_exception = 1;
@@ -4434,7 +4491,7 @@ LibraryManager.library = {
       var destructor = {{{ makeGetValue('header', 4, 'void*') }}};
       if (destructor) {
         Runtime.dynCall('vi', destructor, [ptr]);
-        {{{ makeSetValue('header', 4, '0', 'i32') }}}
+        {{{ makeSetValue('header', 4, '0', 'i32') }}};
       }
       ___cxa_free_exception(ptr);
       ___cxa_last_thrown_exception = 0;
@@ -5887,7 +5944,10 @@ LibraryManager.library = {
     writeArrayToMemory(bytes, s);
     return bytes.length-1;
   },
-  strftime_l: 'strftime', // no locale support yet
+  strftime_l__deps: ['strftime'],
+  strftime_l: function(s, maxsize, format, tm) {
+    return _strftime(s, maxsize, format, tm); // no locale support yet
+  },
 
   strptime__deps: ['_isLeapYear', '_arraySum', '_addDays', '_MONTH_DAYS_REGULAR', '_MONTH_DAYS_LEAP'],
   strptime: function(buf, format, tm) {
@@ -6129,7 +6189,10 @@ LibraryManager.library = {
 
     return 0;
   },
-  strptime_l: 'strptime', // no locale support yet
+  strptime_l__deps: ['strptime'],
+  strptime_l: function(buf, format, tm) {
+    return _strptime(buf, format, tm); // no locale support yet
+  },
 
   getdate: function(string) {
     // struct tm *getdate(const char *string);
@@ -7630,7 +7693,7 @@ LibraryManager.library = {
     node = DNS.lookup_name(node);
     addr = __inet_pton4_raw(node);
     if (family === {{{ cDefine('AF_UNSPEC') }}}) {
-      family = {{{ cDefine('AF_INET') }}}
+      family = {{{ cDefine('AF_INET') }}};
     } else if (family === {{{ cDefine('AF_INET6') }}}) {
       addr = [0, 0, _htonl(0xffff), addr];
     }
diff --git a/src/library_openal.js b/src/library_openal.js
index 67481824..ac49fe95 100644
--- a/src/library_openal.js
+++ b/src/library_openal.js
@@ -5,6 +5,10 @@ var LibraryOpenAL = {
   $AL: {
     contexts: [],
     currentContext: null,
+
+    stringCache: {},
+    alcStringCache: {},
+
     QUEUE_INTERVAL: 25,
     QUEUE_LOOKAHEAD: 100,
 
@@ -235,6 +239,42 @@ var LibraryOpenAL = {
     return _alGetError();
   },
 
+  alcGetIntegerv: function(device, param, size, data) {
+    if (size == 0 || !data) {
+      AL.currentContext.err = 0xA003 /* AL_INVALID_VALUE */;
+      return;
+    }
+
+    switch(param) {
+    case 0x1000 /* ALC_MAJOR_VERSION */:
+      {{{ makeSetValue('data', '0', '1', 'i32') }}};
+      break;
+    case 0x1001 /* ALC_MINOR_VERSION */:
+      {{{ makeSetValue('data', '0', '1', 'i32') }}};
+      break;
+    case 0x1002 /* ALC_ATTRIBUTES_SIZE */:
+      if (!device) {
+        AL.currentContext.err = 0xA001 /* ALC_INVALID_DEVICE */;
+        return 0;
+      }
+      {{{ makeSetValue('data', '0', '1', 'i32') }}};
+      break;
+    case 0x1003 /* ALC_ALL_ATTRIBUTES */:
+      if (!device) {
+        AL.currentContext.err = 0xA001 /* ALC_INVALID_DEVICE */;
+        return 0;
+      }
+      {{{ makeSetValue('data', '0', '0', 'i32') }}};
+      break;
+    default:
+#if OPENAL_DEBUG
+      console.log("alcGetIntegerv with param " + param + " not implemented yet");
+#endif
+      AL.currentContext.err = 0xA003 /* ALC_INVALID_ENUM */;
+      break;
+    }
+  },
+
   alDeleteSources: function(count, sources) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
@@ -334,6 +374,18 @@ var LibraryOpenAL = {
     }
   },
 
+  alIsSource: function(sourceId) {
+    if (!AL.currentContext) {
+      return false;
+    }
+
+    if (!AL.currentContext.src[sourceId - 1]) {
+      return false;
+    } else {
+      return true;
+    }
+  },
+
   alSourcei__deps: ['updateSource'],
   alSourcei: function(source, param, value) {
     if (!AL.currentContext) {
@@ -691,6 +743,7 @@ var LibraryOpenAL = {
     }
     try {
       AL.currentContext.buf[buffer - 1] = AL.currentContext.ctx.createBuffer(channels, size / (bytes * channels), freq);
+      AL.currentContext.buf[buffer - 1].bytesPerSample =  bytes;
     } catch (e) {
       AL.currentContext.err = 0xA003 /* AL_INVALID_VALUE */;
       return;
@@ -715,6 +768,41 @@ var LibraryOpenAL = {
     }
   },
 
+  alGetBufferi: function(buffer, param, value)
+  {
+    if (!AL.currentContext) {
+#if OPENAL_DEBUG
+      console.error("alGetBufferi called without a valid context");
+#endif
+      return;
+    }
+    var buf = AL.currentContext.buf[buffer - 1];
+    if (!buf) {
+#if OPENAL_DEBUG
+      console.error("alGetBufferi called with an invalid buffer");
+#endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
+      return;
+    }
+    switch (param) {
+    case 0x2001 /* AL_FREQUENCY */:
+      {{{ makeSetValue('value', '0', 'buf.sampleRate', 'i32') }}};
+      break;
+    case 0x2002 /* AL_BITS */:
+      {{{ makeSetValue('value', '0', 'buf.bytesPerSample * 8', 'i32') }}};
+      break;
+    case 0x2003 /* AL_CHANNELS */:
+      {{{ makeSetValue('value', '0', 'buf.numberOfChannels', 'i32') }}};
+      break;
+    case 0x2004 /* AL_SIZE */:
+      {{{ makeSetValue('value', '0', 'buf.length * buf.bytesPerSample * buf.numberOfChannels', 'i32') }}};
+      break;
+    default:
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
+      break;
+    }
+  },
+
   alSourcePlay__deps: ['setSourceState'],
   alSourcePlay: function(source) {
     if (!AL.currentContext) {
@@ -1128,15 +1216,116 @@ var LibraryOpenAL = {
   },
 
   alGetString: function(param) {
-    return allocate(intArrayFromString('NA'), 'i8', ALLOC_NORMAL);
+    if (AL.stringCache[param]) return AL.stringCache[param];
+    var ret;
+    switch (param) {
+    case 0 /* AL_NO_ERROR */:
+      ret = 'No Error';
+      break;
+    case 0xA001 /* AL_INVALID_NAME */:
+      ret = 'Invalid Name';
+      break;
+    case 0xA002 /* AL_INVALID_ENUM */:
+      ret = 'Invalid Enum';
+      break;
+    case 0xA003 /* AL_INVALID_VALUE */:
+      ret = 'Invalid Value';
+      break;
+    case 0xA004 /* AL_INVALID_OPERATION */:
+      ret = 'Invalid Operation';
+      break;
+    case 0xA005 /* AL_OUT_OF_MEMORY */:
+      ret = 'Out of Memory';
+      break;
+    case 0xB001 /* AL_VENDOR */:
+      ret = 'Emscripten';
+      break;
+    case 0xB002 /* AL_VERSION */:
+      ret = '1.1';
+      break;
+    case 0xB003 /* AL_RENDERER */:
+      ret = 'WebAudio';
+      break;
+    case 0xB004 /* AL_EXTENSIONS */:
+      ret = '';
+      break;
+    default:
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
+      return 0;
+    }
+
+    ret = allocate(intArrayFromString(ret), 'i8', ALLOC_NORMAL);
+
+    AL.stringCache[param] = ret;
+
+    return ret;
   },
 
   alGetProcAddress: function(fname) {
     return 0;
   },
 
-  alcGetString: function(param) {
-    return allocate(intArrayFromString('NA'), 'i8', ALLOC_NORMAL);
+  alcGetString: function(device, param) {
+    if (AL.alcStringCache[param]) return AL.alcStringCache[param];
+    var ret;
+    switch (param) {
+    case 0 /* ALC_NO_ERROR */:
+      ret = 'No Error';
+      break;
+    case 0xA001 /* ALC_INVALID_DEVICE */:
+      ret = 'Invalid Device';
+      break;
+    case 0xA002 /* ALC_INVALID_CONTEXT */:
+      ret = 'Invalid Context';
+      break;
+    case 0xA003 /* ALC_INVALID_ENUM */:
+      ret = 'Invalid Enum';
+      break;
+    case 0xA004 /* ALC_INVALID_VALUE */:
+      ret = 'Invalid Value';
+      break;
+    case 0xA005 /* ALC_OUT_OF_MEMORY */:
+      ret = 'Out of Memory';
+      break;
+    case 0x1004 /* ALC_DEFAULT_DEVICE_SPECIFIER */:
+      if (typeof(AudioContext) == "function" ||
+          typeof(webkitAudioContext) == "function") {
+        ret = 'Device';
+      } else {
+        return 0;
+      }
+      break;
+    case 0x1005 /* ALC_DEVICE_SPECIFIER */:
+      if (typeof(AudioContext) == "function" ||
+          typeof(webkitAudioContext) == "function") {
+        ret = 'Device\0';
+      } else {
+        ret = '\0';
+      }
+      break;
+    case 0x311 /* ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER */:
+      return 0;
+      break;
+    case 0x310 /* ALC_CAPTURE_DEVICE_SPECIFIER */:
+      ret = '\0'
+      break;
+    case 0x1006 /* ALC_EXTENSIONS */:
+      if (!device) {
+        AL.currentContext.err = 0xA001 /* ALC_INVALID_DEVICE */;
+        return 0;
+      }
+      ret = '';
+      break;
+    default:
+      AL.currentContext.err = 0xA003 /* ALC_INVALID_ENUM */;
+      return 0;
+    }
+
+    ret = allocate(intArrayFromString(ret), 'i8', ALLOC_NORMAL);
+
+    AL.alcStringCache[param] = ret;
+
+    return ret;
   },
 
   alcGetProcAddress: function(device, fname) {
diff --git a/src/parseTools.js b/src/parseTools.js
index e09cd2e2..bad080b7 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -1332,7 +1332,7 @@ function makeGetValue(ptr, pos, type, noNeedFirst, unsigned, ignore, align, noSa
     if (printType !== 'null' && printType[0] !== '#') printType = '"' + safeQuote(printType) + '"';
     if (printType[0] === '#') printType = printType.substr(1);
     if (ASM_JS) {
-      if (!ignore) return asmCoercion('SAFE_HEAP_LOAD(' + asmCoercion(offset, 'i32') + ', ' + Runtime.getNativeTypeSize(type) + ', ' + ((type in Runtime.FLOAT_TYPES)|0) + ', ' + (!!unsigned+0) + ')', type);
+      if (!ignore && phase !== 'funcs') return asmCoercion('SAFE_HEAP_LOAD(' + asmCoercion(offset, 'i32') + ', ' + Runtime.getNativeTypeSize(type) + ', ' + ((type in Runtime.FLOAT_TYPES)|0) + ', ' + (!!unsigned+0) + ')', type);
       // else fall through
     } else {
       return asmCoercion('SAFE_HEAP_LOAD(' + offset + ', ' + (ASM_JS ? 0 : printType) + ', ' + (!!unsigned+0) + ', ' + ((!checkSafeHeap() || ignore)|0) + ')', type);
@@ -1444,7 +1444,7 @@ function makeSetValue(ptr, pos, value, type, noNeedFirst, ignore, align, noSafe,
     if (printType !== 'null' && printType[0] !== '#') printType = '"' + safeQuote(printType) + '"';
     if (printType[0] === '#') printType = printType.substr(1);
     if (ASM_JS) {
-      if (!ignore) return asmCoercion('SAFE_HEAP_STORE(' + asmCoercion(offset, 'i32') + ', ' + asmCoercion(value, type) + ', ' + Runtime.getNativeTypeSize(type) + ', ' + ((type in Runtime.FLOAT_TYPES)|0) + ')', type);
+      if (!ignore && phase !== 'funcs') return asmCoercion('SAFE_HEAP_STORE(' + asmCoercion(offset, 'i32') + ', ' + asmCoercion(value, type) + ', ' + Runtime.getNativeTypeSize(type) + ', ' + ((type in Runtime.FLOAT_TYPES)|0) + ')', type);
       // else fall through
     } else {
       return 'SAFE_HEAP_STORE(' + offset + ', ' + value + ', ' + (ASM_JS ? 0 : printType) + ', ' + ((!checkSafeHeap() || ignore)|0) + ')';
diff --git a/src/runtime.js b/src/runtime.js
index 4fcca56b..a9265e70 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -565,7 +565,7 @@ function getRuntime() {
 
 // Converts a value we have as signed, into an unsigned value. For
 // example, -1 in int32 would be a very large number as unsigned.
-function unSign(value, bits, ignore, sig) {
+function unSign(value, bits, ignore) {
   if (value >= 0) {
     return value;
   }
@@ -578,7 +578,7 @@ function unSign(value, bits, ignore, sig) {
 
 // Converts a value we have as unsigned, into a signed value. For
 // example, 200 in a uint8 would be a negative number.
-function reSign(value, bits, ignore, sig) {
+function reSign(value, bits, ignore) {
   if (value <= 0) {
     return value;
   }
diff --git a/system/include/emscripten/emscripten.h b/system/include/emscripten/emscripten.h
index fb456d67..2fc82f50 100644
--- a/system/include/emscripten/emscripten.h
+++ b/system/include/emscripten/emscripten.h
@@ -50,10 +50,14 @@ extern "C" {
  *      return $0 + $1;
  *    }, calc(), otherCalc());
  *
- * Note the {,}
+ * Note the { and }. If you just want to receive an output value
+ * (int or double) but *not* to pass any values, you can use
+ * EM_ASM_INT_V and EM_ASM_DOUBLE_V respectively.
  */
 #define EM_ASM_INT(code, ...) emscripten_asm_const_int(#code, __VA_ARGS__)
 #define EM_ASM_DOUBLE(code, ...) emscripten_asm_const_double(#code, __VA_ARGS__)
+#define EM_ASM_INT_V(code) emscripten_asm_const_int(#code)
+#define EM_ASM_DOUBLE_V(code) emscripten_asm_const_double(#code)
 
 /*
  * Forces LLVM to not dead-code-eliminate a function. Note that
diff --git a/tests/cases/i96shiftnon32_ta2.ll b/tests/cases/i96shiftnon32_ta2.ll
new file mode 100644
index 00000000..55e84575
--- /dev/null
+++ b/tests/cases/i96shiftnon32_ta2.ll
@@ -0,0 +1,44 @@
+; ModuleID = '/tmp/tmpxFUbAg/test_emcc1.bc'
+target datalayout = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-p:32:32:32-v128:32:32"
+target triple = "le32-unknown-nacl"
+
+%struct.c_s = type { i8, float, i32 }
+
+@.str = private unnamed_addr constant [12 x i8] c"RESULT: %d\0A\00", align 1
+
+define internal fastcc void @f2(%struct.c_s* noalias nocapture sret %agg.result) nounwind {
+  %agg.result.1 = getelementptr inbounds %struct.c_s* %agg.result, i32 0, i32 1
+  store float 0.000000e+00, float* %agg.result.1, align 4
+  %agg.result.2 = getelementptr inbounds %struct.c_s* %agg.result, i32 0, i32 2
+  store i32 43110, i32* %agg.result.2, align 4
+  ret void
+}
+
+define internal fastcc void @f1(%struct.c_s* nocapture %tp) nounwind {
+  %1 = alloca %struct.c_s, align 8
+  call fastcc void @f2(%struct.c_s* sret %1)
+  %2 = bitcast %struct.c_s* %1 to i96*
+  %srcval1 = load i96* %2, align 8
+  %small = trunc i96 %srcval1 to i64
+  %large = zext i64 %small to i96
+  %return = or i96 %srcval1, %large
+  %3 = lshr i96 %return, 4
+  %4 = shl i96 %3, 2
+  %5 = bitcast %struct.c_s