~ubuntu-branches/ubuntu/vivid/emscripten/vivid

var INDENTATION = ' ';

 

var functionStubSigs = {};

 

    var shellFile = SHELL_FILE ? SHELL_FILE : (BUILD_AS_SHARED_LIB || SIDE_MODULE ? 'shell_sharedlib.js' : 'shell.js');

      print(processMacros(preprocess(shellParts[0])));

      var preFile = BUILD_AS_SHARED_LIB || SIDE_MODULE ? 'preamble_sharedlib.js' : 'preamble.js';

      // Populate implementedFunctions. Note that this is before types, and will be updated later.

        assert(!(BUILD_AS_SHARED_LIB || SIDE_MODULE), 'Cannot have both INCLUDE_FULL_LIBRARY and BUILD_AS_SHARED_LIB/SIDE_MODULE set.')

        item.JS = '\n/* global initializers */ __ATINIT__.push(' +

                    item.ctors.map(function(ctor) { return '{ func: function() { ' + ctor + '() } }' }).join(',') +

                  ');\n';

        item.JS = makeGlobalDef(item.ident);

 

      Variables.globals[item.ident].named = item.named;

 

      if (ASM_JS && (MAIN_MODULE || SIDE_MODULE) && !item.private_ && !NAMED_GLOBALS && isIndexableGlobal(item.ident)) {

        // We need this to be named (and it normally would not be), so that it can be linked to and used from other modules

        Variables.globals[item.ident].linkable = 1;

      }

 

      if (isBSS(item)) {

        var length = calcAllocatedSize(item.type);

        length = Runtime.alignMemory(length);

 

        // If using indexed globals, go ahead and early out (no need to explicitly

        // initialize).

        if (!NAMED_GLOBALS) {

          return ret;

        }

        // If using named globals, we can at least shorten the call to allocate by

        // passing an integer representing the size of memory to alloc instead of

        // an array of 0s of size length.

        else {

          constant = length;

        }

      } else {

        if (item.external) {

          if (Runtime.isNumberType(item.type) || isPointerType(item.type)) {

            constant = zeros(Runtime.getNativeFieldSize(item.type));

          } else {

            constant = makeEmptyStruct(item.type);

          }

          constant = parseConst(item.value, item.type, item.ident);

        }

        assert(typeof constant === 'object');//, [typeof constant, JSON.stringify(constant), item.external]);

 

        // This is a flattened object. We need to find its idents, so they can be assigned to later

        var structTypes = null;

        constant.forEach(function(value, i) {

          if (needsPostSet(value)) { // ident, or expression containing an ident

            if (!structTypes) structTypes = generateStructTypes(item.type);

            ret.push({

              intertype: 'GlobalVariablePostSet',

              JS: makeSetValue(makeGlobalUse(item.ident), i, value, structTypes[i], false, true) + ';' // ignore=true, since e.g. rtti and statics cause lots of safe_heap errors

            });

            constant[i] = '0';

          }

        });

 

        if (item.external) {

          // External variables in shared libraries should not be declared as

          // they would shadow similarly-named globals in the parent, so do nothing here.

          if (BUILD_AS_SHARED_LIB) return ret;

          if (SIDE_MODULE) return [];

          // Library items need us to emit something, but everything else requires nothing.

          if (!LibraryManager.library[item.ident.slice(1)]) return ret;

        }

 

        // ensure alignment

        constant = constant.concat(zeros(Runtime.alignMemory(constant.length) - constant.length));

 

        // Special case: class vtables. We make sure they are null-terminated, to allow easy runtime operations

        if (item.ident.substr(0, 5) == '__ZTV') {

          constant = constant.concat(zeros(Runtime.alignMemory(QUANTUM_SIZE)));

        }

      if (!ASM_JS && NAMED_GLOBALS && (EXPORT_ALL || (item.ident in EXPORTED_GLOBALS))) {

      if ((MAIN_MODULE || SIDE_MODULE) && isFunctionType(item.type)) {

        var target = item.value.ident;

        if (!Functions.aliases[target]) Functions.aliases[target] = [];

        Functions.aliases[target].push(item.ident);

      // 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);

      }

 

        if (postset && !addedLibraryItems[postsetId] && !SIDE_MODULE) {

        if (SIDE_MODULE) return ';'; // we import into the side module js library stuff from the outside parent 

      if (DLOPEN_SUPPORT) Functions.getIndex(func.ident);

 

        func.JS += INDENTATION + 'PGOMonitor.called["' + func.ident + '"] = 1;\n';

          func.JS += INDENTATION + param.ident + ' = ' + asmCoercion(param.ident, param.type) + ';\n';

            func.JS += INDENTATION + 'var ' + chunks[i].map(function(v) {

        func.JS += INDENTATION + 'var label = 0;\n';

          func.JS += INDENTATION + 'var tempParam = 0;\n';

      if (func.hasVarArgsCall) {

        func.JS += INDENTATION + 'var tempVarArgs = 0;\n';

      }

 

      func.JS += INDENTATION + RuntimeGenerator.stackEnter(func.initialStack, func.otherStackAllocations) + ';\n';

          func.JS += INDENTATION + (ASM_JS ? '' : 'var ') + 'tempParam = ' + param.ident + '; ' + param.ident + ' = ' + RuntimeGenerator.stackAlloc(typeInfo.flatSize) + ';' +

            // invoke instructions span two lines, and the debug info is located

            // on the second line, hence the +1

            return JS + (Debugging.on ? Debugging.getComment(line.lineNum + (line.intertype === 'invoke' ? 1 : 0)) : '');

              return indent + INDENTATION + 'case ' + getLabelId(label.ident) + ': ' + (SHOW_LABELS ? '// ' + getOriginalLabelId(label.ident) : '') + '\n'

                            + getLabelLines(label, indent + INDENTATION + INDENTATION);

              ret += INDENTATION + 'case ' + SETJMP_LABEL + ': ';

            if (ASSERTIONS) ret += indent + INDENTATION + 'default: assert(0' + (ASM_JS ? '' : ', "bad label: " + label') + ');\n';

            var last = label.lines[label.lines.length-1];

            if (!last.signedIdent) {

              blockMap[label.ident] = Relooper.addBlock(content);

            } else {

              assert(last.intertype == 'switch');

              blockMap[label.ident] = Relooper.addBlock(content, last.signedIdent);

            }

      func.JS += walkBlock(func.block, INDENTATION);

        if (returns == 0) func.JS += INDENTATION + 'return ' + asmCoercion('0', func.returnType);

 

      if (MAIN_MODULE || SIDE_MODULE) {

        // Clone the function for each of its aliases. We do not know which name it will be used by in another module,

        // and we do not have a heavyweight metadata system to resolve aliases during linking

        var aliases = Functions.aliases[func.ident];

        if (aliases) {

          var body = func.JS.substr(func.JS.indexOf('('));

          aliases.forEach(function(alias) {

            func.JS += '\n' + 'function ' + alias + body;

          });

        }

      }

 

    // use a switch if the range is not too big or sparse

    var minn = Infinity, maxx = -Infinity;

    item.switchLabels.forEach(function(switchLabel) {

      var curr = Math.abs(parseInt(switchLabel.value));

      minn = Math.min(minn, curr);

      maxx = Math.max(maxx, curr);

    });

    var range = maxx - minn;

    var useIfs = (item.switchLabels.length+1) < 6 || range > 10*1024 || (range/item.switchLabels.length) > 1024; // heuristics

    if (VERBOSE && useIfs && item.switchLabels.length >= 6) {

      warn('not optimizing llvm switch into js switch because range of values is ' + range + ', density is ' + range/item.switchLabels.length);

    }

 

    signedIdent = makeSignOp(item.ident, item.type, 're'); // we need to standardize for purpose of comparison

    if (!useIfs) item.signedIdent = signedIdent;

      ret += INDENTATION + '' + phiSet + makeBranch(targetLabel, item.currLabelId || null) + '\n';

    var call_ = makeFunctionCall(item.ident, item.params, item.funcData, item.type, ASM_JS && !disabled, !!item.assignTo || !item.standalone, true);

      if (item.type != 'void') call_ = asmCoercion(call_, item.type); // ensure coercion to ffi in comma operator

      if (item.type == 'void') {

        ret = '__THREW__ = 0;' +  call_ + ';';

      } else {

        ret = '(__THREW__ = 0,' +  call_ + ');';

      }

    ret = makeVarArgsCleanup(ret);

        return '(tempValue=' + makeGetValue(param1, 0, type) + ',(' + makeGetValue(param1, 0, type) + '==(' + param2 + '|0) ? ' + asmCoercion(makeSetValue(param1, 0, param3, type, null, null, null, null, ','), 'i32') + ' : 0),tempValue)';

      return asmCoercion(getFastValue('sp', '+', item.allocatedIndex.toString()), 'i32');

    

    // store current list offset in tempInt, advance list offset by STACK_ALIGN, return list entry stored at tempInt

    return '(tempInt=' + makeGetValue(ident, Runtime.QUANTUM_SIZE, '*') + ',' +

                         makeSetValue(ident, Runtime.QUANTUM_SIZE, 'tempInt + ' + move, '*') + ',' +

  function makeFunctionCall(ident, params, funcData, type, forceByPointer, hasReturn, invoke) {

    var extCall = false;

 

    if (ASM_JS && DLOPEN_SUPPORT && !invoke && !funcData.setjmpTable) extCall = true; // go out, to be able to access other modules TODO: optimize

      if (shortident in Functions.libraryFunctions || simpleIdent in Functions.libraryFunctions || byPointerForced || invoke || extCall || funcData.setjmpTable) {

      funcData.hasVarArgsCall = true;

      varargs = '(tempVarArgs=' + RuntimeGenerator.stackAlloc(varargs.length, ',') + ',' +

                    ret = makeSetValue(getFastValue('tempVarArgs', '+', offset), 0, arg, type, null, null, Runtime.STACK_ALIGN, null, ',');

                    ret = makeCopyValues(getFastValue('tempVarArgs', '+', offset), arg, size, null, null, varargsByVals[i], ',');

                }).join(',') + ',tempVarArgs)';

    if (ASM_JS && ident.indexOf('llvm_') >= 0) {

      // remove unneeded arguments in llvm intrinsic functions, which the asm sig can show us. this lets us alias memset with llvm.memset, we just

    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 numArgs = Functions.implementedFunctions[callIdent].length - 1;

      if (numArgs !== args.length) {

        if (VERBOSE) warnOnce('Fixing function call arguments based on signature, on ' + [callIdent, args.length, numArgs]);

        while (args.length > numArgs) { args.pop(); argsTypes.pop() }

        while (args.length < numArgs) { args.push('0'); argsTypes.push('i32') }

      }

    }

 

    var returnType = 'void';

    if ((byPointer || ASM_JS) && hasReturn) {

      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]);

        if (trueType !== returnType && !isIdenticallyImplemented(trueType, returnType)) {

          if (VERBOSE) warnOnce('Fixing function call based on return type from signature, on ' + [callIdent, returnType, trueType]);

          returnType = trueType;

        }

      }

        Functions.neededTables[sig] = 1;

        var functionTableCall = !byPointerForced && !funcData.setjmpTable && !invoke && !extCall;

        if (functionTableCall) {

          // This is a call through an invoke_* or extCall, either a forced one, or a setjmp-required one

          args.unshift(byPointerForced ? Functions.getIndex(callIdent, sig) : asmCoercion(callIdent, 'i32'));

          callIdent = (extCall ? 'extCall' : 'invoke') + '_' + sig;

      if (!ASM_JS || functionTableCall) callIdent = Functions.getTable(sig) + '[' + callIdent + ']';

 

  function makeVarArgsCleanup(js) {

    if (js.indexOf('(tempVarArgs=') >= 0) {

      if (js[js.length-1] == ';') {

        return js + ' STACKTOP=tempVarArgs;';

      } else {

        assert(js.indexOf(';') < 0);

        return '((' + js + '), STACKTOP=tempVarArgs)';

      }

    }

    return js;

  }

 

    var ret = makeFunctionCall(item.ident, item.params, item.funcData, item.type, false, !!item.assignTo || !item.standalone) + (item.standalone ? ';' : '');

    return makeVarArgsCleanup(ret);

      if (phase == 'pre' && !Variables.generatedGlobalBase && !BUILD_AS_SHARED_LIB) {

        assert((TARGET_LE32 && Runtime.GLOBAL_BASE == 8) || (TARGET_X86 && Runtime.GLOBAL_BASE == 4)); // this is assumed in e.g. relocations for linkable modules

        if (!SIDE_MODULE) {

          print('STATIC_BASE = ' + Runtime.GLOBAL_BASE + ';\n');

          print('STATICTOP = STATIC_BASE + ' + Runtime.alignMemory(Variables.nextIndexedOffset) + ';\n');

        } else {

          print('H_BASE = parentModule["_malloc"](' + Runtime.alignMemory(Variables.nextIndexedOffset) + ' + Runtime.GLOBAL_BASE);\n');

          print('// STATICTOP = STATIC_BASE + ' + Runtime.alignMemory(Variables.nextIndexedOffset) + ';\n'); // comment as metadata only

        }

      print(generated.map(function(item) { return item.JS; }).join('\n'));

          print('/* memory initializer */ ' + makePointer(memoryInitialization, null, 'ALLOC_NONE', 'i8', 'Runtime.GLOBAL_BASE' + (SIDE_MODULE ? '+H_BASE' : ''), true));

        // 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.

          if (!BUILD_AS_SHARED_LIB && !SIDE_MODULE) {

            print('var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);\n');

            print('assert(tempDoublePtr % 8 == 0);\n');

            print('function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much\n');

            print('  HEAP8[tempDoublePtr] = HEAP8[ptr];\n');

            print('  HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];\n');

            print('  HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];\n');

            print('  HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];\n');

            print('}\n');

            print('function copyTempDouble(ptr) {\n');

            print('  HEAP8[tempDoublePtr] = HEAP8[ptr];\n');

            print('  HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];\n');

            print('  HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];\n');

            print('  HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];\n');

            print('  HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];\n');

            print('  HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];\n');

            print('  HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];\n');

            print('  HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];\n');

            print('}\n');

          }

      if (!BUILD_AS_SHARED_LIB && !SIDE_MODULE) {

        print('STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);\n');

        print('staticSealed = true; // seal the static portion of memory\n');

        print('STACK_MAX = STACK_BASE + ' + TOTAL_STACK + ';\n');

        print('DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);\n');

        print('assert(DYNAMIC_BASE < TOTAL_MEMORY); // Stack must fit in TOTAL_MEMORY; allocations from here on may enlarge TOTAL_MEMORY\n');

      }

    if (abortExecution) throw 'Aborting compilation due to previous errors';

      print(read('fastLong.js'));

      assert(!ASM_JS, 'corruption checker is not compatible with asm.js');

      print(read('headlessCanvas.js'));

      print('\n');

      print(read('headless.js').replace("'%s'", "'http://emscripten.org'").replace("'?%s'", "''").replace("'?%s'", "'/'").replace('%s,', 'null,').replace('%d', '0'));

    if (PROXY_TO_WORKER) {

      print(read('proxyWorker.js'));

    }

    var postFile = BUILD_AS_SHARED_LIB || SIDE_MODULE ? 'postamble_sharedlib.js' : 'postamble.js';

    print(processMacros(preprocess(shellParts[1])));

    if (phase == 'pre') {

      // types have been parsed, so we can figure out function signatures (which can use types)

      data.unparsedFunctions.forEach(function(func) {

        Functions.implementedFunctions[func.ident] = Functions.getSignature(func.returnType, func.params.map(function(param) { return param.type }));

      });

    }

    if (phase == 'pre') {

      // ensure there is a global ctors, for runPostSets

      if ('_llvm_global_ctors' in data.globalVariables) {

        data.globalVariables._llvm_global_ctors.ctors.unshift('runPostSets'); // run postsets right before global initializers

        hasCtors = true;

      } else {

        substrate.addItems([{

          intertype: 'GlobalVariableStub',

          ident: '_llvm_global_ctors',

          type: '[1 x { i32, void ()* }]',

          ctors: ["runPostSets"],

        }], 'GlobalVariable');

      }

    }