- Rename AnalysisUsage::preservesAll to getPreservesAll & preservesCFG to

[oota-llvm.git] / lib / Transforms / Utils / LowerAllocations.cpp

diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp
index a50cd8a5d11db2263b5272dfece787c213a9fe9a..8c6550003dd72b0dbe78a4c0ca89148bc83349a2 100644 (file)
--- a/lib/Transforms/Utils/LowerAllocations.cpp
+++ b/lib/Transforms/Utils/LowerAllocations.cpp
@@ -5,57 +5,54 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/ChangeAllocations.h"
+#include "llvm/Transforms/Scalar.h"
 #include "llvm/Module.h"
-#include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/iMemory.h"
 #include "llvm/iOther.h"
 #include "llvm/Constants.h"
 #include "llvm/Pass.h"
 #include "llvm/Target/TargetData.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
-static Statistic<> NumLowered("lowerallocs\t- Number of allocations lowered");
 using std::vector;
 
 namespace {
+  Statistic<> NumLowered("lowerallocs", "Number of allocations lowered");
+
+  /// LowerAllocations - Turn malloc and free instructions into %malloc and
+  /// %free calls.
+  ///
+  class LowerAllocations : public BasicBlockPass {
+    Function *MallocFunc;   // Functions in the module we are processing
+    Function *FreeFunc;     // Initialized by doInitialization
+  public:
+    LowerAllocations() : MallocFunc(0), FreeFunc(0) {}
+
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired<TargetData>();
+    }
 
-// LowerAllocations - Turn malloc and free instructions into %malloc and %free
-// calls.
-//
-class LowerAllocations : public BasicBlockPass {
-  Function *MallocFunc;   // Functions in the module we are processing
-  Function *FreeFunc;     // Initialized by doInitialization
-
-  const TargetData &DataLayout;
-public:
-  LowerAllocations(const TargetData &TD) : DataLayout(TD) {
-    MallocFunc = FreeFunc = 0;
-  }
-
-  // doPassInitialization - For the lower allocations pass, this ensures that a
-  // module contains a declaration for a malloc and a free function.
-  //
-  bool doInitialization(Module &M);
-
-  // runOnBasicBlock - This method does the actual work of converting
-  // instructions over, assuming that the pass has already been initialized.
-  //
-  bool runOnBasicBlock(BasicBlock &BB);
-};
+    /// doPassInitialization - For the lower allocations pass, this ensures that
+    /// a module contains a declaration for a malloc and a free function.
+    ///
+    bool doInitialization(Module &M);
+    
+    /// runOnBasicBlock - This method does the actual work of converting
+    /// instructions over, assuming that the pass has already been initialized.
+    ///
+    bool runOnBasicBlock(BasicBlock &BB);
+  };
+
+  RegisterOpt<LowerAllocations>
+  X("lowerallocs", "Lower allocations from instructions to calls");
 }
 
 // createLowerAllocationsPass - Interface to this file...
-Pass *createLowerAllocationsPass(const TargetData &TD) {
-  return new LowerAllocations(TD);
+Pass *createLowerAllocationsPass() {
+  return new LowerAllocations();
 }
 
-static RegisterPass<LowerAllocations>
-X("lowerallocs", "Lower allocations from instructions to calls (TD)",
-  createLowerAllocationsPass);
-
 
 // doInitialization - For the lower allocations pass, this ensures that a
 // module contains a declaration for a malloc and a free function.
@@ -85,12 +82,11 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
   assert(MallocFunc && FreeFunc && "Pass not initialized!");
 
   BasicBlock::InstListType &BBIL = BB.getInstList();
+  TargetData &DataLayout = getAnalysis<TargetData>();
 
   // 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
@@ -103,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;
     }