Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/LowerEmAsyncify.cpp

 //===- LowerEmAsyncify - transform asynchronous functions for Emscripten/JS   -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Lu Wang <coolwanglu@gmail.com>
@@ skipping 49 matching lines @@
     Module *TheModule;
 
   public:
     static char ID; // Pass identification, replacement for typeid
     explicit LowerEmAsyncify() : ModulePass(ID), TheModule(NULL) {
       initializeLowerEmAsyncifyPass(*PassRegistry::getPassRegistry());
     }
     virtual ~LowerEmAsyncify() { }
     bool runOnModule(Module &M);
 
-    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addRequired<DataLayoutPass>();
-      ModulePass::getAnalysisUsage(AU);
-    }
-
   private:
     const DataLayout *DL;
 
     Type *Void, *I1, *I32, *I32Ptr;
     FunctionType *VFunction, *I1Function, *I32PFunction;
     FunctionType *VI32PFunction, *I32PI32Function;
     FunctionType *CallbackFunctionType;
 
     Function *AllocAsyncCtxFunction, *ReallocAsyncCtxFunction, *FreeAsyncCtxFunction;
     Function *CheckAsyncFunction;
@@ skipping 32 matching lines @@
   };
 }
 
 char LowerEmAsyncify::ID = 0;
 INITIALIZE_PASS(LowerEmAsyncify, "loweremasyncify",
     "Lower async functions for js/emscripten",
     false, false)
 
 bool LowerEmAsyncify::runOnModule(Module &M) {
   TheModule = &M;
+  DL = &M.getDataLayout();
 
   std::set<std::string> WhiteList(AsyncifyWhiteList.begin(), AsyncifyWhiteList.end());
 
   /* 
    * collect all the functions that should be asyncified
    * any function that _might_ call an async function is also async
    */
   std::vector<Function*> AsyncFunctionsPending;
   for(unsigned i = 0; i < AsyncifyFunctions.size(); ++i) {
     std::string const& AFName = AsyncifyFunctions[i];
@@ skipping 53 matching lines @@
 
   for (FunctionInstructionsMap::iterator I = AsyncFunctionCalls.begin(), E = AsyncFunctionCalls.end();
       I != E; ++I) {
     transformAsyncFunction(*(I->first), I->second);
   }
 
   return true;
 }
 
 void LowerEmAsyncify::initTypesAndFunctions(void) {
-  DL = &getAnalysis<DataLayoutPass>().getDataLayout();
-
   // Data types
   Void = Type::getVoidTy(TheModule->getContext());
   I1 = Type::getInt1Ty(TheModule->getContext());
   I32 = Type::getInt32Ty(TheModule->getContext());
   I32Ptr = Type::getInt32PtrTy(TheModule->getContext());
 
   // Function types
   SmallVector<Type*, 2> ArgTypes;
   VFunction = FunctionType::get(Void, false);
   I1Function = FunctionType::get(I1, false);
@@ skipping 218 matching lines @@
   // - retrieve the async return value and free the async context if the called function turns out to be sync
   std::vector<AsyncCallEntry> AsyncCallEntries;
   AsyncCallEntries.reserve(AsyncCalls.size());
   for (Instructions::const_iterator I = AsyncCalls.begin(), E = AsyncCalls.end(); I != E; ++I) {
     // prepare blocks
     Instruction *CurAsyncCall = *I;
 
     // The block containing the async call
     BasicBlock *CurBlock = CurAsyncCall->getParent();
     // The block should run after the async call
-    BasicBlock *AfterCallBlock = SplitBlock(CurBlock, CurAsyncCall->getNextNode(), this);
+    BasicBlock *AfterCallBlock = SplitBlock(CurBlock, CurAsyncCall->getNextNode());
     // The block where we store the context and return
     BasicBlock *SaveAsyncCtxBlock = BasicBlock::Create(TheModule->getContext(), "SaveAsyncCtx", &F, AfterCallBlock);
     // return a dummy value at the end, to make the block valid
     new UnreachableInst(TheModule->getContext(), SaveAsyncCtxBlock);
 
     // allocate the context before making the call
     // we don't know the size yet, will fix it later
     // we cannot insert the instruction later because,
     // we need to make sure that all the instructions and blocks are fixed before we can generate DT and find context variables
     // In CallHandler.h `sp` will be put as the second parameter
@@ skipping 48 matching lines @@
     CurEntry.AllocAsyncCtxInst->setOperand(0, 
         ConstantInt::get(I32, DL->getTypeStoreSize(CurEntry.ContextStructType)));
 
     // construct SaveAsyncCtxBlock
     {
       // fill in SaveAsyncCtxBlock
       // temporarily remove the terminator for convenience
       CurEntry.SaveAsyncCtxBlock->getTerminator()->eraseFromParent();
       assert(CurEntry.SaveAsyncCtxBlock->empty());
 
-      BitCastInst *AsyncCtxAddr = new BitCastInst(CurEntry.AllocAsyncCtxInst, CurEntry.ContextStructType->getPointerTo(), "AsyncCtxAddr", CurEntry.SaveAsyncCtxBlock);
+      Type *AsyncCtxAddrTy = CurEntry.ContextStructType->getPointerTo();
+      BitCastInst *AsyncCtxAddr = new BitCastInst(CurEntry.AllocAsyncCtxInst, AsyncCtxAddrTy, "AsyncCtxAddr", CurEntry.SaveAsyncCtxBlock);
       SmallVector<Value*, 2> Indices;
       // store the callback
       {
         Indices.push_back(ConstantInt::get(I32, 0));
         Indices.push_back(ConstantInt::get(I32, 0));
-        GetElementPtrInst *AsyncVarAddr = GetElementPtrInst::Create(AsyncCtxAddr, Indices, "", CurEntry.SaveAsyncCtxBlock);
+        GetElementPtrInst *AsyncVarAddr = GetElementPtrInst::Create(AsyncCtxAddrTy, AsyncCtxAddr, Indices, "", CurEntry.SaveAsyncCtxBlock);
         new StoreInst(CurEntry.CallbackFunc, AsyncVarAddr, CurEntry.SaveAsyncCtxBlock);
       }
       // store the context variables
       for (size_t i = 0; i < CurEntry.ContextVariables.size(); ++i) {
         Indices.clear();
         Indices.push_back(ConstantInt::get(I32, 0));
         Indices.push_back(ConstantInt::get(I32, i + 1)); // the 0th element is the callback function
-        GetElementPtrInst *AsyncVarAddr = GetElementPtrInst::Create(AsyncCtxAddr, Indices, "", CurEntry.SaveAsyncCtxBlock);
+        GetElementPtrInst *AsyncVarAddr = GetElementPtrInst::Create(AsyncCtxAddrTy, AsyncCtxAddr, Indices, "", CurEntry.SaveAsyncCtxBlock);
         new StoreInst(CurEntry.ContextVariables[i], AsyncVarAddr, CurEntry.SaveAsyncCtxBlock);
       }
       // to exit the block, we want to return without unwinding the stack frame
       CallInst::Create(DoNotUnwindFunction, "", CurEntry.SaveAsyncCtxBlock);
       ReturnInst::Create(TheModule->getContext(), 
           (F.getReturnType()->isVoidTy() ? 0 : Constant::getNullValue(F.getReturnType())),
           CurEntry.SaveAsyncCtxBlock);
     }
   }
 
   // Pass 3
   // now all the SaveAsyncCtxBlock's have been constructed
   // we can clone F and construct callback functions 
   // we could not construct the callbacks in Pass 2 because we need _all_ those SaveAsyncCtxBlock's appear in _each_ callback
   for (std::vector<AsyncCallEntry>::iterator EI = AsyncCallEntries.begin(), EE = AsyncCallEntries.end();  EI != EE; ++EI) {
     AsyncCallEntry & CurEntry = *EI;
 
     Function *CurCallbackFunc = CurEntry.CallbackFunc;
     ValueToValueMapTy VMap;
 
     // Add the entry block
     // load variables from the context
     // also update VMap for CloneFunction
     BasicBlock *EntryBlock = BasicBlock::Create(TheModule->getContext(), "AsyncCallbackEntry", CurCallbackFunc);
     std::vector<LoadInst *> LoadedAsyncVars;
     {
-      BitCastInst *AsyncCtxAddr = new BitCastInst(CurCallbackFunc->arg_begin(), CurEntry.ContextStructType->getPointerTo(), "AsyncCtx", EntryBlock);
+      Type *AsyncCtxAddrTy = CurEntry.ContextStructType->getPointerTo();
+      BitCastInst *AsyncCtxAddr = new BitCastInst(CurCallbackFunc->arg_begin(), AsyncCtxAddrTy, "AsyncCtx", EntryBlock);
       SmallVector<Value*, 2> Indices;
       for (size_t i = 0; i < CurEntry.ContextVariables.size(); ++i) {
         Indices.clear();
         Indices.push_back(ConstantInt::get(I32, 0));
         Indices.push_back(ConstantInt::get(I32, i + 1)); // the 0th element of AsyncCtx is the callback function
-        GetElementPtrInst *AsyncVarAddr = GetElementPtrInst::Create(AsyncCtxAddr, Indices, "", EntryBlock);
+        GetElementPtrInst *AsyncVarAddr = GetElementPtrInst::Create(AsyncCtxAddrTy, AsyncCtxAddr, Indices, "", EntryBlock);
         LoadedAsyncVars.push_back(new LoadInst(AsyncVarAddr, "", EntryBlock));
         // we want the argument to be replaced by the loaded value
         if (isa<Argument>(CurEntry.ContextVariables[i]))
           VMap[CurEntry.ContextVariables[i]] = LoadedAsyncVars.back();
       }
     }
 
     // we don't need any argument, just leave dummy entries there to cheat CloneFunctionInto
     for (Function::const_arg_iterator AI = F.arg_begin(), AE = F.arg_end(); AI != AE; ++AI) {
       if (VMap.count(AI) == 0)
@@ skipping 153 matching lines @@
   // mostly from CallHandler.h
   ImmutableCallSite CS(I);
   if (!CS) return false; // not call nor invoke
   const Value *CV = CS.getCalledValue()->stripPointerCasts();
   return !isa<const Function>(CV);
 }
 
 ModulePass *llvm::createLowerEmAsyncifyPass() {
   return new LowerEmAsyncify();
 }
-