Clean up code due to auto-insert constructors

llvm-svn: 3665

6 files changed, 31 insertions, 61 deletions

diff --git a/llvm/lib/Transforms/IPO/RaiseAllocations.cpp b/llvm/lib/Transforms/IPO/RaiseAllocations.cpp
index 0f10dad3c41..cc4573586dc 100644
--- a/llvm/lib/Transforms/IPO/RaiseAllocations.cpp
+++ b/llvm/lib/Transforms/IPO/RaiseAllocations.cpp
@@ -108,7 +108,7 @@ bool RaiseAllocations::runOnBasicBlock(BasicBlock &BB) {
   bool Changed = false;
   BasicBlock::InstListType &BIL = BB.getInstList();
 
-  for (BasicBlock::iterator BI = BB.begin(); BI != BB.end();) {
+  for (BasicBlock::iterator BI = BB.begin(); BI != BB.end(); ++BI) {
     Instruction *I = BI;
 
     if (CallInst *CI = dyn_cast<CallInst>(I)) {
@@ -118,19 +118,14 @@ bool RaiseAllocations::runOnBasicBlock(BasicBlock &BB) {
         
         // If no prototype was provided for malloc, we may need to cast the
         // source size.
-        if (Source->getType() != Type::UIntTy) {
-          CastInst *New = new CastInst(Source, Type::UIntTy, "MallocAmtCast");
-          BI = ++BIL.insert(BI, New);
-          Source = New;
-        }
-
-        MallocInst *MallocI = new MallocInst(PtrSByte, Source, CI->getName());
-                                             
-        CI->setName("");
-        ReplaceInstWithInst(BIL, BI, MallocI);
+        if (Source->getType() != Type::UIntTy)
+          Source = new CastInst(Source, Type::UIntTy, "MallocAmtCast", BI);
+
+        std::string Name(CI->getName()); CI->setName("");
+        BI = new MallocInst(PtrSByte, Source, Name, BI);
+        BIL.erase(I);
         Changed = true;
         ++NumRaised;
-        continue;  // Skip the ++BI
       } else if (CI->getCalledValue() == FreeFunc) { // Replace call to free?
         // If no prototype was provided for free, we may need to cast the
         // source pointer.  This should be really uncommon, but it's neccesary
@@ -138,21 +133,15 @@ bool RaiseAllocations::runOnBasicBlock(BasicBlock &BB) {
         //   free((long)ptr);
         //
         Value *Source = CI->getOperand(1);
-        if (!isa<PointerType>(Source->getType())) {
-          CastInst *New = new CastInst(Source, PointerType::get(Type::SByteTy),
-                                       "FreePtrCast");
-          BI = ++BIL.insert(BI, New);
-          Source = New;
-        }
-
-        ReplaceInstWithInst(BIL, BI, new FreeInst(Source));
+        if (!isa<PointerType>(Source->getType()))
+          Source = new CastInst(Source, PointerType::get(Type::SByteTy),
+                                "FreePtrCast", BI);
+        BI = new FreeInst(Source, BI);
+        BIL.erase(I);
         Changed = true;
-        continue;  // Skip the ++BI
         ++NumRaised;
       }
     }
-
-    ++BI;
   }
 
   return Changed;
diff --git a/llvm/lib/Transforms/Scalar/ADCE.cpp b/llvm/lib/Transforms/Scalar/ADCE.cpp
index 15b71fdf55f..3aca4a2d4cd 100644
--- a/llvm/lib/Transforms/Scalar/ADCE.cpp
+++ b/llvm/lib/Transforms/Scalar/ADCE.cpp
@@ -240,7 +240,7 @@ bool ADCE::doADCE() {
     //
     if (!AliveBlocks.count(&Func->front())) {
       BasicBlock *NewEntry = new BasicBlock();
-      NewEntry->getInstList().push_back(new BranchInst(&Func->front()));
+      new BranchInst(&Func->front(), NewEntry->end());
       Func->getBasicBlockList().push_front(NewEntry);
       AliveBlocks.insert(NewEntry);    // This block is always alive!
     }
@@ -353,9 +353,8 @@ bool ADCE::doADCE() {
         // Delete the old terminator instruction...
         BB->getInstList().pop_back();
         const Type *RetTy = Func->getReturnType();
-        Instruction *New = new ReturnInst(RetTy != Type::VoidTy ?
-                                          Constant::getNullValue(RetTy) : 0);
-        BB->getInstList().push_back(New);
+        new ReturnInst(RetTy != Type::VoidTy ? Constant::getNullValue(RetTy) :0,
+                       BB->end());
       }
 
       BB->dropAllReferences();
diff --git a/llvm/lib/Transforms/Scalar/LICM.cpp b/llvm/lib/Transforms/Scalar/LICM.cpp
index 37333db1115..7bae9fd18a5 100644
--- a/llvm/lib/Transforms/Scalar/LICM.cpp
+++ b/llvm/lib/Transforms/Scalar/LICM.cpp
@@ -241,10 +241,8 @@ void LICM::hoist(Instruction &Inst) {
     // No loop pre-header, insert a PHI node into header to capture all of the
     // incoming versions of the value.
     //
-    PHINode *LoopVal = new PHINode(Inst.getType(), InstName+".phi");
-
-    // Insert the new PHI node into the loop header...
-    Header->getInstList().push_front(LoopVal);
+    PHINode *LoopVal = new PHINode(Inst.getType(), InstName+".phi",
+                                   Header->begin());
 
     // Insert cloned versions of the instruction into all of the loop preds.
     for (unsigned i = 0, e = LoopPreds.size(); i != e; ++i) {
diff --git a/llvm/lib/Transforms/Scalar/LowerAllocations.cpp b/llvm/lib/Transforms/Scalar/LowerAllocations.cpp
index bdb4f9c491d..001028eb21a 100644
--- a/llvm/lib/Transforms/Scalar/LowerAllocations.cpp
+++ b/llvm/lib/Transforms/Scalar/LowerAllocations.cpp
@@ -87,8 +87,6 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
   // Loop over all of the instructions, looking for malloc or free instructions
   for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) {
     if (MallocInst *MI = dyn_cast<MallocInst>(&*I)) {
-      BBIL.remove(I);   // remove the malloc instr...
-
       const Type *AllocTy = MI->getType()->getElementType();
       
       // Get the number of bytes to be allocated for one element of the
@@ -101,39 +99,32 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
         MallocArg = MI->getOperand(0);         // Operand * 1 = Operand
       } else if (MI->getNumOperands()) {
         // Multiply it by the array size if neccesary...
-        MallocArg = BinaryOperator::create(Instruction::Mul,MI->getOperand(0),
-                                           MallocArg);
-        I = ++BBIL.insert(I, cast<Instruction>(MallocArg));
+        MallocArg = BinaryOperator::create(Instruction::Mul, MI->getOperand(0),
+                                           MallocArg, "", I);
       }
       
       // Create the call to Malloc...
       CallInst *MCall = new CallInst(MallocFunc,
-                                     vector<Value*>(1, MallocArg));
-      I = BBIL.insert(I, MCall);
+                                     vector<Value*>(1, MallocArg), "", I);
       
       // Create a cast instruction to convert to the right type...
-      CastInst *MCast = new CastInst(MCall, MI->getType());
-      I = BBIL.insert(++I, MCast);
+      CastInst *MCast = new CastInst(MCall, MI->getType(), "", I);
       
       // Replace all uses of the old malloc inst with the cast inst
       MI->replaceAllUsesWith(MCast);
-      delete MI;                          // Delete the malloc inst
+      I = --BBIL.erase(I);         // remove and delete the malloc instr...
       Changed = true;
       ++NumLowered;
     } else if (FreeInst *FI = dyn_cast<FreeInst>(&*I)) {
-      BBIL.remove(I);
-      
       // Cast the argument to free into a ubyte*...
       CastInst *MCast = new CastInst(FI->getOperand(0), 
-                                     PointerType::get(Type::UByteTy));
-      I = ++BBIL.insert(I, MCast);
+                                     PointerType::get(Type::UByteTy), "", I);
       
       // Insert a call to the free function...
-      CallInst *FCall = new CallInst(FreeFunc, vector<Value*>(1, MCast));
-      I = BBIL.insert(I, FCall);
+      CallInst *FCall = new CallInst(FreeFunc, vector<Value*>(1, MCast), "", I);
       
       // Delete the old free instruction
-      delete FI;
+      I = --BBIL.erase(I);
       Changed = true;
       ++NumLowered;
     }
diff --git a/llvm/lib/Transforms/Scalar/PiNodeInsertion.cpp b/llvm/lib/Transforms/Scalar/PiNodeInsertion.cpp
index bf0119f2f3c..940b56fd29b 100644
--- a/llvm/lib/Transforms/Scalar/PiNodeInsertion.cpp
+++ b/llvm/lib/Transforms/Scalar/PiNodeInsertion.cpp
@@ -148,13 +148,8 @@ bool PiNodeInserter::insertPiNodeFor(Value *V, BasicBlock *Succ, Value *Rep) {
     
   // Create the Pi node...
   Value *Pi = Rep;
-  if (Rep == 0) {
-    PHINode *Phi = new PHINode(V->getType(), V->getName() + ".pi");
-    
-    // Insert the Pi node in the successor basic block...
-    Succ->getInstList().push_front(Phi);
-    Pi = Phi;
-  }
+  if (Rep == 0)      // Insert the Pi node in the successor basic block...
+    Pi = new PHINode(V->getType(), V->getName() + ".pi", Succ->begin());
     
   // Loop over all of the uses of V, replacing ones that the Pi node
   // dominates with references to the Pi node itself.
diff --git a/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
index 5fcab970352..b84f1a378fa 100644
--- a/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
+++ b/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
@@ -196,14 +196,12 @@ bool PromotePass::QueuePhiNode(BasicBlock *BB, unsigned AllocaNo) {
   // If the BB already has a phi node added for the i'th alloca then we're done!
   if (BBPNs[AllocaNo]) return false;
 
-  // Create a PhiNode using the dereferenced type...
+  // Create a PhiNode using the dereferenced type... and add the phi-node to the
+  // BasicBlock
   PHINode *PN = new PHINode(Allocas[AllocaNo]->getAllocatedType(),
-                            Allocas[AllocaNo]->getName()+".mem2reg");
+                            Allocas[AllocaNo]->getName()+".mem2reg",
+                            BB->begin());
   BBPNs[AllocaNo] = PN;
-
-  // Add the phi-node to the basic-block
-  BB->getInstList().push_front(PN);
-
   PhiNodes[AllocaNo].push_back(BB);
   return true;
 }