simplify and automate GetProcAddress logic, and move it out of GL emulation

5 files changed, 49 insertions, 191 deletions

diff --git a/src/jsifier.js b/src/jsifier.js
index c92526d2..8ed19194 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -16,6 +16,8 @@ var SETJMP_LABEL = -1;
 
 var INDENTATION = ' ';
 
+var functionStubSigs = {};
+
 // JSifier
 function JSify(data, functionsOnly, givenFunctions) {
   var mainPass = !functionsOnly;
@@ -407,6 +409,11 @@ function JSify(data, functionsOnly, givenFunctions) {
   // functionStub
   substrate.addActor('FunctionStub', {
     processItem: function(item) {
+      // note the signature
+      if (item.returnType && item.params) {
+        functionStubSigs[item.ident] = Functions.getSignature(item.returnType.text, item.params.map(function(arg) { return arg.type }), false);
+      }
+
       function addFromLibrary(ident) {
         if (ident in addedLibraryItems) return '';
         addedLibraryItems[ident] = true;
@@ -1537,7 +1544,7 @@ function JSify(data, functionsOnly, givenFunctions) {
           // This is a call through an invoke_*, either a forced one, or a setjmp-required one
           // note: no need to update argsTypes at this point
           if (byPointerForced) Functions.unimplementedFunctions[callIdent] = sig;
-          args.unshift(byPointerForced ? Functions.getIndex(callIdent, undefined, sig) : asmCoercion(callIdent, 'i32'));
+          args.unshift(byPointerForced ? Functions.getIndex(callIdent, sig) : asmCoercion(callIdent, 'i32'));
           callIdent = 'invoke_' + sig;
         }
       } else if (SAFE_DYNCALLS) {
diff --git a/src/library_gl.js b/src/library_gl.js
index cd50a279..d69a479f 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -1289,6 +1289,7 @@ var LibraryGL = {
 
   // GL emulation: provides misc. functionality not present in OpenGL ES 2.0 or WebGL
 
+  $GLEmulation__deps: ['$GLImmediateSetup', 'glEnable', 'glDisable', 'glIsEnabled', 'glGetBooleanv', 'glGetIntegerv', 'glGetString', 'glCreateShader', 'glShaderSource', 'glCompileShader', 'glAttachShader', 'glDetachShader', 'glUseProgram', 'glDeleteProgram', 'glBindAttribLocation', 'glLinkProgram', 'glBindBuffer', 'glGetFloatv', 'glHint', 'glEnableVertexAttribArray', 'glDisableVertexAttribArray', 'glVertexAttribPointer', 'glActiveTexture'],
   $GLEmulation__postset: 'GLEmulation.init();',
   $GLEmulation: {
     // Fog support. Partial, we assume shaders are used that implement fog. We just pass them uniforms
@@ -1773,170 +1774,6 @@ var LibraryGL = {
       }
       return attrib;
     },
-
-    getProcAddress: function(name) {
-      name = name.replace('EXT', '').replace('ARB', '');
-      // Do the translation carefully because of closure
-      var ret = 0;
-      switch (name) {
-        case 'glCreateShaderObject': case 'glCreateShader': ret = {{{ Functions.getIndex('_glCreateShader', true) }}}; break;
-        case 'glCreateProgramObject': case 'glCreateProgram': ret = {{{ Functions.getIndex('_glCreateProgram', true) }}}; break;
-        case 'glAttachObject': case 'glAttachShader': ret = {{{ Functions.getIndex('_glAttachShader', true) }}}; break;
-        case 'glUseProgramObject': case 'glUseProgram': ret = {{{ Functions.getIndex('_glUseProgram', true) }}}; break;
-        case 'glDetachObject': case 'glDetachShader': ret = {{{ Functions.getIndex('_glDetachShader', true) }}}; break;
-        case 'glDeleteObject': ret = {{{ Functions.getIndex('_glDeleteObject', true) }}}; break;
-        case 'glGetObjectParameteriv': ret = {{{ Functions.getIndex('_glGetObjectParameteriv', true) }}}; break;
-        case 'glGetInfoLog': ret = {{{ Functions.getIndex('_glGetInfoLog', true) }}}; break;
-        case 'glBindProgram': ret = {{{ Functions.getIndex('_glBindProgram', true) }}}; break;
-        case 'glDrawRangeElements': ret = {{{ Functions.getIndex('_glDrawRangeElements', true) }}}; break;
-        case 'glShaderSource': ret = {{{ Functions.getIndex('_glShaderSource', true) }}}; break;
-        case 'glCompileShader': ret = {{{ Functions.getIndex('_glCompileShader', true) }}}; break;
-        case 'glLinkProgram': ret = {{{ Functions.getIndex('_glLinkProgram', true) }}}; break;
-        case 'glGetUniformLocation': ret = {{{ Functions.getIndex('_glGetUniformLocation', true) }}}; break;
-        case 'glUniform1f': ret = {{{ Functions.getIndex('_glUniform1f', true) }}}; break;
-        case 'glUniform2f': ret = {{{ Functions.getIndex('_glUniform2f', true) }}}; break;
-        case 'glUniform3f': ret = {{{ Functions.getIndex('_glUniform3f', true) }}}; break;
-        case 'glUniform4f': ret = {{{ Functions.getIndex('_glUniform4f', true) }}}; break;
-        case 'glUniform1fv': ret = {{{ Functions.getIndex('_glUniform1fv', true) }}}; break;
-        case 'glUniform2fv': ret = {{{ Functions.getIndex('_glUniform2fv', true) }}}; break;
-        case 'glUniform3fv': ret = {{{ Functions.getIndex('_glUniform3fv', true) }}}; break;
-        case 'glUniform4fv': ret = {{{ Functions.getIndex('_glUniform4fv', true) }}}; break;
-        case 'glUniform1i': ret = {{{ Functions.getIndex('_glUniform1i', true) }}}; break;
-        case 'glUniform2i': ret = {{{ Functions.getIndex('_glUniform2i', true) }}}; break;
-        case 'glUniform3i': ret = {{{ Functions.getIndex('_glUniform3i', true) }}}; break;
-        case 'glUniform4i': ret = {{{ Functions.getIndex('_glUniform4i', true) }}}; break;
-        case 'glUniform1iv': ret = {{{ Functions.getIndex('_glUniform1iv', true) }}}; break;
-        case 'glUniform2iv': ret = {{{ Functions.getIndex('_glUniform2iv', true) }}}; break;
-        case 'glUniform3iv': ret = {{{ Functions.getIndex('_glUniform3iv', true) }}}; break;
-        case 'glUniform4iv': ret = {{{ Functions.getIndex('_glUniform4iv', true) }}}; break;
-        case 'glBindAttribLocation': ret = {{{ Functions.getIndex('_glBindAttribLocation', true) }}}; break;
-        case 'glGetActiveUniform': ret = {{{ Functions.getIndex('_glGetActiveUniform', true) }}}; break;
-        case 'glGenBuffers': ret = {{{ Functions.getIndex('_glGenBuffers', true) }}}; break;
-        case 'glBindBuffer': ret = {{{ Functions.getIndex('_glBindBuffer', true) }}}; break;
-        case 'glBufferData': ret = {{{ Functions.getIndex('_glBufferData', true) }}}; break;
-        case 'glBufferSubData': ret = {{{ Functions.getIndex('_glBufferSubData', true) }}}; break;
-        case 'glDeleteBuffers': ret = {{{ Functions.getIndex('_glDeleteBuffers', true) }}}; break;
-        case 'glActiveTexture': ret = {{{ Functions.getIndex('_glActiveTexture', true) }}}; break;
-        case 'glClientActiveTexture': ret = {{{ Functions.getIndex('_glClientActiveTexture', true) }}}; break;
-        case 'glGetProgramiv': ret = {{{ Functions.getIndex('_glGetProgramiv', true) }}}; break;
-        case 'glEnableVertexAttribArray': ret = {{{ Functions.getIndex('_glEnableVertexAttribArray', true) }}}; break;
-        case 'glDisableVertexAttribArray': ret = {{{ Functions.getIndex('_glDisableVertexAttribArray', true) }}}; break;
-        case 'glVertexAttribPointer': ret = {{{ Functions.getIndex('_glVertexAttribPointer', true) }}}; break;
-        case 'glVertexAttrib1f': ret = {{{ Functions.getIndex('_glVertexAttrib1f', true) }}}; break;
-        case 'glVertexAttrib2f': ret = {{{ Functions.getIndex('_glVertexAttrib2f', true) }}}; break;
-        case 'glVertexAttrib3f': ret = {{{ Functions.getIndex('_glVertexAttrib3f', true) }}}; break;
-        case 'glVertexAttrib4f': ret = {{{ Functions.getIndex('_glVertexAttrib4f', true) }}}; break;
-        case 'glVertexAttrib1fv': ret = {{{ Functions.getIndex('_glVertexAttrib1fv', true) }}}; break;
-        case 'glVertexAttrib2fv': ret = {{{ Functions.getIndex('_glVertexAttrib2fv', true) }}}; break;
-        case 'glVertexAttrib3fv': ret = {{{ Functions.getIndex('_glVertexAttrib3fv', true) }}}; break;
-        case 'glVertexAttrib4fv': ret = {{{ Functions.getIndex('_glVertexAttrib4fv', true) }}}; break;
-        case 'glGetVertexAttribfv': ret = {{{ Functions.getIndex('_glGetVertexAttribfv', true) }}}; break;
-        case 'glGetVertexAttribiv': ret = {{{ Functions.getIndex('_glGetVertexAttribiv', true) }}}; break;
-        case 'glGetVertexAttribPointerv': ret = {{{ Functions.getIndex('_glGetVertexAttribPointerv', true) }}}; break;
-        case 'glGetAttribLocation': ret = {{{ Functions.getIndex('_glGetAttribLocation', true) }}}; break;
-        case 'glGetActiveAttrib': ret = {{{ Functions.getIndex('_glGetActiveAttrib', true) }}}; break;
-        case 'glBindRenderbuffer': ret = {{{ Functions.getIndex('_glBindRenderbuffer', true) }}}; break;
-        case 'glDeleteRenderbuffers': ret = {{{ Functions.getIndex('_glDeleteRenderbuffers', true) }}}; break;
-        case 'glGenRenderbuffers': ret = {{{ Functions.getIndex('_glGenRenderbuffers', true) }}}; break;
-        case 'glCompressedTexImage2D': ret = {{{ Functions.getIndex('_glCompressedTexImage2D', true) }}}; break;
-        case 'glCompressedTexSubImage2D': ret = {{{ Functions.getIndex('_glCompressedTexSubImage2D', true) }}}; break;
-        case 'glBindFramebuffer': ret = {{{ Functions.getIndex('_glBindFramebuffer', true) }}}; break;
-        case 'glGenFramebuffers': ret = {{{ Functions.getIndex('_glGenFramebuffers', true) }}}; break;
-        case 'glDeleteFramebuffers': ret = {{{ Functions.getIndex('_glDeleteFramebuffers', true) }}}; break;
-        case 'glFramebufferRenderbuffer': ret = {{{ Functions.getIndex('_glFramebufferRenderbuffer', true) }}}; break;
-        case 'glFramebufferTexture2D': ret = {{{ Functions.getIndex('_glFramebufferTexture2D', true) }}}; break;
-        case 'glGetFramebufferAttachmentParameteriv': ret = {{{ Functions.getIndex('_glGetFramebufferAttachmentParameteriv', true) }}}; break;
-        case 'glIsFramebuffer': ret = {{{ Functions.getIndex('_glIsFramebuffer', true) }}}; break;
-        case 'glCheckFramebufferStatus': ret = {{{ Functions.getIndex('_glCheckFramebufferStatus', true) }}}; break;
-        case 'glRenderbufferStorage': ret = {{{ Functions.getIndex('_glRenderbufferStorage', true) }}}; break;
-        case 'glGenVertexArrays': ret = {{{ Functions.getIndex('_glGenVertexArrays', true) }}}; break;
-        case 'glDeleteVertexArrays': ret = {{{ Functions.getIndex('_glDeleteVertexArrays', true) }}}; break;
-        case 'glBindVertexArray': ret = {{{ Functions.getIndex('_glBindVertexArray', true) }}}; break;
-        case 'glGetString': ret = {{{ Functions.getIndex('_glGetString', true) }}}; break;
-        case 'glBindTexture': ret = {{{ Functions.getIndex('_glBindTexture', true) }}}; break;
-        case 'glGetBufferParameteriv': ret = {{{ Functions.getIndex('_glGetBufferParameteriv', true) }}}; break;
-        case 'glIsBuffer': ret = {{{ Functions.getIndex('_glIsBuffer', true) }}}; break;
-        case 'glDeleteShader': ret = {{{ Functions.getIndex('_glDeleteShader', true) }}}; break;
-        case 'glUniformMatrix2fv': ret = {{{ Functions.getIndex('_glUniformMatrix2fv', true) }}}; break;
-        case 'glUniformMatrix3fv': ret = {{{ Functions.getIndex('_glUniformMatrix3fv', true) }}}; break;
-        case 'glUniformMatrix4fv': ret = {{{ Functions.getIndex('_glUniformMatrix4fv', true) }}}; break;
-        case 'glIsRenderbuffer': ret = {{{ Functions.getIndex('_glIsRenderbuffer', true) }}}; break;
-        case 'glBlendEquation': ret = {{{ Functions.getIndex('_glBlendEquation', true) }}}; break;
-        case 'glBlendFunc': ret = {{{ Functions.getIndex('_glBlendFunc', true) }}}; break;
-        case 'glBlendFuncSeparate': ret = {{{ Functions.getIndex('_glBlendFuncSeparate', true) }}}; break;
-        case 'glBlendEquationSeparate': ret = {{{ Functions.getIndex('_glBlendEquationSeparate', true) }}}; break;
-        case 'glDepthRangef': ret = {{{ Functions.getIndex('_glDepthRangef', true) }}}; break;
-        case 'glClear': ret = {{{ Functions.getIndex('_glClear', true) }}}; break;
-        case 'glGenerateMipmap': ret = {{{ Functions.getIndex('_glGenerateMipmap', true) }}}; break;
-        case 'glBlendColor': ret = {{{ Functions.getIndex('_glBlendColor', true) }}}; break;
-        case 'glClearDepthf': ret = {{{ Functions.getIndex('_glClearDepthf', true) }}}; break;
-        case 'glDeleteProgram': ret = {{{ Functions.getIndex('_glDeleteProgram', true) }}}; break;
-        case 'glUniformMatrix3fv': ret = {{{ Functions.getIndex('_glUniformMatrix3fv', true) }}}; break;
-        case 'glClearColor': ret = {{{ Functions.getIndex('_glClearColor', true) }}}; break;
-        case 'glGetRenderbufferParameteriv': ret = {{{ Functions.getIndex('_glGetRenderbufferParameteriv', true) }}}; break;
-        case 'glGetShaderInfoLog': ret = {{{ Functions.getIndex('_glGetShaderInfoLog', true) }}}; break;
-        case 'glUniformMatrix4fv': ret = {{{ Functions.getIndex('_glUniformMatrix4fv', true) }}}; break;
-        case 'glClearStencil': ret = {{{ Functions.getIndex('_glClearStencil', true) }}}; break;
-        case 'glGetProgramInfoLog': ret = {{{ Functions.getIndex('_glGetProgramInfoLog', true) }}}; break;
-        case 'glGetUniformfv': ret = {{{ Functions.getIndex('_glGetUniformfv', true) }}}; break;
-        case 'glStencilFuncSeparate': ret = {{{ Functions.getIndex('_glStencilFuncSeparate', true) }}}; break;
-        case 'glSampleCoverage': ret = {{{ Functions.getIndex('_glSampleCoverage', true) }}}; break;
-        case 'glColorMask': ret = {{{ Functions.getIndex('_glColorMask', true) }}}; break;
-        case 'glGetShaderiv': ret = {{{ Functions.getIndex('_glGetShaderiv', true) }}}; break;
-        case 'glGetUniformiv': ret = {{{ Functions.getIndex('_glGetUniformiv', true) }}}; break;
-        case 'glCopyTexSubImage2D': ret = {{{ Functions.getIndex('_glCopyTexSubImage2D', true) }}}; break;
-        case 'glDetachShader': ret = {{{ Functions.getIndex('_glDetachShader', true) }}}; break;
-        case 'glGetShaderSource': ret = {{{ Functions.getIndex('_glGetShaderSource', true) }}}; break;
-        case 'glDeleteTextures': ret = {{{ Functions.getIndex('_glDeleteTextures', true) }}}; break;
-        case 'glGetAttachedShaders': ret = {{{ Functions.getIndex('_glGetAttachedShaders', true) }}}; break;
-        case 'glValidateProgram': ret = {{{ Functions.getIndex('_glValidateProgram', true) }}}; break;
-        case 'glDepthFunc': ret = {{{ Functions.getIndex('_glDepthFunc', true) }}}; break;
-        case 'glIsShader': ret = {{{ Functions.getIndex('_glIsShader', true) }}}; break;
-        case 'glDepthMask': ret = {{{ Functions.getIndex('_glDepthMask', true) }}}; break;
-        case 'glStencilMaskSeparate': ret = {{{ Functions.getIndex('_glStencilMaskSeparate', true) }}}; break;
-        case 'glIsProgram': ret = {{{ Functions.getIndex('_glIsProgram', true) }}}; break;
-        case 'glDisable': ret = {{{ Functions.getIndex('_glDisable', true) }}}; break;
-        case 'glStencilOpSeparate': ret = {{{ Functions.getIndex('_glStencilOpSeparate', true) }}}; break;
-        case 'glDrawArrays': ret = {{{ Functions.getIndex('_glDrawArrays', true) }}}; break;
-        case 'glDrawElements': ret = {{{ Functions.getIndex('_glDrawElements', true) }}}; break;
-        case 'glEnable': ret = {{{ Functions.getIndex('_glEnable', true) }}}; break;
-        case 'glFinish': ret = {{{ Functions.getIndex('_glFinish', true) }}}; break;
-        case 'glFlush': ret = {{{ Functions.getIndex('_glFlush', true) }}}; break;
-        case 'glFrontFace': ret = {{{ Functions.getIndex('_glFrontFace', true) }}}; break;
-        case 'glCullFace': ret = {{{ Functions.getIndex('_glCullFace', true) }}}; break;
-        case 'glGenTextures': ret = {{{ Functions.getIndex('_glGenTextures', true) }}}; break;
-        case 'glGetError': ret = {{{ Functions.getIndex('_glGetError', true) }}}; break;
-        case 'glGetIntegerv': ret = {{{ Functions.getIndex('_glGetIntegerv', true) }}}; break;
-        case 'glGetBooleanv': ret = {{{ Functions.getIndex('_glGetBooleanv', true) }}}; break;
-        case 'glGetFloatv': ret = {{{ Functions.getIndex('_glGetFloatv', true) }}}; break;
-        case 'glHint': ret = {{{ Functions.getIndex('_glHint', true) }}}; break;
-        case 'glIsTexture': ret = {{{ Functions.getIndex('_glIsTexture', true) }}}; break;
-        case 'glPixelStorei': ret = {{{ Functions.getIndex('_glPixelStorei', true) }}}; break;
-        case 'glReadPixels': ret = {{{ Functions.getIndex('_glReadPixels', true) }}}; break;
-        case 'glScissor': ret = {{{ Functions.getIndex('_glScissor', true) }}}; break;
-        case 'glStencilFunc': ret = {{{ Functions.getIndex('_glStencilFunc', true) }}}; break;
-        case 'glStencilMask': ret = {{{ Functions.getIndex('_glStencilMask', true) }}}; break;
-        case 'glStencilOp': ret = {{{ Functions.getIndex('_glStencilOp', true) }}}; break;
-        case 'glTexImage2D': ret = {{{ Functions.getIndex('_glTexImage2D', true) }}}; break;
-        case 'glTexParameterf': ret = {{{ Functions.getIndex('_glTexParameterf', true) }}}; break;
-        case 'glTexParameterfv': ret = {{{ Functions.getIndex('_glTexParameterfv', true) }}}; break;
-        case 'glTexParameteri': ret = {{{ Functions.getIndex('_glTexParameteri', true) }}}; break;
-        case 'glTexParameteriv': ret = {{{ Functions.getIndex('_glTexParameteriv', true) }}}; break;
-        case 'glGetTexParameterfv': ret = {{{ Functions.getIndex('_glGetTexParameterfv', true) }}}; break;
-        case 'glGetTexParameteriv': ret = {{{ Functions.getIndex('_glGetTexParameteriv', true) }}}; break;
-        case 'glTexSubImage2D': ret = {{{ Functions.getIndex('_glTexSubImage2D', true) }}}; break;
-        case 'glCopyTexImage2D': ret = {{{ Functions.getIndex('_glCopyTexImage2D', true) }}}; break;
-        case 'glViewport': ret = {{{ Functions.getIndex('_glViewport', true) }}}; break;
-        case 'glIsEnabled': ret = {{{ Functions.getIndex('_glIsEnabled', true) }}}; break;
-        case 'glLineWidth': ret = {{{ Functions.getIndex('_glLineWidth', true) }}}; break;
-        case 'glPolygonOffset': ret = {{{ Functions.getIndex('_glPolygonOffset', true) }}}; break;
-        case 'glReleaseShaderCompiler': ret = {{{ Functions.getIndex('_glReleaseShaderCompiler', true) }}}; break;
-        case 'glGetShaderPrecisionFormat': ret = {{{ Functions.getIndex('_glGetShaderPrecisionFormat', true) }}}; break;
-        case 'glShaderBinary': ret = {{{ Functions.getIndex('_glShaderBinary', true) }}}; break;
-      }
-      if (!ret) Module.printErr('WARNING: getProcAddress failed for ' + name);
-      return ret;
-    }
   },
 
   glGetShaderPrecisionFormat__sig: 'v',
@@ -4460,27 +4297,46 @@ var LibraryGL = {
 
 autoAddDeps(LibraryGL, '$GL');
 
+// Legacy GL emulation 
 if (LEGACY_GL_EMULATION) {
-  // Emulation requires everything else, potentially
-  LibraryGL.$GLEmulation__deps = LibraryGL.$GLEmulation__deps.slice(0); // the __deps object is shared
-  var glFuncs = [];
-  for (var item in LibraryGL) {
-    if (item != '$GLEmulation' && item.substr(-6) != '__deps' && item.substr(-9) != '__postset' && item.substr(-5) != '__sig' && item.substr(0, 2) == 'gl') {
-      glFuncs.push(item);
-    }
-  }
-  LibraryGL.$GLEmulation__deps = LibraryGL.$GLEmulation__deps.concat(glFuncs);
-  LibraryGL.$GLEmulation__deps.push(function() {
-    for (var func in Functions.getIndex.tentative) {
-      Functions.getIndex(func);
-      Functions.unimplementedFunctions[func] = LibraryGL[func.substr(1) + '__sig'];
+  DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push('$GLEmulation');
+}
+
+// GL proc address retrieval
+LibraryGL.emscripten_GetProcAddress__deps = [function() {
+  // ProcAddress is used, so include everything in GL. This runs before we go to the $ProcAddressTable object,
+  // and we fill its deps just in time, and create the lookup table
+  var table = {};
+  LibraryManager.library.emscripten_procAddressTable__deps = keys(LibraryGL).filter(function(x) {
+    if (x.substr(-6) == '__deps' || x.substr(-9) == '__postset' || x.substr(-5) == '__sig' || x.substr(0, 2) != 'gl') return false;
+    var sig = LibraryGL[x + '__sig'] || functionStubSigs['_' + x];
+    if (sig) {
+      table[x] = Functions.getIndex('_' + x, sig);
+      if (!(('_' + x) in Functions.implementedFunctions)) Functions.unimplementedFunctions[('_' + x)] = sig;
     }
+    return true;
   });
-
-  LibraryGL.glDrawElements__deps = LibraryGL.glDrawElements__deps.concat('$GLEmulation');
-  LibraryGL.glDrawArrays__deps = LibraryGL.glDrawArrays__deps.concat('$GLEmulation');
+  // convert table into function with switch, to not confuse closure compiler
+  var tableImpl = 'switch(name) {\n';
+  for (var x in table) tableImpl += 'case "' + x + '": return ' + table[x] + '; break;\n';
+  tableImpl += '}\nreturn 0;';
+  LibraryManager.library.emscripten_procAddressTable = new Function('name', tableImpl);
+}, 'emscripten_procAddressTable'];
+LibraryGL.emscripten_GetProcAddress = function(name) {
+  name = name.replace('EXT', '').replace('ARB', '');
+  switch(name) { // misc renamings
+    case 'glCreateProgramObject': name = 'glCreateProgram'; break;
+    case 'glUseProgramObject': name = 'glUseProgram'; break;
+    case 'glCreateShaderObject': name = 'glCreateShader'; break;
+    case 'glAttachObject': name = 'glAttachShader'; break;
+    case 'glDetachObject': name = 'glDetachShader'; break;
+  }
+  var ret = _emscripten_procAddressTable(name);
+  if (!ret) Module.printErr('WARNING: getProcAddress failed for ' + name);
+  return ret;
 }
 
+// Final merge
 mergeInto(LibraryManager.library, LibraryGL);
 
 assert(!(FULL_ES2 && LEGACY_GL_EMULATION), 'cannot emulate both ES2 and legacy GL');
diff --git a/src/library_sdl.js b/src/library_sdl.js
index 6cc337e8..236ab1bf 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -2067,9 +2067,9 @@ var LibrarySDL = {
     console.log('TODO: SDL_GL_SetAttribute');
   },
 
-  SDL_GL_GetProcAddress__deps: ['$GLEmulation'],
+  SDL_GL_GetProcAddress__deps: ['emscripten_GetProcAddress'],
   SDL_GL_GetProcAddress: function(name_) {
-    return GLEmulation.getProcAddress(Pointer_stringify(name_));
+    return _emscripten_GetProcAddress(Pointer_stringify(name_));
   },
 
   SDL_GL_SwapBuffers: function() {},
diff --git a/src/modules.js b/src/modules.js
index 13561777..01f0d8ae 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -275,20 +275,15 @@ var Functions = {
   },
 
   // Mark a function as needing indexing. Python will coordinate them all
-  getIndex: function(ident, doNotCreate, sig) {
-    if (doNotCreate && !(ident in this.indexedFunctions)) {
-      if (!Functions.getIndex.tentative) Functions.getIndex.tentative = {}; // only used by GL emulation; TODO: generalize when needed
-      Functions.getIndex.tentative[ident] = 0;
-    }
+  getIndex: function(ident, sig) {
     var ret;
     if (phase != 'post' && singlePhase) {
-      if (!doNotCreate) this.indexedFunctions[ident] = 0; // tell python we need this indexized
       ret = "'{{ FI_" + toNiceIdent(ident) + " }}'"; // something python will replace later
+      this.indexedFunctions[ident] = 0;
     } else {
       if (!singlePhase) return 'NO_INDEX'; // Should not index functions in post
       ret = this.indexedFunctions[ident];
       if (!ret) {
-        if (doNotCreate) return '0';
         ret = this.nextIndex;
         this.nextIndex += 2; // Need to have indexes be even numbers, see |polymorph| test
         this.indexedFunctions[ident] = ret;
diff --git a/src/parseTools.js b/src/parseTools.js
index f11c867a..65e96264 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -1244,7 +1244,7 @@ function indexizeFunctions(value, type) {
     if (!sig) {
       sig = Functions.unimplementedFunctions[value] = Functions.getSignature(out.returnType, out.segments ? out.segments.map(function(segment) { return segment[0].text }) : [], isVarArgsFunctionType(type));
     }
-    return Functions.getIndex(value, undefined, sig);
+    return Functions.getIndex(value, sig);
   }
   return value;
 }