Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/LowerEmSetjmp.cpp

 //===- LowerEmSetjmp - Lower setjmp/longjmp for Emscripten/JS   -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Lowers setjmp to a reasonably-performant approach for emscripten. The idea
@@ skipping 195 matching lines @@
   FunctionPhisMap SetjmpOutputPhis;
   std::vector<Instruction*> ToErase;
 
   if (Setjmp) {
     for (Instruction::user_iterator UI = Setjmp->user_begin(), UE = Setjmp->user_end(); UI != UE; ++UI) {
       User *U = *UI;
       if (CallInst *CI = dyn_cast<CallInst>(U)) {
         BasicBlock *SJBB = CI->getParent();
         // The tail is everything right after the call, and will be reached once when setjmp is
         // called, and later when longjmp returns to the setjmp
-        BasicBlock *Tail = SplitBlock(SJBB, CI->getNextNode(), this);
+        BasicBlock *Tail = SplitBlock(SJBB, CI->getNextNode());
         // Add a phi to the tail, which will be the output of setjmp, which indicates if this is the
         // first call or a longjmp back. The phi directly uses the right value based on where we
         // arrive from
         PHINode *SetjmpOutput = PHINode::Create(i32, 2, "", Tail->getFirstNonPHI());
         SetjmpOutput->addIncoming(ConstantInt::get(i32, 0), SJBB); // setjmp initial call returns 0
         CI->replaceAllUsesWith(SetjmpOutput); // The proper output is now this, not the setjmp call itself
         // longjmp returns to the setjmp will add themselves to this phi
         Phis& P = SetjmpOutputPhis[SJBB->getParent()];
         P.push_back(SetjmpOutput);
         // fix call target
@@ skipping 34 matching lines @@
           if (Function *CF = dyn_cast<Function>(V)) if (CF->isIntrinsic()) continue;
           // TODO: proper analysis of what can actually longjmp. Currently we assume anything but setjmp can.
           // This may longjmp, so we need to check if it did. Split at that point, and
           // envelop the call in pre/post invoke, if we need to
           CallInst *After;
           Instruction *Check = NULL;
           if (Iter != E && (After = dyn_cast<CallInst>(Iter)) && After->getCalledValue() == PostInvoke) {
             // use the pre|postinvoke that exceptions lowering already made
             Check = Iter++;
           }
-          BasicBlock *Tail = SplitBlock(BB, Iter, this); // Iter already points to the next instruction, as we need
+          BasicBlock *Tail = SplitBlock(BB, Iter); // Iter already points to the next instruction, as we need
           TerminatorInst *TI = BB->getTerminator();
           if (!Check) {
             // no existing pre|postinvoke, create our own
             CallInst::Create(PreInvoke, "", CI);
             Check = CallInst::Create(PostInvoke, "", TI); // CI is at the end of the block
 
             // If we are calling a function that is noreturn, we must remove that attribute. The code we
             // insert here does expect it to return, after we catch the exception.
             if (CI->doesNotReturn()) {
               if (Function *F = dyn_cast<Function>(CI->getCalledValue())) {
@@ skipping 58 matching lines @@
     doRegToMem(*F);
     doMemToReg(*F);
   }
 
   return true;
 }
 
 ModulePass *llvm::createLowerEmSetjmpPass() {
   return new LowerEmSetjmp();
 }