Prep for merging 3.4: Undo changes from 3.3 branch

lib/CodeGen/CGException.cpp

 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This contains code dealing with C++ exception related code generation.
@@ skipping 401 matching lines @@
 }
 
 llvm::Value *CodeGenFunction::getExceptionFromSlot() {
   return Builder.CreateLoad(getExceptionSlot(), "exn");
 }
 
 llvm::Value *CodeGenFunction::getSelectorFromSlot() {
   return Builder.CreateLoad(getEHSelectorSlot(), "sel");
 }
 
-void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E,
-                                       bool KeepInsertionPoint) {
+void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E) {
   if (!E->getSubExpr()) {
     EmitNoreturnRuntimeCallOrInvoke(getReThrowFn(CGM),
                                     ArrayRef<llvm::Value*>());
 
     // throw is an expression, and the expression emitters expect us
     // to leave ourselves at a valid insertion point.
-    if (KeepInsertionPoint)
-      EmitBlock(createBasicBlock("throw.cont"));
+    EmitBlock(createBasicBlock("throw.cont"));
 
     return;
   }
 
   QualType ThrowType = E->getSubExpr()->getType();
 
   if (ThrowType->isObjCObjectPointerType()) {
     const Stmt *ThrowStmt = E->getSubExpr();
     const ObjCAtThrowStmt S(E->getExprLoc(),
                             const_cast<Stmt *>(ThrowStmt));
     CGM.getObjCRuntime().EmitThrowStmt(*this, S, false);
     // This will clear insertion point which was not cleared in
     // call to EmitThrowStmt.
-    if (KeepInsertionPoint)
-      EmitBlock(createBasicBlock("throw.cont"));
+    EmitBlock(createBasicBlock("throw.cont"));
     return;
   }
   
   // Now allocate the exception object.
   llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
   uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();
 
   llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM);
   llvm::CallInst *ExceptionPtr =
     EmitNounwindRuntimeCall(AllocExceptionFn,
@@ skipping 17 matching lines @@
       Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy);
     }
   }
   if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy);
 
   llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor };
   EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
 
   // throw is an expression, and the expression emitters expect us
   // to leave ourselves at a valid insertion point.
-  if (KeepInsertionPoint)
-    EmitBlock(createBasicBlock("throw.cont"));
+  EmitBlock(createBasicBlock("throw.cont"));
 }
 
 void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
   if (!CGM.getLangOpts().CXXExceptions)
     return;
   
   const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
   if (FD == 0)
     return;
   const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
@@ skipping 1180 matching lines @@
       break;
     }
   }
 
   Builder.CreateUnreachable();
 
   Builder.restoreIP(SavedIP);
 
   return EHResumeBlock;
 }