webruby 0.1.0

data/modules/emscripten/src/experimental/renderer_cache_hash.diff

@@ -0,0 +1,99 @@
+diff --git a/src/library_gl.js b/src/library_gl.js
+index 4bce0ef..094a961 100644
+--- a/src/library_gl.js
++++ b/src/library_gl.js
+@@ -1386,6 +1386,7 @@ var LibraryGL = {
+     mode: 0,
+ 
+     rendererCache: {},
++    rendererCacheTemp: [], // temporary item for renderer cache lookups
+     rendererComponents: {}, // small cache for calls inside glBegin/end. counts how many times the element was seen
+     rendererComponentPointer: 0, // next place to start a glBegin/end component
+     lastRenderer: null, // used to avoid cleaning up and re-preparing the same renderer
+@@ -1520,9 +1521,71 @@ var LibraryGL = {
+     },
+ 
+     getRenderer: function() {
+-      // return a renderer object given the liveClientAttributes
+-      // we maintain a cache of renderers, optimized to not generate garbage
++      // return a renderer object given the liveClientAttributes and other relevant information about rendering state
+       var attributes = GL.immediate.liveClientAttributes;
++
++
++
++
++
++      var temp = GL.immediate.rendererCacheTemp;
++      temp.length = 0;
++      var hash = 1000;
++      var salt = 0x0149F37A;
++      function add(value) {
++        temp.push(value);
++        hash = (hash*(value+3))^salt;
++      }
++      for (var i = 0; i < attributes.length; i++) {
++        var attribute = attributes[i];
++        add(attribute.name);
++        add(attribute.size);
++        add(attribute.type);
++      }
++      add(GLEmulation.fogEnabled ? GLEmulation.fogMode : 0);
++      if (GL.currProgram) { // Note the order here; this one is last, and optional
++        add(GL.currProgram);
++      }
++      var cache = GL.immediate.rendererCache;
++      function isCorrect(item) {
++        if (item.hash != hash) return false;
++        if (item.id.length != temp.length) return false;
++        var length = temp.length;
++        var existing = item.id;
++        for (var i = 0; i < length; i++) {
++          if (existing[i] != temp[i]) {
++            return false;
++          }
++        }
++        return true;
++      }
++      var seek = hash;
++      var item;
++      while ((item = cache[seek]) && !isCorrect(item)) {
++        Module.printErr('cache collision!');
++        seek++;
++      }
++      if (item) return item.renderer;
++#if GL_DEBUG
++      Module.printErr('generating renderer for ' + JSON.stringify(attributes));
++#endif
++      var renderer = this.createRenderer();
++      cache[seek] = {
++        id: temp.slice(0),
++        hash: hash,
++        renderer: renderer
++      };
++      return renderer;
++
++
++
++
++
++
++
++
++
++      // we maintain a cache of renderers, optimized to not generate garbage
+       var cacheItem = GL.immediate.rendererCache;
+       for (var i = 0; i < attributes.length; i++) {
+         var attribute = attributes[i];
+@@ -1544,6 +1607,12 @@ var LibraryGL = {
+         if (!cacheItem[GL.currProgram]) cacheItem[GL.currProgram] = {};
+         cacheItem = cacheItem[GL.currProgram];
+       }
++
++
++
++
++
++
+       if (!cacheItem.renderer) {
+ #if GL_DEBUG
+         Module.printErr('generating renderer for ' + JSON.stringify(attributes));

data/modules/emscripten/src/experimental/sdl_key_forwarding.diff

@@ -0,0 +1,57 @@
+diff --git a/src/library_sdl.js b/src/library_sdl.js
+index 8cb8db7..d46a089 100644
+--- a/src/library_sdl.js
++++ b/src/library_sdl.js
+@@ -43,6 +43,7 @@ var LibrarySDL = {
+     DOMButtons: [0, 0, 0],
+ 
+     DOMEventToSDLEvent: {},
++    forwardedDOMKeys: {},
+ 
+     keyCodes: { // DOM code ==> SDL code. See https://developer.mozilla.org/en/Document_Object_Model_%28DOM%29/KeyboardEvent and SDL_keycode.h
+       46: 127, // SDLK_DEL == '\177'
+@@ -372,6 +373,11 @@ var LibrarySDL = {
+             if (!SDL.DOMButtons[event.button]) return false; // ignore extra ups, can happen if we leave the canvas while pressing down, then return,
+                                                              // since we add a mouseup in that case
+             SDL.DOMButtons[event.button] = 0;
++          } else if (event.type == 'keydown' || event.type == 'keyup') {
++            // whitelist a few keycodes that we do want to let the browser handle
++            if (event.keyCode in SDL.forwardedDOMKeys) {
++              return true;
++            }
+           }
+ 
+           SDL.events.push(event);
+@@ -399,6 +405,10 @@ var LibrarySDL = {
+           // Force-run a main event loop, since otherwise this event will never be caught!
+           Browser.mainLoop.runner();
+           return true;
++        case 'keypress':
++          if (event.ctrlKey) {
++            return true; // forward control-X events, see SDL.forwardedDOMKeys
++          }
+       }
+       return false;
+     },
+@@ -569,13 +579,20 @@ var LibrarySDL = {
+     window.onunload = SDL.receiveEvent;
+     SDL.keyboardState = _malloc(0x10000);
+     _memset(SDL.keyboardState, 0, 0x10000);
+-    // Initialize this structure carefully for closure
++    // Initialize these structures carefully for closure
+     SDL.DOMEventToSDLEvent['keydown'] = 0x300 /* SDL_KEYDOWN */;
+     SDL.DOMEventToSDLEvent['keyup'] = 0x301 /* SDL_KEYUP */;
+     SDL.DOMEventToSDLEvent['mousedown'] = 0x401 /* SDL_MOUSEBUTTONDOWN */;
+     SDL.DOMEventToSDLEvent['mouseup'] = 0x402 /* SDL_MOUSEBUTTONUP */;
+     SDL.DOMEventToSDLEvent['mousemove'] = 0x400 /* SDL_MOUSEMOTION */;
+     SDL.DOMEventToSDLEvent['unload'] = 0x100 /* SDL_QUIT */;
++    SDL.forwardedDOMKeys[17] = 1; // control - forward control-X to keep the page responsive
++    SDL.forwardedDOMKeys[173] = 1; // minus (shrink view)
++    SDL.forwardedDOMKeys[61] = 1; // plus (expand view)
++    SDL.forwardedDOMKeys[48] = 1; // 0 (return view to normal)
++    SDL.forwardedDOMKeys[84] = 1; // t (new tab)
++    SDL.forwardedDOMKeys[87] = 1; // w (close tab)
++    SDL.forwardedDOMKeys[82] = 1; // r (reload)
+     return 0; // success
+   },
+ 

data/modules/emscripten/src/experimental/simplifyGeneratedFunctionsDetection.diff

@@ -0,0 +1,336 @@
+diff --git a/emscripten.py b/emscripten.py
+index b698654..a7843c7 100755
+--- a/emscripten.py
++++ b/emscripten.py
+@@ -294,8 +294,6 @@ def emscript(infile, settings, outfile, libraries=[], compiler_engine=None,
+   outfile.write(blockaddrsize(indexize(pre)))
+   pre = None
+ 
+-  #if DEBUG: outfile.write('// funcs\n')
+-
+   # forward
+   forwarded_data = json.dumps(forwarded_json)
+   forwarded_file = temp_files.get('.2.json').name
+@@ -483,9 +481,14 @@ Runtime.stackRestore = function(top) { asm.stackRestore(top) };
+   else:
+     function_tables_defs = '\n'.join([table for table in last_forwarded_json['Functions']['tables'].itervalues()])
+     outfile.write(function_tables_defs)
++
++  outfile.write('// EMSCRIPTEN_START_FUNCS\n')
++
+   outfile.write(blockaddrsize(indexize(funcs_js)))
+   funcs_js = None
+ 
++  outfile.write('// EMSCRIPTEN_END_FUNCS\n')
++
+   outfile.write(indexize(post))
+   if DEBUG: print >> sys.stderr, '  emscript: phase 3 took %s seconds' % (time.time() - t)
+ 
+diff --git a/src/jsifier.js b/src/jsifier.js
+index ff58ece..d6aa110 100644
+--- a/src/jsifier.js
++++ b/src/jsifier.js
+@@ -1587,12 +1587,6 @@ function JSify(data, functionsOnly, givenFunctions) {
+ 
+     var shellParts = read(shellFile).split('{{BODY}}');
+     print(shellParts[1]);
+-    // Print out some useful metadata (for additional optimizations later, like the eliminator)
+-    if (EMIT_GENERATED_FUNCTIONS) {
+-      print('// EMSCRIPTEN_GENERATED_FUNCTIONS: ' + JSON.stringify(keys(Functions.implementedFunctions).filter(function(func) {
+-        return IGNORED_FUNCTIONS.indexOf(func.ident) < 0;
+-      })) + '\n');
+-    }
+ 
+     PassManager.serialize();
+ 
+diff --git a/src/settings.js b/src/settings.js
+index 1bfcf92..99c83f4 100644
+--- a/src/settings.js
++++ b/src/settings.js
+@@ -336,8 +336,6 @@ var EXPLICIT_ZEXT = 0; // If 1, generate an explicit conversion of zext i1 to i3
+ 
+ var NECESSARY_BLOCKADDRS = []; // List of (function, block) for all block addresses that are taken.
+ 
+-var EMIT_GENERATED_FUNCTIONS = 0; // whether to emit the list of generated functions, needed for external JS optimization passes
+-
+ // Compiler debugging options
+ var DEBUG_TAGS_SHOWING = [];
+   // Some useful items:
+diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js
+index f2dc516..9fa038c 100644
+--- a/tools/js-optimizer.js
++++ b/tools/js-optimizer.js
+@@ -140,16 +140,6 @@ var UNDEFINED_NODE = ['unary-prefix', 'void', ['num', 0]];
+ var TRUE_NODE = ['unary-prefix', '!', ['num', 0]];
+ var FALSE_NODE = ['unary-prefix', '!', ['num', 1]];
+ 
+-var GENERATED_FUNCTIONS_MARKER = '// EMSCRIPTEN_GENERATED_FUNCTIONS:';
+-var generatedFunctions = null;
+-function setGeneratedFunctions(metadata) {
+-  var start = metadata.indexOf(GENERATED_FUNCTIONS_MARKER);
+-  generatedFunctions = set(eval(metadata.substr(start + GENERATED_FUNCTIONS_MARKER.length)));
+-}
+-function isGenerated(ident) {
+-  return ident in generatedFunctions;
+-}
+-
+ function srcToAst(src) {
+   return uglify.parser.parse(src);
+ }
+@@ -212,21 +202,9 @@ function traverse(node, pre, post, stack) {
+   return result;
+ }
+ 
+-// Only walk through the generated functions
+-function traverseGenerated(ast, pre, post, stack) {
+-  assert(generatedFunctions);
+-  traverse(ast, function(node) {
+-    if (node[0] == 'defun' && isGenerated(node[1])) {
+-      traverse(node, pre, post, stack);
+-      return null;
+-    }
+-  });
+-}
+-
+-function traverseGeneratedFunctions(ast, callback) {
+-  assert(generatedFunctions);
++function traverseFunctions(ast, callback) {
+   traverse(ast, function(node) {
+-    if (node[0] == 'defun' && isGenerated(node[1])) {
++    if (node[0] == 'defun') {
+       callback(node);
+       return null;
+     }
+@@ -418,7 +396,7 @@ function simplifyExpressionsPre(ast) {
+     var rerun = true;
+     while (rerun) {
+       rerun = false;
+-      traverseGenerated(ast, function process(node, type, stack) {
++      traverse(ast, function process(node, type, stack) {
+         if (type == 'binary' && node[1] == '|') {
+           if (node[2][0] == 'num' && node[3][0] == 'num') {
+             return ['num', node[2][1] | node[3][1]];
+@@ -455,7 +433,7 @@ function simplifyExpressionsPre(ast) {
+     }
+ 
+     // &-related optimizations
+-    traverseGenerated(ast, function(node, type) {
++    traverse(ast, function(node, type) {
+       if (type == 'binary' && node[1] == '&' && node[3][0] == 'num') {
+         if (node[2][0] == 'num') return ['num', node[2][1] & node[3][1]];
+         var input = node[2];
+@@ -489,7 +467,7 @@ function simplifyExpressionsPre(ast) {
+ 
+     if (asm) {
+       // optimize num >> num, in asm we need this here since we do not run optimizeShifts
+-      traverseGenerated(ast, function(node, type) {
++      traverse(ast, function(node, type) {
+         if (type == 'binary' && node[1] == '>>' && node[2][0] == 'num' && node[3][0] == 'num') {
+           node[0] = 'num';
+           node[1] = node[2][1] >> node[3][1];
+@@ -505,7 +483,7 @@ function simplifyExpressionsPre(ast) {
+     var rerun = true;
+     while (rerun) {
+       rerun = false;
+-      traverseGenerated(ast, function(node, type) {
++      traverse(ast, function(node, type) {
+         if (type == 'binary' && node[1] == '+') {
+           if (node[2][0] == 'num' && node[3][0] == 'num') {
+             rerun = true;
+@@ -528,7 +506,7 @@ function simplifyExpressionsPre(ast) {
+ 
+   // if (x == 0) can be if (!x), etc.
+   function simplifyZeroComp(ast) {
+-    traverseGenerated(ast, function(node, type) {
++    traverse(ast, function(node, type) {
+       var binary;
+       if (type == 'if' && (binary = node[1])[0] == 'binary') {
+         if ((binary[1] == '!=' || binary[1] == '!==') && binary[3][0] == 'num' && binary[3][1] == 0) {
+@@ -554,7 +532,7 @@ function simplifyExpressionsPre(ast) {
+ // TODO: when shifting a variable, if there are other uses, keep an unshifted version too, to prevent slowdowns?
+ function optimizeShiftsInternal(ast, conservative) {
+   var MAX_SHIFTS = 3;
+-  traverseGeneratedFunctions(ast, function(fun) {
++  traverseFunctions(ast, function(fun) {
+     var funMore = true;
+     var funFinished = {};
+     while (funMore) {
+@@ -999,7 +977,7 @@ function vacuum(ast) {
+       } break;
+     }
+   }
+-  traverseGeneratedFunctions(ast, function(node) {
++  traverseFunctions(ast, function(node) {
+     vacuumInternal(node);
+     simplifyNotComps(node);
+   });
+@@ -1021,7 +999,7 @@ function getStatements(node) {
+ //   if (condition) { label == x } else ..
+ // We can hoist the multiple block into the condition, thus removing code and one 'if' check
+ function hoistMultiples(ast) {
+-  traverseGeneratedFunctions(ast, function(node) {
++  traverseFunctions(ast, function(node) {
+     traverse(node, function(node, type) {
+       var statements = getStatements(node);
+       if (!statements) return;
+@@ -1135,7 +1113,7 @@ function hoistMultiples(ast) {
+   //    if (..) { .. break|continue } else { .. }
+   // to
+   //    if (..) { .. break|continue } ..
+-  traverseGenerated(ast, function(container, type) {
++  traverse(ast, function(container, type) {
+     var statements = getStatements(container);
+     if (!statements) return;
+     for (var i = 0; i < statements.length; i++) {
+@@ -1168,7 +1146,7 @@ function loopOptimizer(ast) {
+   function passTwo(ast) {
+     var neededDos = [];
+     // Find unneeded labels
+-    traverseGenerated(ast, function(node, type, stack) {
++    traverse(ast, function(node, type, stack) {
+       if (type == 'label' && node[2][0] in LOOP) {
+         // this is a labelled loop. we don't know if it's needed yet. Mark its label for removal for now now.
+         stack.push(node);
+@@ -1212,7 +1190,7 @@ function loopOptimizer(ast) {
+     // We return whether another pass is necessary
+     var more = false;
+     // Remove unneeded labels
+-    traverseGenerated(ast, function(node, type) {
++    traverse(ast, function(node, type) {
+       if (type == 'label' && node[1][0] == '+') {
+         more = true;
+         var ident = node[1].substr(1);
+@@ -1227,13 +1205,13 @@ function loopOptimizer(ast) {
+     });
+     // Remove unneeded one-time loops. We need such loops if (1) they have a label, or (2) they have a direct break so they are in neededDos.
+     // First, add all labeled loops of this nature to neededDos
+-    traverseGenerated(ast, function(node, type) {
++    traverse(ast, function(node, type) {
+       if (type == 'label' && node[2][0] == 'do') {
+         neededDos.push(node[2]);
+       }
+     });
+     // Remove unneeded dos, we know who they are now
+-    traverseGenerated(ast, function(node, type) {
++    traverse(ast, function(node, type) {
+       if (type == 'do' && neededDos.indexOf(node) < 0) {
+         assert(jsonCompare(node[1], ['num', 0]), 'Trying to remove a one-time do loop that is not one of our generated ones.;');
+         more = true;
+@@ -1407,7 +1385,7 @@ function denormalizeAsm(func, data) {
+ //       we still need the eliminator? Closure? And in what order? Perhaps just
+ //       closure simple?
+ function registerize(ast) {
+-  traverseGeneratedFunctions(ast, function(fun) {
++  traverseFunctions(ast, function(fun) {
+     if (asm) var asmData = normalizeAsm(fun);
+     // Add parameters as a first (fake) var (with assignment), so they get taken into consideration
+     var params = {}; // note: params are special, they can never share a register between them (see later)
+@@ -1671,7 +1649,7 @@ var ABORTING_ELIMINATOR_SCAN_NODES = set('new', 'object', 'function', 'defun', '
+ 
+ function eliminate(ast, memSafe) {
+   // Find variables that have a single use, and if they can be eliminated, do so
+-  traverseGeneratedFunctions(ast, function(func, type) {
++  traverseFunctions(ast, function(func, type) {
+     if (asm) var asmData = normalizeAsm(func);
+     //printErr('eliminate in ' + func[1]);
+ 
+@@ -2218,9 +2196,6 @@ var passes = {
+ var src = read(arguments_[0]);
+ var ast = srcToAst(src);
+ //printErr(JSON.stringify(ast)); throw 1;
+-var metadata = src.split('\n').filter(function(line) { return line.indexOf(GENERATED_FUNCTIONS_MARKER) >= 0 })[0];
+-//assert(metadata, 'Must have EMSCRIPTEN_GENERATED_FUNCTIONS metadata');
+-if (metadata) setGeneratedFunctions(metadata);
+ 
+ arguments_.slice(1).forEach(function(arg) {
+   passes[arg](ast);
+diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py
+index 2fd2211..a253afb 100644
+--- a/tools/js_optimizer.py
++++ b/tools/js_optimizer.py
+@@ -41,17 +41,17 @@ def run_on_js(filename, passes, js_engine, jcache):
+   if os.linesep != '\n':
+     js = js.replace(os.linesep, '\n') # we assume \n in the splitting code
+ 
+-  # Find suffix
+-  suffix_marker = '// EMSCRIPTEN_GENERATED_FUNCTIONS'
+-  suffix_start = js.find(suffix_marker)
+-  suffix = ''
+-  if suffix_start >= 0:
+-    suffix = js[suffix_start:js.find('\n', suffix_start)] + '\n'
+-    # if there is metadata, we will run only on the generated functions. If there isn't, we will run on everything.
+-    generated = set(eval(suffix[len(suffix_marker)+1:]))
+-
+-  if not suffix and jcache:
+-    # JCache cannot be used without metadata, since it might reorder stuff, and that's dangerous since only generated can be reordered
++  # Find markers
++  start_marker = '// EMSCRIPTEN_START_FUNCS\n'
++  end_marker = '// EMSCRIPTEN_END_FUNCS\n'
++  start = js.find(start_marker)
++  end = js.find(end_marker)
++  assert (start >= 0) == (end >= 0), 'must have both markers or neither'
++  have_markers = start >= 0
++  # if there are markers, we will run only on the generated functions. If there isn't, we will run on everything.
++
++  if not have_markers and jcache:
++    # JCache cannot be used without markers, since it might reorder stuff, and that's dangerous since only generated can be reordered
+     # This means jcache does not work after closure compiler runs, for example. But you won't get much benefit from jcache with closure
+     # anyhow (since closure is likely the longest part of the build).
+     if DEBUG: print >>sys.stderr, 'js optimizer: no metadata, so disabling jcache'
+@@ -59,27 +59,10 @@ def run_on_js(filename, passes, js_engine, jcache):
+ 
+   # If we process only generated code, find that and save the rest on the side
+   func_sig = re.compile('( *)function (_[\w$]+)\(')
+-  if suffix:
+-    pos = 0
+-    gen_start = 0
+-    gen_end = 0
+-    while 1:
+-      m = func_sig.search(js, pos)
+-      if not m: break
+-      pos = m.end()
+-      indent = m.group(1)
+-      ident = m.group(2)
+-      if ident in generated:
+-        if not gen_start:
+-          gen_start = m.start()
+-          assert gen_start
+-        gen_end = js.find('\n%s}\n' % indent, m.end()) + (3 + len(indent))
+-    assert gen_end > gen_start
+-    pre = js[:gen_start]
+-    post = js[gen_end:]
+-    if 'last' in passes:
+-      post = post.replace(suffix, '') # no need to write out the metadata - nothing after us needs it
+-    js = js[gen_start:gen_end]
++  if have_markers:
++    pre = js[:start + len(start_marker)] # includes start marker
++    post = js[end:] # includes end marker
++    js = js[start + len(start_marker):end]
+   else:
+     pre = ''
+     post = ''
+@@ -95,7 +78,7 @@ def run_on_js(filename, passes, js_engine, jcache):
+     if m:
+       ident = m.group(2)
+     else:
+-      if suffix: continue # ignore whitespace
++      if have_markers: continue # ignore whitespace
+       ident = 'anon_%d' % i
+     assert ident
+     funcs.append((ident, func))
+@@ -131,7 +114,6 @@ def run_on_js(filename, passes, js_engine, jcache):
+       temp_file = temp_files.get('.jsfunc_%d.js' % i).name
+       f = open(temp_file, 'w')
+       f.write(chunk)
+-      f.write(suffix)
+       f.close()
+       return temp_file
+     filenames = [write_chunk(chunks[i], i) for i in range(len(chunks))]
+@@ -169,7 +151,6 @@ def run_on_js(filename, passes, js_engine, jcache):
+       f.write(cached); # TODO: preserve order
+       f.write('\n')
+   f.write(post);
+-  # No need to write suffix: if there was one, it is inside post which exists when suffix is there
+   f.write('\n')
+   f.close()
+ 

data/modules/emscripten/src/experimental/stringCache.diff

@@ -0,0 +1,147 @@
+diff --git a/src/library_gl.js b/src/library_gl.js
+index 7471578..9228964 100644
+--- a/src/library_gl.js
++++ b/src/library_gl.js
+@@ -1256,28 +1256,28 @@ var LibraryGL = {
+ 
+     setClientAttribute: function(name, size, type, stride, pointer) {
+       var attrib = this.clientAttributes[GL.immediate.ATTRIBUTE_BY_NAME[name]];
+       attrib.size = size;
+       attrib.type = type;
+       attrib.stride = stride;
+       attrib.pointer = pointer;
+-      attrib.name = name + size;
++      attrib.name = Runtime.getStringConcat(name, size);
+     },
+ 
+     // Renderers
+     addRendererComponent: function(component) {
+       if (this.rendererComponents[component]) return;
+       this.rendererComponents[component] = 1;
+-      this.renderer += component;
++      this.renderer = Runtime.getStringConcat(this.renderer, component);
+     },
+ 
+     setRenderer: function(renderer) {
+       var name = renderer;
+       if (GL.currProgram && renderer[0] != 'U') {
+-        name = 'UD' + GL.currProgram + '|' + renderer; // user-defined program renderer
++        name = Runtime.getStringConcat(Runtime.getStringConcat('UD', GL.currProgram), Runtime.getStringConcat('|', renderer)); // user-defined program renderer
+       }
+       this.renderer = name;
+       if (this.renderers[name]) return this.renderers[name];
+       this.renderers[name] = this.createRenderer(renderer);
+       return this.renderers[name];
+     },
+ 
+@@ -1300,15 +1300,18 @@ var LibraryGL = {
+           }
+           vertexSize += size * 4; // XXX assuming float
+         } else if (which == 'N') {
+           vertexSize += 4; // 1 char, + alignment
+         } else if (which == 'C') {
+           vertexSize += 4; // Up to 4 chars, + alignment
+         } else {
+-          console.log('Warning: Ignoring renderer attribute ' + which);
++#if ASSERTIONS
++          console.log('Warning: Ignoring renderer attribute');
++          console.log(which);
++#endif
+           size = parseInt(renderer[i+1]);
+           vertexSize += size * 4; // XXX assuming float
+         }
+       }
+       assert(positionSize > 0);
+       // TODO: verify vertexSize is equal to the stride in enabled client arrays
+       var useCurrProgram = !!GL.currProgram;
+@@ -1465,30 +1468,30 @@ var LibraryGL = {
+       var renderer = '', bytes = 0;
+       for (var i = 0; i < attributes.length; i++) {
+         var attribute = attributes[i];
+         if (!attribute) break;
+         attribute.offset = attribute.pointer - start;
+         if (attribute.offset > bytes) { // ensure we start where we should
+           assert((attribute.offset - bytes)%4 == 0); // XXX assuming 4-alignment
+-          renderer += '?' + ((attribute.offset - bytes)/4);
++          renderer = Runtime.getStringConcat(renderer, Runtime.getStringConcat('?', ((attribute.offset - bytes)/4)));
+           bytes += attribute.offset - bytes;
+         }
+-        renderer += attribute.name;
++        renderer = Runtime.getStringConcat(renderer, attribute.name);
+         bytes += attribute.size * GL.immediate.byteSizeByType[attribute.type];
+         if (bytes % 4 != 0) bytes += 4 - (bytes % 4); // XXX assuming 4-alignment
+ #if ASSERTIONS
+         assert(0 <= attribute.offset && attribute.offset < stride); // must all be in the same buffer
+ #endif
+       }
+ 
+       assert(stride == 0 || bytes <= stride);
+ 
+       if (bytes < stride) { // ensure the size is that of the stride
+         assert((stride - bytes)%4 == 0); // assuming float
+-        renderer += '?' + ((stride-bytes)/4);
++        renderer = Runtime.getStringConcat(renderer, Runtime.getStringConcat('?', ((stride-bytes)/4)));
+         bytes = stride;
+       }
+ 
+       bytes *= count;
+       if (!GL.currArrayBuffer) {
+         GL.immediate.vertexData = {{{ makeHEAPView('F32', 'start', 'start + bytes') }}}; // XXX assuming float
+       }
+@@ -1671,15 +1674,15 @@ var LibraryGL = {
+   },
+ 
+   glVertexPointer__deps: ['$GLEmulation'], // if any pointers are used, glVertexPointer must be, and if it is, then we need emulation
+   glVertexPointer: function(size, type, stride, pointer) {
+     GL.immediate.setClientAttribute('V', size, type, stride, pointer);
+   },
+   glTexCoordPointer: function(size, type, stride, pointer) {
+-    GL.immediate.setClientAttribute('T' + GL.immediate.clientActiveTexture, size, type, stride, pointer);
++    GL.immediate.setClientAttribute(Runtime.getStringConcat('T', GL.immediate.clientActiveTexture), size, type, stride, pointer);
+   },
+   glNormalPointer: function(type, stride, pointer) {
+     GL.immediate.setClientAttribute('N', 1, type, stride, pointer);
+   },
+   glColorPointer: function(size, type, stride, pointer) {
+     GL.immediate.setClientAttribute('C', size, type, stride, pointer);
+   },
+diff --git a/src/runtime.js b/src/runtime.js
+index 6a251c4..012a66d 100644
+--- a/src/runtime.js
++++ b/src/runtime.js
+@@ -319,25 +319,34 @@ var Runtime = {
+     if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+     if (!Runtime.warnOnce.shown[text]) {
+       Runtime.warnOnce.shown[text] = 1;
+       Module.printErr(text);
+     }
+   },
+ 
++  // Cache for JS function wrappers for C functions in FUNCTION_TABLE
+   funcWrappers: {},
+-
+   getFuncWrapper: function(func) {
+     if (!Runtime.funcWrappers[func]) {
+       Runtime.funcWrappers[func] = function() {
+         FUNCTION_TABLE[func].apply(null, arguments);
+       };
+     }
+     return Runtime.funcWrappers[func];
+   },
+ 
++  // Cache for small recurring strings generated by concatenating other
++  // strings, use this to avoid needless allocation and collection
++  stringCache: {},
++  getStringConcat: function(a, b) {
++    var cacheItem = Runtime.stringCache[a];
++    if (!cacheItem) cacheItem = Runtime.stringCache[a] = {};
++    return cacheItem[b] || (cacheItem[b] = a + b);
++  },
++
+ #if RUNTIME_DEBUG
+   debug: true, // Switch to false at runtime to disable logging at the right times
+ 
+   printObjectList: [],
+ 
+   prettyPrint: function(arg) {
+     if (typeof arg == 'undefined') return '!UNDEFINED!';