webruby 0.2.2 → 0.2.4

data/modules/emscripten/src/analyzer.js

@@ -25,6 +25,7 @@ var SHADOW_FLIP = { i64: 'double', double: 'i64' }; //, i32: 'float', float: 'i3
 // Analyzer
 
 function analyzer(data, sidePass) {
+  //B.start('analyzer');
   var mainPass = !sidePass;
 
   var item = { items: data };
@@ -417,7 +418,7 @@ function analyzer(data, sidePass) {
                     toAdd.push({
                       intertype: 'value',
                       assignTo: element.ident,
-                      type: element.bits,
+                      type: 'i' + element.bits,
                       ident: 'tempRet' + (j - 1)
                     });
                     assert(j<10); // TODO: dynamically create more than 10 tempRet-s
@@ -1661,11 +1662,13 @@ function analyzer(data, sidePass) {
   function stackAnalyzer() {
     data.functions.forEach(function(func) {
       var lines = func.labels[0].lines;
+      var hasAlloca = false;
       for (var i = 0; i < lines.length; i++) {
         var item = lines[i];
         if (!item.assignTo || item.intertype != 'alloca' || !isNumber(item.ident)) break;
         item.allocatedSize = func.variables[item.assignTo].impl === VAR_EMULATED ?
           calcAllocatedSize(item.allocatedType)*item.ident: 0;
+        hasAlloca = true;
         if (USE_TYPED_ARRAYS === 2) {
           // We need to keep the stack aligned
           item.allocatedSize = Runtime.forceAlign(item.allocatedSize, Runtime.STACK_ALIGN);
@@ -1681,6 +1684,7 @@ function analyzer(data, sidePass) {
       }
       func.initialStack = index;
       func.otherStackAllocations = false;
+      if (func.initialStack === 0 && hasAlloca) func.otherStackAllocations = true; // a single alloca of zero still requires us to emit stack support code
       while (func.initialStack == 0) { // one-time loop with possible abort in the middle
         // If there is no obvious need for stack management, perhaps we don't need it
         // (we try to optimize that way with SKIP_STACK_IN_SMALL). However,
@@ -1761,6 +1765,7 @@ function analyzer(data, sidePass) {
   stackAnalyzer();
   relooper();
 
+  //B.stop('analyzer');
   return item;
 }
 

data/modules/emscripten/src/compiler.js

@@ -206,12 +206,12 @@ if (phase == 'pre') {
 if (VERBOSE) printErr('VERBOSE is on, this generates a lot of output and can slow down compilation');
 
 // Load struct and define information.
-try {
+//try {
   var temp = JSON.parse(read(STRUCT_INFO));
-} catch(e) {
-  printErr('cannot load struct info at ' + STRUCT_INFO + ' : ' + e + ', trying in current dir');
-  temp = JSON.parse(read('struct_info.compiled.json'));
-}
+//} catch(e) {
+//  printErr('cannot load struct info at ' + STRUCT_INFO + ' : ' + e + ', trying in current dir');
+//  temp = JSON.parse(read('struct_info.compiled.json'));
+//}
 C_STRUCTS = temp.structs;
 C_DEFINES = temp.defines;
 
@@ -224,12 +224,12 @@ load('analyzer.js');
 load('jsifier.js');
 if (phase == 'funcs' && RELOOP) { // XXX handle !singlePhase
   RelooperModule = { TOTAL_MEMORY: ceilPowerOfTwo(2*RELOOPER_BUFFER_SIZE) };
-  try {
+  //try {
     load(RELOOPER);
-  } catch(e) {
-    printErr('cannot load relooper at ' + RELOOPER + ' : ' + e + ', trying in current dir');
-    load('relooper.js');
-  }
+  //} catch(e) {
+  //  printErr('cannot load relooper at ' + RELOOPER + ' : ' + e + ', trying in current dir');
+  //  load('relooper.js');
+  //}
   assert(typeof Relooper != 'undefined');
 }
 globalEval(processMacros(preprocess(read('runtime.js'))));
@@ -267,7 +267,7 @@ function compile(raw) {
   function runPhase(currPhase) {
     //printErr('// JS compiler in action, phase ' + currPhase + typeof lines + (lines === null));
     phase = currPhase;
-    if (phase != 'pre') {
+    if (phase != 'pre' && phase != 'glue') {
       if (singlePhase) PassManager.load(read(forwardedDataFile));
 
       if (phase == 'funcs') {
@@ -285,6 +285,7 @@ function compile(raw) {
 
     //dumpInterProf();
     //printErr(phase + ' paths (fast, slow): ' + [fastPaths, slowPaths]);
+    B.print(phase);
 
     phase = null;
 
@@ -308,12 +309,20 @@ function compile(raw) {
   }
 }
 
-if (ll_file) {
-  if (ll_file.indexOf(String.fromCharCode(10)) == -1) {
-    compile(read(ll_file));
-  } else {
-    compile(ll_file); // we are given raw .ll
+B = new Benchmarker();
+
+try {
+  if (ll_file) {
+    if (phase === 'glue') {
+      compile(';');
+    } else if (ll_file.indexOf(String.fromCharCode(10)) == -1) {
+      compile(read(ll_file));
+    } else {
+      compile(ll_file); // we are given raw .ll
+    }
   }
+} catch(err) {
+  printErr('aborting from js compiler due to exception: ' + err + ' | ' + err.stack);
 }
 
 //var M = keys(tokenCacheMisses).map(function(m) { return [m, misses[m]] }).sort(function(a, b) { return a[1] - b[1] });

data/modules/emscripten/src/emrun_postjs.js

@@ -0,0 +1,20 @@
+function emrun_register_handlers() {
+  function post(msg) {
+    var http = new XMLHttpRequest();
+    http.open("POST", "stdio.html", true);
+    http.send(msg);
+  }
+  // If the address contains localhost, we can assume we're running the test runner and should post stdout logs.
+  if (document.URL.search("localhost") != -1) {
+    var emrun_http_sequence_number = 1;
+    var prevExit = Module['exit'];
+    var prevPrint = Module['print'];
+    var prevErr = Module['printErr'];
+    Module['exit'] = function emrun_exit(returncode) { post('^exit^'+returncode); prevExit(returncode); }
+    Module['print'] = function emrun_print(text) { post('^out^'+(emrun_http_sequence_number++)+'^'+text); prevPrint(text); }
+    Module['printErr'] = function emrun_printErr(text) { post('^err^'+(emrun_http_sequence_number++)+'^'+text); prevErr(text); }
+  }
+  // Notify emrun web server that this browser has successfully launched the page.
+  post('^pageload^');
+}
+emrun_register_handlers();

data/modules/emscripten/src/intertyper.js

@@ -153,6 +153,7 @@ var NSW_NUW = set('nsw', 'nuw');
 // Intertyper
 
 function intertyper(lines, sidePass, baseLineNums) {
+  //B.start('intertyper');
   var mainPass = !sidePass;
   baseLineNums = baseLineNums || [[0,0]]; // each pair [#0,#1] means "starting from line #0, the base line num is #1"
 
@@ -470,8 +471,8 @@ function intertyper(lines, sidePass, baseLineNums) {
           item.tokens[1] = item.tokens[1].tokens[0];
         }
         var subTokens = item.tokens[1].tokens;
-        if (subTokens) {
-          subTokens.push({text:','});
+        if (subTokens && subTokens.length > 0) {
+          subTokens.push({text:','}); // XXX we should avoid altering tokens like that
           while (subTokens[0]) {
             var stop = 1;
             while ([','].indexOf(subTokens[stop].text) == -1) stop ++;
@@ -523,6 +524,27 @@ function intertyper(lines, sidePass, baseLineNums) {
             }
           });
         }
+      } else if (ident == '_llvm_used') {
+        var chunk = item.tokens[1].tokens;
+        var funcs = [];
+        var part = [];
+
+        for (var i = 0; i < chunk.length; i++) {
+          if (chunk[i].text == ',') {
+            var call = parseLLVMFunctionCall(part);
+            EXPORTED_FUNCTIONS[call.ident] = 0;
+            part = [];
+          } else {
+            part.push(chunk[i]);
+          }
+        }
+        if (part.length > 0) {
+          var call = parseLLVMFunctionCall(part);
+          EXPORTED_FUNCTIONS[call.ident] = 0;
+        }
+
+        ret.type = 'i32';
+        ret.value = { intertype: 'value', ident: '0', value: '0', type: ret.type };
       } else if (!external) {
         if (item.tokens[1] && item.tokens[1].text != ';') {
           if (item.tokens[1].text == 'c') {
@@ -537,6 +559,7 @@ function intertyper(lines, sidePass, baseLineNums) {
           ret.value = { intertype: 'value', ident: '0', value: '0', type: ret.type };
         }
       }
+
       return ret;
     }
   }
@@ -615,7 +638,8 @@ function intertyper(lines, sidePass, baseLineNums) {
   // 'bitcast'
   function bitcastHandler(item) {
     item.intertype = 'bitcast';
-    item.type = item.tokens[4].text; // The final type
+    var last = getTokenIndexByText(item.tokens, ';');
+    item.type = item.tokens[Math.min(last, item.tokens.length-1)].text; // The final type
     Types.needAnalysis[item.type] = 0;
     var to = getTokenIndexByText(item.tokens, 'to');
     item.params = [parseLLVMSegment(item.tokens.slice(1, to))];
@@ -659,9 +683,10 @@ function intertyper(lines, sidePass, baseLineNums) {
     var tokensLeft = item.tokens.slice(2);
     item.ident = eatLLVMIdent(tokensLeft);
     if (item.ident == 'asm') {
+      warnOnce('inline JavaScript using asm() has some oddities due to how gcc asm() syntax works. use EM_ASM where possible (see emscripten.h)');
       if (ASM_JS) {
         Types.hasInlineJS = true;
-        warnOnce('inline JavaScript (asm, EM_ASM) will cause the code to no longer fall in the asm.js subset of JavaScript, which can reduce performance - consider using emscripten_run_script');
+        warnOnce('inline JavaScript using asm() will cause the code to no longer fall in the asm.js subset of JavaScript, which can reduce performance - consider using emscripten_run_script');
       }
       assert(TARGET_LE32, 'inline js is only supported in le32');
       // Inline assembly is just JavaScript that we paste into the code
@@ -671,15 +696,20 @@ function intertyper(lines, sidePass, baseLineNums) {
       assert((item.tokens[5].text.match(/=/g) || []).length <= 1, 'we only support at most 1 exported variable from inline js: ' + item.ident);
       var i = 0;
       var params = [], args = [];
-      splitTokenList(tokensLeft[3].tokens).map(function(element) {
-        var ident = toNiceIdent(element[1].text);
-        var type = element[0].text;
-        params.push('$' + (i++));
-        args.push(ident);
+      if (tokensLeft[3].tokens) {
+        splitTokenList(tokensLeft[3].tokens).map(function(element) {
+          var ident = toNiceIdent(element[1].text);
+          var type = element[0].text;
+          params.push('$' + (i++));
+          args.push(ident);
+        });
+      }
+      item.ident = expandLLVMString(item.ident).replace(/(#[^\n]*)/g, function(m) {
+        return '/* ' + m.substr(1) + ' */'; // fix asm comments to js comments
       });
       if (item.assignTo) item.ident = 'return ' + item.ident;
       item.ident = '(function(' + params + ') { ' + item.ident + ' })(' + args + ');';
-      return { forward: null, ret: item, item: item };
+      return { ret: item, item: item };
     } 
     if (item.ident.substr(-2) == '()') {
       // See comment in isStructType()
@@ -702,13 +732,12 @@ function intertyper(lines, sidePass, baseLineNums) {
     if (item.indent == 2) {
       // standalone call - not in assign
       item.standalone = true;
-      return { forward: null, ret: item, item: item };
+      return { ret: item, item: item };
     }
-    return { forward: item, ret: null, item: item };
+    return { ret: null, item: item };
   }
   function callHandler(item) {
     var result = makeCall.call(this, item, 'call');
-    if (result.forward) this.forwardItem(result.forward, 'Reintegrator');
     return result.ret;
   }
   function invokeHandler(item) {
@@ -718,10 +747,9 @@ function intertyper(lines, sidePass, baseLineNums) {
       finalResults.push({
         intertype: 'branch',
         label: result.item.toLabel,
-        lineNum: (result.forward ? item.parentLineNum : item.lineNum) + 0.5
+        lineNum: item.lineNum + 0.5
       });
     }
-    if (result.forward) this.forwardItem(result.forward, 'Reintegrator');
     return result.ret;
   }
   function atomicHandler(item) {
@@ -838,7 +866,7 @@ function intertyper(lines, sidePass, baseLineNums) {
       item.variant = item.tokens[1].text;
       item.tokens.splice(1, 1);
     }
-    if (item.tokens[1].text == 'exact') item.tokens.splice(1, 1); // TODO: Implement trap values
+    while (item.tokens[1].text in LLVM.MATHOP_IGNORABLES) item.tokens.splice(1, 1);
     var segments = splitTokenList(item.tokens.slice(1));
     item.params = [];
     for (var i = 1; i <= 4; i++) {
@@ -1184,6 +1212,7 @@ function intertyper(lines, sidePass, baseLineNums) {
     finalResults.push(item);
     if (item.tokens) item.tokens = null; // We do not need tokens, past the intertyper. Clean them up as soon as possible here.
   });
+  //B.stop('intertyper');
   return finalResults;
 }
 

data/modules/emscripten/src/jsifier.js

@@ -20,6 +20,7 @@ var functionStubSigs = {};
 
 // JSifier
 function JSify(data, functionsOnly, givenFunctions) {
+  //B.start('jsifier');
   var mainPass = !functionsOnly;
 
   var itemsDict = { type: [], GlobalVariableStub: [], functionStub: [], function: [], GlobalVariable: [], GlobalVariablePostSet: [] };
@@ -27,7 +28,7 @@ function JSify(data, functionsOnly, givenFunctions) {
   if (mainPass) {
     var shellFile = SHELL_FILE ? SHELL_FILE : (BUILD_AS_SHARED_LIB || SIDE_MODULE ? 'shell_sharedlib.js' : 'shell.js');
 
-    if (phase == 'pre') {
+    if (phase == 'pre' || phase == 'glue') {
       // We will start to print out the data, but must do so carefully - we are
       // dealing with potentially *huge* strings. Convenient replacements and
       // manipulations may create in-memory copies, and we may OOM.
@@ -67,9 +68,11 @@ function JSify(data, functionsOnly, givenFunctions) {
 
     // Add additional necessary items for the main pass. We can now do this since types are parsed (types can be used through
     // generateStructInfo in library.js)
+    //B.start('jsifier-libload');
     LibraryManager.load();
+    //B.stop('jsifier-libload');
 
-    if (phase == 'pre') {
+    if (phase == 'pre' || phase == 'glue') {
       var libFuncsToInclude;
       if (INCLUDE_FULL_LIBRARY) {
         assert(!(BUILD_AS_SHARED_LIB || SIDE_MODULE), 'Cannot have both INCLUDE_FULL_LIBRARY and BUILD_AS_SHARED_LIB/SIDE_MODULE set.')
@@ -471,7 +474,7 @@ function JSify(data, functionsOnly, givenFunctions) {
         }
       }
       if (SIDE_MODULE) return ';'; // we import into the side module js library stuff from the outside parent 
-      if ((!ASM_JS || phase == 'pre') &&
+      if ((!ASM_JS || phase == 'pre' || phase == 'glue') &&
           (EXPORT_ALL || (ident in EXPORTED_FUNCTIONS))) {
         contentText += '\nModule["' + ident + '"] = ' + ident + ';';
       }
@@ -487,10 +490,19 @@ function JSify(data, functionsOnly, givenFunctions) {
     } else {
       // If this is not linkable, anything not in the library is definitely missing
       var cancel = false;
+      if (item.ident in DEAD_FUNCTIONS) {
+        if (LibraryManager.library[shortident + '__asm']) {
+          warn('cannot kill asm library function ' + item.ident);
+        } else {
+          LibraryManager.library[shortident] = new Function("Module['printErr']('dead function: " + shortident + "'); abort(-1);");
+          delete LibraryManager.library[shortident + '__inline'];
+          delete LibraryManager.library[shortident + '__deps'];
+        }
+      }
       if (!LINKABLE && !LibraryManager.library.hasOwnProperty(shortident) && !LibraryManager.library.hasOwnProperty(shortident + '__inline')) {
         if (ERROR_ON_UNDEFINED_SYMBOLS) error('unresolved symbol: ' + shortident);
-        if (VERBOSE || WARN_ON_UNDEFINED_SYMBOLS) printErr('warning: unresolved symbol: ' + shortident);
-        if (ASM_JS || item.ident in DEAD_FUNCTIONS) {
+        else if (VERBOSE || WARN_ON_UNDEFINED_SYMBOLS) warn('unresolved symbol: ' + shortident);
+        if (ASM_JS) {
           // emit a stub that will fail during runtime. this allows asm validation to succeed.
           LibraryManager.library[shortident] = new Function("Module['printErr']('missing function: " + shortident + "'); abort(-1);");
         } else {
@@ -504,6 +516,7 @@ function JSify(data, functionsOnly, givenFunctions) {
   // function splitter
   function functionSplitter(item) {
     item.lines.forEach(function(line) {
+      //B.start('jsifier-handle-' + line.intertype);
       Framework.currItem = line;
       line.funcData = item; // TODO: remove all these, access it globally
       switch (line.intertype) {
@@ -538,8 +551,11 @@ function JSify(data, functionsOnly, givenFunctions) {
       //if (ASM_JS) assert(line.JS.indexOf('var ') < 0, dump(line));
       if (line.assignTo) makeAssign(line);
       Framework.currItem = null;
+      //B.stop('jsifier-handle-' + line.intertype);
     });
+    //B.start('jsifier-frec');
     functionReconstructor(item);
+    //B.stop('jsifier-frec');
   }
 
   // function for filtering functions for label debugging
@@ -749,20 +765,14 @@ function JSify(data, functionsOnly, givenFunctions) {
           if (func.setjmpTable && !ASM_JS) {
             ret += ' } catch(e) { if (!e.longjmp || !(e.id in mySetjmpIds)) throw(e); setjmpTable[setjmpLabels[e.id]](e.value) }';
           }
-          if (ASM_JS && func.returnType !== 'void') {
-            // Add a return
-            if (func.returnType in Runtime.FLOAT_TYPES) {
-              ret += ' return +0;\n';
-            } else {
-              ret += ' return 0;\n';
-            }
-          }
+          if (ASM_JS && func.returnType !== 'void') ret += '  return ' + asmInitializer(func.returnType) + ';\n'; // Add a return
         } else {
           ret += (SHOW_LABELS ? indent + '/* ' + block.entries[0] + ' */' : '') + '\n' + getLabelLines(block.labels[0]);
         }
         ret += '\n';
       } else {
         // Reloop multiple blocks using the compiled relooper
+        //B.start('jsifier-reloop');
 
         //Relooper.setDebug(1);
         Relooper.init();
@@ -812,6 +822,7 @@ function JSify(data, functionsOnly, givenFunctions) {
         }
         ret += Relooper.render(blockMap[block.entries[0]]);
         Relooper.cleanup();
+        //B.stop('jsifier-reloop');
       }
       return ret;
     }
@@ -824,11 +835,7 @@ function JSify(data, functionsOnly, givenFunctions) {
       var lastReturn = func.JS.lastIndexOf('return ');
       if ((lastCurly < 0 && lastReturn < 0) || // no control flow, no return
           (lastCurly >= 0 && lastReturn < lastCurly)) { // control flow, no return past last join
-        if (func.returnType in Runtime.FLOAT_TYPES) {
-          func.JS += ' return +0;\n';
-        } else {
-          func.JS += ' return 0;\n';
-        }
+        func.JS += '  return ' + asmInitializer(func.returnType) + ';\n';
       }
     }
     func.JS += '}\n';
@@ -939,11 +946,12 @@ function JSify(data, functionsOnly, givenFunctions) {
     }
     if (item.valueType[item.valueType.length-1] === '>') {
       // vector store TODO: move to makeSetValue?
-      var base = getVectorBaseType(item.valueType);
-      return '(' + makeSetValue(item.ident,  0, value + '.x', base, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident,  4, value + '.y', base, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident,  8, value + '.z', base, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident, 12, value + '.w', base, 0, 0, item.align) + ')';
+      var native = getVectorNativeType(item.valueType);
+      var base = getSIMDName(native);
+      return '(' + makeSetValue(item.ident,  0, value + '.x', native, 0, 0, item.align) + ',' +
+                   makeSetValue(item.ident,  4, value + '.y', native, 0, 0, item.align) + ',' +
+                   makeSetValue(item.ident,  8, value + '.z', native, 0, 0, item.align) + ',' +
+                   makeSetValue(item.ident, 12, value + '.w', native, 0, 0, item.align) + ');';
     }
     switch (impl) {
       case VAR_NATIVIZED:
@@ -1314,11 +1322,12 @@ function JSify(data, functionsOnly, givenFunctions) {
     var value = finalizeLLVMParameter(item.pointer);
     if (item.valueType[item.valueType.length-1] === '>') {
       // vector load
-      var base = getVectorBaseType(item.valueType);
-      return base + '32x4(' + makeGetValue(value,  0, base, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value,  4, base, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value,  8, base, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value, 12, base, 0, item.unsigned, 0, item.align) + ')';
+      var native = getVectorNativeType(item.valueType);
+      var base = getSIMDName(native);
+      return base + '32x4(' + makeGetValue(value,  0, native, 0, item.unsigned, 0, item.align) + ',' +
+                              makeGetValue(value,  4, native, 0, item.unsigned, 0, item.align) + ',' +
+                              makeGetValue(value,  8, native, 0, item.unsigned, 0, item.align) + ',' +
+                              makeGetValue(value, 12, native, 0, item.unsigned, 0, item.align) + ');';
     }
     var impl = item.ident ? getVarImpl(item.funcData, item.ident) : VAR_EMULATED;
     switch (impl) {
@@ -1326,7 +1335,7 @@ function JSify(data, functionsOnly, givenFunctions) {
         if (isNumber(item.ident)) {
           // Direct read from a memory address; this may be an intentional segfault, if not, it is a bug in the source
           if (ASM_JS) {
-            return asmCoercion('abort(' + item.ident + ')', item.type);
+            return asmFFICoercion('abort(' + item.ident + ')', item.type);
           } else {
             item.assignTo = null;
             return 'throw "fault on read from ' + item.ident + '";';
@@ -1364,8 +1373,9 @@ function JSify(data, functionsOnly, givenFunctions) {
   function insertelementHandler(item) {
     var base = getVectorBaseType(item.type);
     var ident = ensureVector(item.ident, base);
+    var laneOp = ((base == 'float') ? 'SIMD.float32x4.with' : 'SIMD.int32x4.with');
     //return ident + '.with' + SIMDLane[finalizeLLVMParameter(item.index)] + '(' + finalizeLLVMParameter(item.value) + ')';
-    return 'SIMD.with' + SIMDLane[finalizeLLVMParameter(item.index)] + '(' + ident + ',' + finalizeLLVMParameter(item.value) + ')';
+    return laneOp + SIMDLane[finalizeLLVMParameter(item.index)] + '(' + ident + ',' + finalizeLLVMParameter(item.value) + ')';
   }
   function extractelementHandler(item) {
     var base = getVectorBaseType(item.type);
@@ -1480,7 +1490,7 @@ function JSify(data, functionsOnly, givenFunctions) {
     }
 
     params.forEach(function(param, i) {
-      var val = finalizeParam(param);
+      var val = finalizeLLVMParameter(param);
       if (!hasVarArgs || useJSArgs || i < normalArgs) {
         args.push(val);
         argsTypes.push(param.type);
@@ -1503,8 +1513,10 @@ function JSify(data, functionsOnly, givenFunctions) {
 
     args = args.map(function(arg, i) { return indexizeFunctions(arg, argsTypes[i]) });
     if (ASM_JS) {
-      if (shortident in Functions.libraryFunctions || simpleIdent in Functions.libraryFunctions || byPointerForced || invoke || extCall || funcData.setjmpTable) {
-        args = args.map(function(arg, i) { return asmCoercion(arg, argsTypes[i]) });
+      var ffiCall = (shortident in Functions.libraryFunctions || simpleIdent in Functions.libraryFunctions || byPointerForced || invoke || extCall || funcData.setjmpTable) &&
+                    !(simpleIdent in JS_MATH_BUILTINS);
+      if (ffiCall) {
+        args = args.map(function(arg, i) { return asmCoercion(arg, ensureValidFFIType(argsTypes[i])) });
       } else {
         args = args.map(function(arg, i) { return asmEnsureFloat(arg, argsTypes[i]) });
       }
@@ -1581,7 +1593,7 @@ function JSify(data, functionsOnly, givenFunctions) {
       returnType = getReturnType(type);
       if (callIdent in Functions.implementedFunctions) {
         // LLVM sometimes bitcasts for no reason. We must call using the exact same type as the actual function is generated as
-        var trueType = Functions.getSignatureReturnType(Functions.implementedFunctions[callIdent]);
+        var trueType = Functions.getSignatureType(Functions.implementedFunctions[callIdent][0]);
         if (trueType !== returnType && !isIdenticallyImplemented(trueType, returnType)) {
           if (VERBOSE) warnOnce('Fixing function call based on return type from signature, on ' + [callIdent, returnType, trueType]);
           returnType = trueType;
@@ -1592,6 +1604,15 @@ function JSify(data, functionsOnly, givenFunctions) {
       }
     }
 
+    // we alias llvm memset and such to normal memset. The target has a return value, while the original
+    // does not, so we need to fix that for the actual call target
+    if (ASM_JS) {
+      var sig = LibraryManager.library[simpleIdent + '__sig'];
+      if (sig && sig[0] !== 'v') {
+        returnType = Functions.getSignatureType(sig[0]);
+      }
+    }
+
     if (byPointer) {
       var sig = Functions.getSignature(returnType, argsTypes, hasVarArgs);
       if (ASM_JS) {
@@ -1617,7 +1638,11 @@ function JSify(data, functionsOnly, givenFunctions) {
 
     var ret = callIdent + '(' + args.join(',') + ')';
     if (ASM_JS) { // TODO: do only when needed (library functions and Math.*?) XXX && simpleIdent in Functions.libraryFunctions) {
-      ret = asmCoercion(ret, returnType);
+      if (ffiCall) {
+        ret = asmFFICoercion(ret, returnType);
+      } else {
+        ret = asmCoercion(ret, returnType);
+      }
       if (simpleIdent == 'abort' && funcData.returnType != 'void') {
         ret += '; return ' + asmCoercion('0', funcData.returnType); // special case: abort() can happen without return, breaking the return type of asm functions. ensure a return
       }
@@ -1689,7 +1714,7 @@ function JSify(data, functionsOnly, givenFunctions) {
     //
 
     if (!mainPass) {
-      if (phase == 'pre' && !Variables.generatedGlobalBase && !BUILD_AS_SHARED_LIB) {
+      if ((phase == 'pre' || phase == 'glue') && !Variables.generatedGlobalBase && !BUILD_AS_SHARED_LIB) {
         Variables.generatedGlobalBase = true;
         // Globals are done, here is the rest of static memory
         assert((TARGET_LE32 && Runtime.GLOBAL_BASE == 8) || (TARGET_X86 && Runtime.GLOBAL_BASE == 4)); // this is assumed in e.g. relocations for linkable modules
@@ -1704,7 +1729,7 @@ function JSify(data, functionsOnly, givenFunctions) {
       var generated = itemsDict.function.concat(itemsDict.type).concat(itemsDict.GlobalVariableStub).concat(itemsDict.GlobalVariable);
       print(generated.map(function(item) { return item.JS; }).join('\n'));
 
-      if (phase == 'pre') {
+      if (phase == 'pre' || phase == 'glue') {
         if (memoryInitialization.length > 0) {
           // apply postsets directly into the big memory initialization
           itemsDict.GlobalVariablePostSet = itemsDict.GlobalVariablePostSet.filter(function(item) {
@@ -1727,15 +1752,17 @@ function JSify(data, functionsOnly, givenFunctions) {
           });
           // write out the singleton big memory initialization value
           print('/* memory initializer */ ' + makePointer(memoryInitialization, null, 'ALLOC_NONE', 'i8', 'Runtime.GLOBAL_BASE' + (SIDE_MODULE ? '+H_BASE' : ''), true));
-        } else {
+        } else if (phase !== 'glue') {
           print('/* no memory initializer */'); // test purposes
         }
 
-        // Define postsets. These will be run in ATINIT, right before global initializers (which might need the postsets). We cannot
-        // run them now because the memory initializer might not have been applied yet.
-        print('function runPostSets() {\n');
-        print(itemsDict.GlobalVariablePostSet.map(function(item) { return item.JS }).join('\n'));
-        print('}\n');
+        if (phase !== 'glue') {
+          // Define postsets. These will be run in ATINIT, right before global initializers (which might need the postsets). We cannot
+          // run them now because the memory initializer might not have been applied yet.
+          print('function runPostSets() {\n');
+          print(itemsDict.GlobalVariablePostSet.map(function(item) { return item.JS }).join('\n'));
+          print('}\n');
+        }
 
         if (USE_TYPED_ARRAYS == 2) {
           if (!BUILD_AS_SHARED_LIB && !SIDE_MODULE) {
@@ -1765,7 +1792,7 @@ function JSify(data, functionsOnly, givenFunctions) {
     }
 
     // Print out global variables and postsets TODO: batching
-    if (phase == 'pre') {
+    if (phase == 'pre' || phase == 'glue') {
       var legalizedI64sDefault = legalizedI64s;
       legalizedI64s = false;
 
@@ -1832,10 +1859,10 @@ function JSify(data, functionsOnly, givenFunctions) {
         // first row are utilities called from generated code, second are needed from fastLong
         ['i64Add', 'i64Subtract', 'bitshift64Shl', 'bitshift64Lshr', 'bitshift64Ashr',
          'llvm_ctlz_i32', 'llvm_cttz_i32'].forEach(function(func) {
-          if (!Functions.libraryFunctions[func]) {
+          if (!Functions.libraryFunctions[func] || (phase == 'glue' && func[0] === 'l' && !addedLibraryItems[func])) { // TODO: one-by-one in fastcomp glue mode
             print(processLibraryFunction(LibraryManager.library[func], func)); // must be first to be close to generated code
             Functions.implementedFunctions['_' + func] = LibraryManager.library[func + '__sig'];
-            Functions.libraryFunctions[func] = 1;
+            Functions.libraryFunctions[func] = phase == 'glue' ? 2 : 1; // XXX
             // limited dependency handling
             var deps = LibraryManager.library[func + '__deps'];
             if (deps) {
@@ -1910,8 +1937,6 @@ function JSify(data, functionsOnly, givenFunctions) {
     }
 
     PassManager.serialize();
-
-    return null;
   }
 
   // Data
@@ -1941,13 +1966,18 @@ function JSify(data, functionsOnly, givenFunctions) {
       }
     }
 
+    //B.start('jsifier-handle-gv');
     sortGlobals(data.globalVariables).forEach(globalVariableHandler);
+    //B.stop('jsifier-handle-gv');
     data.aliass.forEach(aliasHandler);
     data.functions.forEach(functionSplitter);
   }
 
+  //B.start('jsifier-fc');
   finalCombiner();
+  //B.stop('jsifier-fc');
 
   dprint('framework', 'Big picture: Finishing JSifier, main pass=' + mainPass);
+  //B.stop('jsifier');
 }