LowerAllocations is really a BasicBlock pass. Make it so.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1521 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 54 insertions, 57 deletions

diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp
index 4f3f182cf3..1acaea7d29 100644
--- a/lib/Transforms/Utils/LowerAllocations.cpp
+++ b/lib/Transforms/Utils/LowerAllocations.cpp
@@ -1,4 +1,4 @@
-//===- llvm/Transforms/LowerAllocations.h - Remove Malloc & Free Insts ------=//
+//===- LowerAllocations.cpp - Remove Malloc & Free Instructions -------------=//
 //
 // This file implements a pass that lowers malloc and free instructions to
 // calls to %malloc & %free functions.  This transformation is a target
@@ -52,71 +52,68 @@ bool LowerAllocations::doInitialization(Module *M) {
     Changed = true;
   }
 
-  return Changed;  // Always successful
+  return Changed;
 }
 
-// runOnMethod - This method does the actual work of converting
+// runOnBasicBlock - This method does the actual work of converting
 // instructions over, assuming that the pass has already been initialized.
 //
-bool LowerAllocations::runOnMethod(Method *M) {
+bool LowerAllocations::runOnBasicBlock(BasicBlock *BB) {
   bool Changed = false;
-  assert(MallocMeth && FreeMeth && M && "Pass not initialized!");
+  assert(MallocMeth && FreeMeth && BB && "Pass not initialized!");
 
   // Loop over all of the instructions, looking for malloc or free instructions
-  for (Method::iterator BBI = M->begin(), BBE = M->end(); BBI != BBE; ++BBI) {
-    BasicBlock *BB = *BBI;
-    for (unsigned i = 0; i < BB->size(); ++i) {
-      BasicBlock::InstListType &BBIL = BB->getInstList();
-      if (MallocInst *MI = dyn_cast<MallocInst>(*(BBIL.begin()+i))) {
-        BBIL.remove(BBIL.begin()+i);   // remove the malloc instr...
+  for (unsigned i = 0; i < BB->size(); ++i) {
+    BasicBlock::InstListType &BBIL = BB->getInstList();
+    if (MallocInst *MI = dyn_cast<MallocInst>(*(BBIL.begin()+i))) {
+      BBIL.remove(BBIL.begin()+i);   // remove the malloc instr...
         
-        const Type *AllocTy =cast<PointerType>(MI->getType())->getElementType();
-
-        // Get the number of bytes to be allocated for one element of the
-        // requested type...
-        unsigned Size = DataLayout.getTypeSize(AllocTy);
-
-        // malloc(type) becomes sbyte *malloc(constint)
-        Value *MallocArg = ConstantUInt::get(Type::UIntTy, Size);
-        if (MI->getNumOperands() && Size == 1) {
-          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);
-          BBIL.insert(BBIL.begin()+i++, cast<Instruction>(MallocArg));
-        }
-
-        // Create the call to Malloc...
-        CallInst *MCall = new CallInst(MallocMeth,
-                                       vector<Value*>(1, MallocArg));
-        BBIL.insert(BBIL.begin()+i, MCall);
-
-        // Create a cast instruction to convert to the right type...
-        CastInst *MCast = new CastInst(MCall, MI->getType());
-        BBIL.insert(BBIL.begin()+i+1, MCast);
-
-        // Replace all uses of the old malloc inst with the cast inst
-        MI->replaceAllUsesWith(MCast);
-        delete MI;                          // Delete the malloc inst
-        Changed = true;
-      } else if (FreeInst *FI = dyn_cast<FreeInst>(*(BBIL.begin()+i))) {
-        BBIL.remove(BB->getInstList().begin()+i);
-
-        // Cast the argument to free into a ubyte*...
-        CastInst *MCast = new CastInst(FI->getOperand(0), 
-                                       PointerType::get(Type::UByteTy));
-        BBIL.insert(BBIL.begin()+i, MCast);
-
-        // Insert a call to the free function...
-        CallInst *FCall = new CallInst(FreeMeth,
-                                       vector<Value*>(1, MCast));
-        BBIL.insert(BBIL.begin()+i+1, FCall);
-
-        // Delete the old free instruction
-        delete FI;
-        Changed = true;
+      const Type *AllocTy =cast<PointerType>(MI->getType())->getElementType();
+      
+      // Get the number of bytes to be allocated for one element of the
+      // requested type...
+      unsigned Size = DataLayout.getTypeSize(AllocTy);
+      
+      // malloc(type) becomes sbyte *malloc(constint)
+      Value *MallocArg = ConstantUInt::get(Type::UIntTy, Size);
+      if (MI->getNumOperands() && Size == 1) {
+        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);
+        BBIL.insert(BBIL.begin()+i++, cast<Instruction>(MallocArg));
       }
+      
+      // Create the call to Malloc...
+      CallInst *MCall = new CallInst(MallocMeth,
+                                     vector<Value*>(1, MallocArg));
+      BBIL.insert(BBIL.begin()+i, MCall);
+      
+      // Create a cast instruction to convert to the right type...
+      CastInst *MCast = new CastInst(MCall, MI->getType());
+      BBIL.insert(BBIL.begin()+i+1, MCast);
+      
+      // Replace all uses of the old malloc inst with the cast inst
+      MI->replaceAllUsesWith(MCast);
+      delete MI;                          // Delete the malloc inst
+      Changed = true;
+    } else if (FreeInst *FI = dyn_cast<FreeInst>(*(BBIL.begin()+i))) {
+      BBIL.remove(BB->getInstList().begin()+i);
+      
+      // Cast the argument to free into a ubyte*...
+      CastInst *MCast = new CastInst(FI->getOperand(0), 
+                                     PointerType::get(Type::UByteTy));
+      BBIL.insert(BBIL.begin()+i, MCast);
+      
+      // Insert a call to the free function...
+      CallInst *FCall = new CallInst(FreeMeth,
+                                     vector<Value*>(1, MCast));
+      BBIL.insert(BBIL.begin()+i+1, FCall);
+      
+      // Delete the old free instruction
+      delete FI;
+      Changed = true;
     }
   }