27 files changed, 1313 insertions, 354 deletions
diff --git a/AUTHORS b/AUTHORS
index 74efb628..c157c468 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -48,6 +48,5 @@ a license to everyone to use it as detailed in LICENSE.)
 * Jasper St. Pierre <jstpierre@mecheye.net>
 * Manuel Sch�lling <manuel.schoelling@gmx.de>
 * Bruce Mitchener, Jr. <bruce.mitchener@gmail.com>
-
-
-
+* Michael Bishop <mbtyke@gmail.com>
+* Roger Braun <roger@rogerbraun.net>
diff --git a/emcc b/emcc
index ffce7363..d28df40f 100755
--- a/emcc
+++ b/emcc
@@ -119,11 +119,20 @@ if len(sys.argv) == 1:
   exit(1)
 
 if sys.argv[1] == '--version':
-  print '''emcc (Emscripten GCC-like replacement) 2.0
-Copyright (C) 2012 the Emscripten authors.
+  revision = '(unknown revision)'
+  here = os.getcwd()
+  os.chdir(shared.path_from_root())
+  try:
+    revision = execute(['git', 'show'], stdout=PIPE, stderr=PIPE)[0].split('\n')[0]
+  except:
+    pass
+  finally:
+    os.chdir(here)
+  print '''emcc (Emscripten GCC-like replacement) %s (%s)
+Copyright (C) 2013 the Emscripten authors (see AUTHORS.txt)
 This is free and open source software under the MIT license.
 There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  '''
+  ''' % (shared.EMSCRIPTEN_VERSION, revision)
   exit(0)
 elif sys.argv[1] == '--help':
   this = os.path.basename('em++' if os.environ.get('EMMAKEN_CXX') else 'emcc')
@@ -148,14 +157,19 @@ Options that are modified or new in %s include:
                            compiling to JavaScript, not to intermediate
                            bitcode.
   -O2                      As -O1, plus the relooper (loop recreation),
-                           plus closure compiler advanced opts, plus
-                           LLVM -O2 optimizations
-                           Warning: Compiling with this takes a long time!
+                           plus LLVM -O2 optimizations
   -O3                      As -O2, plus dangerous optimizations that may
-                           break the generated code! This is not
-                           recommended at all, see the wiki for more
-                           details (you can try -O2 and then add
-                           dangerous optimizations one by one).
+                           break the generated code! This adds
+
+                              -s INLINING_LIMIT=0
+                              -s DOUBLE_MODE=0
+                              -s PRECISE_I64_MATH=0
+                              --closure 1
+
+                           This is not recommended at all. A better idea
+                           is to try each of these separately on top of
+                           -O2 to see what works. See the wiki for more
+                           information.
 
   -s OPTION=VALUE          JavaScript code generation option passed
                            into the emscripten compiler. For the
@@ -177,6 +191,12 @@ Options that are modified or new in %s include:
                            the last compilation phase from bitcode to
                            JavaScript, or else we will remove it by
                            default in -O1 and above.
+                           In -O0, line numbers wil be shown in the
+                           generated code. In -O1 and above, the optimizer
+                           removes those comments. This flag does however
+                           have the effect of disabling anything that
+                           causes name mangling or minification (closure
+                           or the registerize pass).
 
   --typed-arrays <mode>    0: No typed arrays
                            1: Parallel typed arrays
@@ -193,8 +213,17 @@ Options that are modified or new in %s include:
                            (see --llvm-opts), setting this to 1 has no
                            effect.
 
-  --closure <on>           0: No closure compiler (default in -O0, -O1)
-                           1: Run closure compiler (default in -O2, -O3)
+  --closure <on>           0: No closure compiler (default in -O2 and below)
+                           1: Run closure compiler. This greatly reduces
+                           code size and may in some cases increase
+                           runtime speed (although the opposite can also
+                           occur). Note that it takes time to run, and
+                           may require some changes to the code. This
+                           is run by default in -O3.
+
+                           Note: If closure compiler hits an out-of-memory,
+                           try adjusting JAVA_HEAP_SIZE in the environment
+                           (for example, to 4096m for 4GB).
 
   --js-transform <cmd>     <cmd> will be called on the generated code
                            before it is optimized. This lets you modify
@@ -600,7 +629,8 @@ try:
   ignore_dynamic_linking = False
   shell_path = shared.path_from_root('src', 'shell.html')
   js_libraries = []
-  keep_debug = False
+  keep_llvm_debug = False
+  keep_js_debug = False
   bind = False
   jcache = False
   if use_cxx:
@@ -667,7 +697,8 @@ try:
       newargs[i] = ''
       newargs[i+1] = ''
     elif newargs[i] == '-g':
-      keep_debug = True
+      keep_llvm_debug = True
+      keep_js_debug = True
     elif newargs[i] == '--bind':
       bind = True
       newargs[i] = ''
@@ -738,8 +769,9 @@ try:
 
   if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level]
   if llvm_lto is None: llvm_lto = llvm_opts > 0
-  if closure is None: closure = 1 if opt_level >= 2 else 0
-  if opt_level <= 0: keep_debug = True # always keep debug in -O0
+  if opt_level <= 0: keep_llvm_debug = keep_js_debug = True # always keep debug in -O0
+  if opt_level > 0: keep_llvm_debug = False # JS optimizer wipes out llvm debug info from being visible
+  if closure is None and opt_level == 3: closure = True
 
   if DEBUG: start_time = time.time() # done after parsing arguments, which might affect debug state
 
@@ -879,7 +911,11 @@ try:
       shared.Settings.CORRECT_OVERFLOWS = 1
 
   if shared.Settings.CORRECT_SIGNS >= 2 or shared.Settings.CORRECT_OVERFLOWS >= 2 or shared.Settings.CORRECT_ROUNDINGS >= 2:
-    keep_debug = True # must keep debug info to do line-by-line operations 
+    keep_llvm_debug = True # must keep debug info to do line-by-line operations 
+
+  if (keep_llvm_debug or keep_js_debug) and closure:
+    print >> sys.stderr, 'emcc: warning: disabling closure because debug info was requested'
+    closure = False
 
   if minify_whitespace is None:
     minify_whitespace = closure # if closure is run, minify whitespace
@@ -984,7 +1020,7 @@ try:
     def create_libcxx():
       if DEBUG: print >> sys.stderr, 'emcc: building libcxx for cache'
       os = []
-      for src in ['algorithm.cpp', 'condition_variable.cpp', 'future.cpp', 'iostream.cpp', 'memory.cpp', 'random.cpp', 'stdexcept.cpp', 'system_error.cpp', 'utility.cpp', 'bind.cpp', 'debug.cpp', 'hash.cpp', 'mutex.cpp', 'string.cpp', 'thread.cpp', 'valarray.cpp', 'chrono.cpp', 'exception.cpp', 'ios.cpp', 'locale.cpp', 'regex.cpp', 'strstream.cpp', 'typeinfo.cpp']:
+      for src in ['algorithm.cpp', 'condition_variable.cpp', 'future.cpp', 'iostream.cpp', 'memory.cpp', 'random.cpp', 'stdexcept.cpp', 'system_error.cpp', 'utility.cpp', 'bind.cpp', 'debug.cpp', 'hash.cpp', 'mutex.cpp', 'string.cpp', 'thread.cpp', 'valarray.cpp', 'chrono.cpp', 'exception.cpp', 'ios.cpp', 'locale.cpp', 'regex.cpp', 'strstream.cpp']:
         o = in_temp(src + '.o')
         execute([shared.PYTHON, shared.EMXX, shared.path_from_root('system', 'lib', 'libcxx', src), '-o', o], stdout=stdout, stderr=stderr)
         os.append(o)
@@ -1003,7 +1039,7 @@ try:
     def create_libcxxabi():
       if DEBUG: print >> sys.stderr, 'emcc: building libcxxabi for cache'
       os = []
-      for src in ['private_typeinfo.cpp']:
+      for src in ['private_typeinfo.cpp', 'typeinfo.cpp']:
         o = in_temp(src + '.o')
         execute([shared.PYTHON, shared.EMXX, shared.path_from_root('system', 'lib', 'libcxxabi', 'src', src), '-o', o], stdout=stdout, stderr=stderr)
         os.append(o)
@@ -1084,7 +1120,7 @@ try:
 
   # Optimize, if asked to
   if not LEAVE_INPUTS_RAW:
-    link_opts = [] if keep_debug else ['-strip-debug']
+    link_opts = [] if keep_llvm_debug else ['-strip-debug'] # remove LLVM debug info in -O1+, since the optimizer removes it anyhow
     if llvm_opts > 0:
       shared.Building.llvm_opt(in_temp(target_basename + '.bc'), llvm_opts)
       if DEBUG: save_intermediate('opt', 'bc')
@@ -1216,8 +1252,9 @@ try:
     if DEBUG: print >> sys.stderr, 'emcc: running closure'
     final = shared.Building.closure_compiler(final)
     if DEBUG: save_intermediate('closure')
-  elif shared.Settings.ASM_JS and shared.Settings.RELOOP:
-    js_optimizer_queue += ['registerize'] # we can't use closure in asm, but this does much of the same
+  elif shared.Settings.RELOOP and not closure and not keep_js_debug:
+    # do this if closure is not enabled (it gives similar speedups), and we do not need to keep debug info around
+    js_optimizer_queue += ['registerize']
 
   if opt_level >= 1:
     if DEBUG: print >> sys.stderr, 'emcc: running post-closure post-opts'
diff --git a/src/compiler.js b/src/compiler.js
index 25c306cf..0b43842e 100644
--- a/src/compiler.js
+++ b/src/compiler.js
@@ -160,12 +160,6 @@ if (SAFE_HEAP >= 2) {
   SAFE_HEAP_LINES = set(SAFE_HEAP_LINES); // for fast checking
 }
 
-if (PGO) { // by default, correct everything during PGO
-  CORRECT_SIGNS = CORRECT_SIGNS || 1;
-  CORRECT_OVERFLOWS = CORRECT_OVERFLOWS || 1;
-  CORRECT_ROUNDINGS = CORRECT_ROUNDINGS || 1;
-}
-
 EXPORTED_FUNCTIONS = set(EXPORTED_FUNCTIONS);
 EXPORTED_GLOBALS = set(EXPORTED_GLOBALS);
 EXCEPTION_CATCHING_WHITELIST = set(EXCEPTION_CATCHING_WHITELIST);
@@ -185,7 +179,7 @@ assert(!(!NAMED_GLOBALS && BUILD_AS_SHARED_LIB)); // shared libraries must have
 
 if (phase == 'pre') {
   if (!MICRO_OPTS || !RELOOP || ASSERTIONS || CHECK_SIGNS || CHECK_OVERFLOWS || INIT_STACK || INIT_HEAP ||
-      !SKIP_STACK_IN_SMALL || SAFE_HEAP || PGO || PROFILE || !DISABLE_EXCEPTION_CATCHING) {
+      !SKIP_STACK_IN_SMALL || SAFE_HEAP || !DISABLE_EXCEPTION_CATCHING) {
     print('// Note: Some Emscripten settings will significantly limit the speed of the generated code.');
   } else {
     print('// Note: For maximum-speed code, see "Optimizing Code" on the Emscripten wiki, https://github.com/kripken/emscripten/wiki/Optimizing-Code');
diff --git a/src/corruptionCheck.js b/src/corruptionCheck.js
new file mode 100644
index 00000000..315f5cf0
--- /dev/null
+++ b/src/corruptionCheck.js
@@ -0,0 +1,98 @@
+
+// See settings.js, CORRUPTION_CHECK
+
+var CorruptionChecker = {
+  BUFFER_FACTOR: Math.round({{{ CORRUPTION_CHECK }}}),
+
+  ptrs: {},
+  checks: 0,
+  checkFrequency: 1,
+
+  init: function() {
+    this.realMalloc = _malloc;
+    _malloc = Module['_malloc'] = this.malloc;
+
+    this.realFree = _free;
+    _free = Module['_free'] = this.free;
+
+    if (typeof _realloc != 'undefined') {
+      this.realRealloc = _realloc;
+      _realloc = Module['_realloc'] = this.realloc;
+    }
+
+    __ATEXIT__.push({ func: function() {
+      Module.printErr('No corruption detected, ran ' + CorruptionChecker.checks + ' checks.');
+    } });
+  },
+  malloc: function(size) {
+    if (size <= 0) size = 1; // malloc(0) sometimes happens - just allocate a larger area, no harm
+    CorruptionChecker.checkAll();
+    size = (size+7)&(~7);
+    var allocation = CorruptionChecker.realMalloc(size*(1+2*CorruptionChecker.BUFFER_FACTOR));
+    var ptr = allocation + size*CorruptionChecker.BUFFER_FACTOR;
+    assert(!CorruptionChecker.ptrs[ptr]);
+    CorruptionChecker.ptrs[ptr] = size;
+    CorruptionChecker.fillBuffer(allocation, size*CorruptionChecker.BUFFER_FACTOR);
+    CorruptionChecker.fillBuffer(allocation + size*(1+CorruptionChecker.BUFFER_FACTOR), size*CorruptionChecker.BUFFER_FACTOR);
+    //Module.printErr('malloc ' + size + ' ==> ' + [ptr, allocation]);
+    return ptr;
+  },
+  free: function(ptr) {
+    if (!ptr) return; // ok to free(NULL), does nothing
+    CorruptionChecker.checkAll();
+    var size = CorruptionChecker.ptrs[ptr];
+    //Module.printErr('free ' + ptr + ' of size ' + size);
+    assert(size);
+    var allocation = ptr - size*CorruptionChecker.BUFFER_FACTOR;
+    //Module.printErr('free ' + ptr + ' of size ' + size + ' and allocation ' + allocation);
+    delete CorruptionChecker.ptrs[ptr];
+    CorruptionChecker.realFree(allocation);
+  },
+  realloc: function(ptr, newSize) {
+    //Module.printErr('realloc ' + ptr + ' to size ' + newSize);
+    if (newSize <= 0) newSize = 1; // like in malloc
+    if (!ptr) return CorruptionChecker.malloc(newSize); // realloc(NULL, size) forwards to malloc according to the spec
+    var size = CorruptionChecker.ptrs[ptr];
+    assert(size);
+    var allocation = ptr - size*CorruptionChecker.BUFFER_FACTOR;
+    var newPtr = CorruptionChecker.malloc(newSize);
+    //Module.printErr('realloc ' + ptr + ' to size ' + newSize + ' is now ' + newPtr);
+    var newAllocation = newPtr + newSize*CorruptionChecker.BUFFER_FACTOR;
+    HEAPU8.set(HEAPU8.subarray(ptr, ptr + Math.min(size, newSize)), newPtr);
+    CorruptionChecker.free(ptr);
+    return newPtr;
+  },
+  canary: function(x) {
+    return (x&127) + 10;
+  },
+  fillBuffer: function(buffer, size) {
+    for (var x = buffer; x < buffer + size; x++) {
+      {{{ makeSetValue('x', 0, 'CorruptionChecker.canary(x)', 'i8') }}};
+    }
+  },
+  checkBuffer: function(buffer, size) {
+    for (var x = buffer; x < buffer + size; x++) {
+      if (({{{ makeGetValue('x', 0, 'i8') }}}&255) != CorruptionChecker.canary(x)) {
+        assert(0, 'Heap corruption detected!' + [x, buffer, size, {{{ makeGetValue('x', 0, 'i8') }}}&255, CorruptionChecker.canary(x)]);
+      }
+    }
+  },
+  checkPtr: function(ptr) {
+    var size = CorruptionChecker.ptrs[ptr];
+    assert(size);
+    var allocation = ptr - size*CorruptionChecker.BUFFER_FACTOR;
+    CorruptionChecker.checkBuffer(allocation, size*CorruptionChecker.BUFFER_FACTOR);
+    CorruptionChecker.checkBuffer(allocation + size*(1+CorruptionChecker.BUFFER_FACTOR), size*CorruptionChecker.BUFFER_FACTOR);
+  },
+  checkAll: function(force) {
+    CorruptionChecker.checks++;
+    if (!force && CorruptionChecker.checks % CorruptionChecker.checkFrequency != 0) return;
+    //Module.printErr('checking for corruption ' + (CorruptionChecker.checks/CorruptionChecker.checkFrequency));
+    for (var ptr in CorruptionChecker.ptrs) {
+      CorruptionChecker.checkPtr(ptr, false);
+    }
+  },
+};
+
+CorruptionChecker.init();
+
diff --git a/src/jsifier.js b/src/jsifier.js
index 761a5fec..71975b9d 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -478,8 +478,7 @@ function JSify(data, functionsOnly, givenFunctions) {
           ident = '_' + ident;
         }
         var depsText = (deps ? '\n' + deps.map(addFromLibrary).filter(function(x) { return x != '' }).join('\n') : '');
-        // redirected idents just need a var, but no value assigned to them - it would be unused
-        var contentText = isFunction ? snippet : ('var ' + ident + (redirectedIdent ? '' : '=' + snippet) + ';');
+        var contentText = isFunction ? snippet : ('var ' + ident + '=' + snippet + ';');
         if (ASM_JS) {
           var sig = LibraryManager.library[ident.substr(1) + '__sig'];
           if (isFunction && sig && LibraryManager.library[ident.substr(1) + '__asm']) {
@@ -631,15 +630,6 @@ function JSify(data, functionsOnly, givenFunctions) {
         }
       }
 
-      if (PROFILE) {
-        func.JS += '  if (PROFILING) { '
-                +      'var __parentProfilingNode__ = PROFILING_NODE; PROFILING_NODE = PROFILING_NODE.children["' + func.ident + '"]; '
-                +      'if (!PROFILING_NODE) __parentProfilingNode__.children["' + func.ident + '"] = PROFILING_NODE = { time: 0, children: {}, calls: 0 };'
-                +      'PROFILING_NODE.calls++; '
-                +      'var __profilingStartTime__ = Date.now() '
-                +    '}\n';
-      }
-
       if (true) { // TODO: optimize away when not needed
         if (CLOSURE_ANNOTATIONS) func.JS += '/** @type {number} */';
         func.JS += '  var label = 0;\n';
@@ -1145,12 +1135,6 @@ function JSify(data, functionsOnly, givenFunctions) {
   });
   makeFuncLineActor('return', function(item) {
     var ret = RuntimeGenerator.stackExit(item.funcData.initialStack, item.funcData.otherStackAllocations) + ';\n';
-    if (PROFILE) {
-      ret += 'if (PROFILING) { '
-          +    'PROFILING_NODE.time += Date.now() - __profilingStartTime__; '
-          +    'PROFILING_NODE = __parentProfilingNode__ '
-          +  '}\n';
-    }
     if (LABEL_DEBUG && functionNameFilterTest(item.funcData.ident)) {
       ret += "Module.print(INDENT + 'Exiting: " + item.funcData.ident + "');\n"
           +  "INDENT = INDENT.substr(0, INDENT.length-2);\n";
@@ -1547,6 +1531,10 @@ function JSify(data, functionsOnly, givenFunctions) {
     // This is the main 'post' pass. Print out the generated code that we have here, together with the
     // rest of the output that we started to print out earlier (see comment on the
     // "Final shape that will be created").
+    if (CORRUPTION_CHECK) {
+      assert(!ASM_JS); // cannot monkeypatch asm!
+      print(processMacros(read('corruptionCheck.js')));
+    }
     if (PRECISE_I64_MATH && Types.preciseI64MathUsed) {
       print(read('long.js'));
     } else {
diff --git a/src/library.js b/src/library.js
index ee0befa1..d8f98d73 100644
--- a/src/library.js
+++ b/src/library.js
@@ -2491,6 +2491,17 @@ LibraryManager.library = {
         continue;
       }
 
+      // TODO: Support strings like "%5c" etc.
+      if (format[formatIndex] === '%' && format[formatIndex+1] == 'c') {
+        var argPtr = {{{ makeGetValue('varargs', 'argIndex', 'void*') }}};
+        argIndex += Runtime.getNativeFieldSize('void*');
+        fields++;
+        next = get();
+        {{{ makeSetValue('argPtr', 0, 'next', 'i8') }}}
+        formatIndex += 2;
+        continue;
+      }
+
       // remove whitespace
       while (1) {
         next = get();
@@ -5080,6 +5091,7 @@ LibraryManager.library = {
   },
 
   __cxa_call_unexpected: function(exception) {
+    Module.printErr('Unexpected exception thrown, this is not properly supported - aborting');
     ABORT = true;
     throw exception;
   },
@@ -7303,36 +7315,6 @@ LibraryManager.library = {
   emscripten_random: function() {
     return Math.random();
   },
-
-  $Profiling: {
-    max_: 0,
-    times: null,
-    invalid: 0,
-    dump: function() {
-      if (Profiling.invalid) {
-        Module.printErr('Invalid # of calls to Profiling begin and end!');
-        return;
-      }
-      Module.printErr('Profiling data:')
-      for (var i = 0; i < Profiling.max_; i++) {
-        Module.printErr('Block ' + i + ': ' + Profiling.times[i]);
-      }
-    }
-  },
-  EMSCRIPTEN_PROFILE_INIT__deps: ['$Profiling'],
-  EMSCRIPTEN_PROFILE_INIT: function(max_) {
-    Profiling.max_ = max_;
-    Profiling.times = new Array(max_);
-    for (var i = 0; i < max_; i++) Profiling.times[i] = 0;
-  },
-  EMSCRIPTEN_PROFILE_BEGIN__inline: function(id) {
-    return 'Profiling.times[' + id + '] -= Date.now();'
-         + 'Profiling.invalid++;'
-  },
-  EMSCRIPTEN_PROFILE_END__inline: function(id) {
-    return 'Profiling.times[' + id + '] += Date.now();'
-         + 'Profiling.invalid--;'
-  }
 };
 
 function autoAddDeps(object, name) {
diff --git a/src/library_browser.js b/src/library_browser.js
index 6af2ce0b..e9396d69 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -268,7 +268,7 @@ mergeInto(LibraryManager.library, {
       }
       return ctx;
     },
-
+    destroyContext: function(canvas, useWebGL, setInModule) {},
     requestFullScreen: function() {
       var canvas = Module['canvas'];
       function fullScreenChange() {
diff --git a/src/library_egl.js b/src/library_egl.js
index a9eb37dd..271ea29e 100644
--- a/src/library_egl.js
+++ b/src/library_egl.js
@@ -83,6 +83,17 @@ var LibraryEGL = {
     return 1;
   },
   
+// EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy);
+  eglTerminate: function(display) {
+    if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
+      EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
+      return 0;
+    }
+    // TODO: Tear down EGL here. Currently a no-op since we don't need to actually do anything here for the browser.
+    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
+    return 1;
+  },
+
   // EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
   eglGetConfigs: function(display, configs, config_size, numConfigs) { 
     return EGL.chooseConfig(display, 0, configs, config_size, numConfigs);
@@ -225,6 +236,20 @@ var LibraryEGL = {
     return 62006; /* Magic ID for Emscripten 'default surface' */
   },
 
+  // EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay display, EGLSurface surface);
+  eglDestroySurface: function(display, surface) { 
+    if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
+      EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
+      return 0; 
+    }
+    if (surface != 62006 /* Magic ID for the only EGLSurface supported by Emscripten */) {
+      EGL.setErrorCode(0x300D /* EGL_BAD_SURFACE */);
+      return 1;
+    }
+    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
+    return 1; /* Magic ID for Emscripten 'default surface' */
+  },
+
   eglCreateContext__deps: ['glutCreateWindow', '$GL'],
   
   // EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
@@ -234,7 +259,21 @@ var LibraryEGL = {
       return 0;
     }
 
-    _glutCreateWindow();
+    EGL.windowID = _glutCreateWindow();
+    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
+    return 62004; // Magic ID for Emscripten EGLContext
+  },
+
+  eglDestroyContext__deps: ['glutDestroyWindow', '$GL'],
+  
+  // EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext context);
+  eglDestroyContext: function(display, context) {
+    if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
+      EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
+      return 0;
+    }
+
+    _glutDestroyWindow(EGL.windowID);
     EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
     return 62004; // Magic ID for Emscripten EGLContext
   },
diff --git a/src/library_gl.js b/src/library_gl.js
index 1f664717..2c3be61c 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -993,6 +993,10 @@ var LibraryGL = {
     fogMode: 0x0800, // GL_EXP
     fogEnabled: false,
 
+    // VAO support
+    vaos: [],
+    currentVao: null,
+
     init: function() {
       GLEmulation.fogColor = new Float32Array(4);
 
@@ -1018,6 +1022,11 @@ var LibraryGL = {
         if (cap == 0x0B60 /* GL_FOG */) {
           GLEmulation.fogEnabled = true;
           return;
+        } else if (cap == 0x0de1 /* GL_TEXTURE_2D */) {
+          // XXX not according to spec, and not in desktop GL, but works in some GLES1.x apparently, so support
+          // it by forwarding to glEnableClientState
+          _glEnableClientState(cap);
+          return;
         } else if (!(cap in validCapabilities)) {
           return;
         }
@@ -1028,6 +1037,11 @@ var LibraryGL = {
         if (cap == 0x0B60 /* GL_FOG */) {
           GLEmulation.fogEnabled = false;
           return;
+        } else if (cap == 0x0de1 /* GL_TEXTURE_2D */) {
+          // XXX not according to spec, and not in desktop GL, but works in some GLES1.x apparently, so support
+          // it by forwarding to glDisableClientState
+          _glDisableClientState(cap);
+          return;
         } else if (!(cap in validCapabilities)) {
           return;
         }
@@ -1062,6 +1076,51 @@ var LibraryGL = {
             return;
           }
           case 0x8871: pname = Module.ctx.MAX_COMBINED_TEXTURE_IMAGE_UNITS /* close enough */; break; // GL_MAX_TEXTURE_COORDS
+          case 0x807A: { // GL_VERTEX_ARRAY_SIZE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};
+            return;
+          }
+          case 0x807B: { // GL_VERTEX_ARRAY_TYPE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};
+            return;
+          }
+          case 0x807C: { // GL_VERTEX_ARRAY_STRIDE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};
+            return;
+          }
+          case 0x8081: { // GL_COLOR_ARRAY_SIZE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.COLOR];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};
+            return;
+          }
+          case 0x8082: { // GL_COLOR_ARRAY_TYPE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.COLOR];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};
+            return;
+          }
+          case 0x8083: { // GL_COLOR_ARRAY_STRIDE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.COLOR];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};
+            return;
+          }
+          case 0x8088: { // GL_TEXTURE_COORD_ARRAY_SIZE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};
+            return;
+          }
+          case 0x8089: { // GL_TEXTURE_COORD_ARRAY_TYPE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};
+            return;
+          }
+          case 0x808A: { // GL_TEXTURE_COORD_ARRAY_STRIDE
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            {{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};
+            return;
+          }
         }
         glGetIntegerv(pname, params);
       };
@@ -1277,8 +1336,13 @@ var LibraryGL = {
         glBindBuffer(target, buffer);
         if (target == Module.ctx.ARRAY_BUFFER) {
           GL.currArrayBuffer = buffer;
+          if (GLEmulation.currentVao) {
+            assert(GLEmulation.currentVao.arrayBuffer == buffer || GLEmulation.currentVao.arrayBuffer == 0 || buffer == 0, 'TODO: support for multiple array buffers in vao');
+            GLEmulation.currentVao.arrayBuffer = buffer;
+          }
         } else if (target == Module.ctx.ELEMENT_ARRAY_BUFFER) {
           GL.currElementArrayBuffer = buffer;
+          if (GLEmulation.currentVao) GLEmulation.currentVao.elementArrayBuffer = buffer;
         }
       };
 
@@ -1322,6 +1386,26 @@ var LibraryGL = {
         }
         glHint(target, mode);
       };
+
+      var glEnableVertexAttribArray = _glEnableVertexAttribArray;
+      _glEnableVertexAttribArray = function(index) {
+        glEnableVertexAttribArray(index);
+        if (GLEmulation.currentVao) GLEmulation.currentVao.enabledVertexAttribArrays[index] = 1;
+      };
+
+      var glDisableVertexAttribArray = _glDisableVertexAttribArray;
+      _glDisableVertexAttribArray = function(index) {
+        glDisableVertexAttribArray(index);
+        if (GLEmulation.currentVao) delete GLEmulation.currentVao.enabledVertexAttribArrays[index];
+      };
+
+      var glVertexAttribPointer = _glVertexAttribPointer;
+      _glVertexAttribPointer = function(index, size, type, normalized, stride, pointer) {
+        glVertexAttribPointer(index, size, type, normalized, stride, pointer);
+        if (GLEmulation.currentVao) { // TODO: avoid object creation here? likely not hot though
+          GLEmulation.currentVao.vertexAttribPointers[index] = [index, size, type, normalized, stride, pointer];
+        }
+      };
     },
 
     getProcAddress: function(name) {
@@ -1437,6 +1521,20 @@ var LibraryGL = {
     assert(id == 0);
   },
 
+  glGetPointerv: function(name, p) {
+    var attribute;
+    switch(name) {
+      case 0x808E: // GL_VERTEX_ARRAY_POINTER
+        attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX]; break;
+      case 0x8090: // GL_COLOR_ARRAY_POINTER
+        attribute = GLImmediate.clientAttributes[GLImmediate.COLOR]; break;
+      case 0x8092: // GL_TEXTURE_COORD_ARRAY_POINTER
+        attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0]; break;
+      default: throw 'TODO: glGetPointerv for ' + name;
+    }
+    {{{ makeSetValue('p', '0', 'attribute ? attribute.pointer : 0', 'i32') }}};
+  },
+
   // GL Immediate mode
 
   $GLImmediate__postset: 'GL.immediate.setupFuncs(); Browser.moduleContextCreatedCallbacks.push(function() { GL.immediate.init() });',
@@ -2400,6 +2498,54 @@ var LibraryGL = {
     GL.immediate.clientActiveTexture = texture - 0x84C0; // GL_TEXTURE0
   },
 
+  // Vertex array object (VAO) support. TODO: when the WebGL extension is popular, use that and remove this code and GL.vaos
+  glGenVertexArrays__deps: ['$GLEMulation'],
+  glGenVertexArrays: function(n, vaos) {
+    for (var i = 0; i < n; i++) {
+      var id = GL.getNewId(GLEmulation.vaos); 
+      GLEmulation.vaos[id] = {
+        id: id,
+        arrayBuffer: 0,
+        elementArrayBuffer: 0,
+        enabledVertexAttribArrays: {},
+        vertexAttribPointers: {},
+      };
+      {{{ makeSetValue('vaos', 'i*4', 'id', 'i32') }}};
+    }
+  },
+  glDeleteVertexArrays: function(n, vaos) {
+    for (var i = 0; i < n; i++) {
+      var id = {{{ makeGetValue('vaos', 'i*4', 'i32') }}};
+      GLEmulation.vaos[id] = null;
+      if (GLEmulation.currentVao && GLEmulation.currentVao.id == id) GLEmulation.currentVao = null;
+    }
+  },
+  glBindVertexArray: function(vao) {
+    if (vao) {
+      // replay vao
+      if (GLEmulation.currentVao) _glBindVertexArray(0); // flush the old one out
+      var info = GLEmulation.vaos[vao];
+      _glBindBuffer(Module.ctx.ARRAY_BUFFER, info.arrayBuffer); // XXX overwrite current binding?
+      _glBindBuffer(Module.ctx.ELEMENT_ARRAY_BUFFER, info.elementArrayBuffer);
+      for (var vaa in info.enabledVertexAttribArrays) {
+        _glEnableVertexAttribArray(vaa);
+      }
+      for (var vaa in info.vertexAttribPointers) {
+        _glVertexAttribPointer.apply(null, info.vertexAttribPointers[vaa]);
+      }
+      GLEmulation.currentVao = info; // set currentVao last,