Change the RaiseAllocations pass to be a Pass instead of a BasicBlock pass.

This makes it more efficient: it doesn't have to scan the whole program, so
it performs work proportional to the number of malloc/free calls in the
program, not the size of the program.


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

lib/Transforms/IPO/RaiseAllocations.cpp

@@ -5,13 +5,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Module.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/iMemory.h"
 #include "llvm/iOther.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/CallSite.h"
 #include "Support/Statistic.h"
 
 namespace {
@@ -20,7 +20,7 @@ namespace {
   // RaiseAllocations - Turn %malloc and %free calls into the appropriate
   // instruction.
   //
-  class RaiseAllocations : public BasicBlockPass {
+  class RaiseAllocations : public Pass {
     Function *MallocFunc;   // Functions in the module we are processing
     Function *FreeFunc;     // Initialized by doPassInitializationVirt
   public:
@@ -29,12 +29,11 @@ namespace {
     // doPassInitialization - For the raise allocations pass, this finds a
     // declaration for malloc and free if they exist.
     //
-    bool doInitialization(Module &M);
+    void doInitialization(Module &M);
     
-    // runOnBasicBlock - This method does the actual work of converting
+    // run - This method does the actual work of converting instructions over.
-    // instructions over, assuming that the pass has already been initialized.
     //
-    bool runOnBasicBlock(BasicBlock &BB);
+    bool run(Module &M);
   };
   
   RegisterOpt<RaiseAllocations>
@@ -48,15 +47,15 @@ Pass *createRaiseAllocationsPass() {
 }
 
 
-bool RaiseAllocations::doInitialization(Module &M) {
+// If the module has a symbol table, they might be referring to the malloc and
-  // If the module has a symbol table, they might be referring to the malloc
+// free functions.  If this is the case, grab the method pointers that the
-  // and free functions.  If this is the case, grab the method pointers that 
+// module is using.
-  // the module is using.
+//
-  //
+// Lookup %malloc and %free in the symbol table, for later use.  If they don't
-  // Lookup %malloc and %free in the symbol table, for later use.  If they
+// exist, or are not external, we do not worry about converting calls to that
-  // don't exist, or are not external, we do not worry about converting calls
+// function into the appropriate instruction.
-  // to that function into the appropriate instruction.
+//
-  //
+void RaiseAllocations::doInitialization(Module &M) {
   const FunctionType *MallocType =   // Get the type for malloc
     FunctionType::get(PointerType::get(Type::SByteTy),
                     std::vector<const Type*>(1, Type::ULongTy), false);
@@ -100,53 +99,75 @@ bool RaiseAllocations::doInitialization(Module &M) {
     FreeFunc = M.getFunction("free", FreeType);
   }
 
-
   // Don't mess with locally defined versions of these functions...
   if (MallocFunc && !MallocFunc->isExternal()) MallocFunc = 0;
   if (FreeFunc && !FreeFunc->isExternal())     FreeFunc = 0;
-  return false;
 }
 
-// runOnBasicBlock - Process a basic block, fixing it up...
+// run - Transform calls into instructions...
 //
-bool RaiseAllocations::runOnBasicBlock(BasicBlock &BB) {
+bool RaiseAllocations::run(Module &M) {
+  // Find the malloc/free prototypes...
+  doInitialization(M);
+
   bool Changed = false;
-  BasicBlock::InstListType &BIL = BB.getInstList();
 
-  for (BasicBlock::iterator BI = BB.begin(); BI != BB.end(); ++BI) {
+  // First, process all of the malloc calls...
-    Instruction *I = BI;
+  if (MallocFunc) {
-
+    std::vector<User*> Users(MallocFunc->use_begin(), MallocFunc->use_end());
-    if (CallInst *CI = dyn_cast<CallInst>(I)) {
+    while (!Users.empty()) {
-      if (CI->getCalledValue() == MallocFunc) {      // Replace call to malloc?
+      if (Instruction *I = dyn_cast<Instruction>(Users.back())) {
-        Value *Source = CI->getOperand(1);
+        CallSite CS = CallSite::get(I);
+        if (CS.getInstruction() && CS.getCalledFunction() == MallocFunc &&
+            CS.arg_begin() != CS.arg_end()) {
+          Value *Source = *CS.arg_begin();
           
           // If no prototype was provided for malloc, we may need to cast the
           // source size.
           if (Source->getType() != Type::UIntTy)
-          Source = new CastInst(Source, Type::UIntTy, "MallocAmtCast", BI);
+            Source = new CastInst(Source, Type::UIntTy, "MallocAmtCast", I);
           
-        std::string Name(CI->getName()); CI->setName("");
+          std::string Name(I->getName()); I->setName("");
-        BI = new MallocInst(Type::SByteTy, Source, Name, BI);
+          MallocInst *MI = new MallocInst(Type::SByteTy, Source, Name, I);
-        CI->replaceAllUsesWith(BI);
+          I->replaceAllUsesWith(MI);
-        BIL.erase(I);
+          MI->getParent()->getInstList().erase(I);
           Changed = true;
           ++NumRaised;
-      } else if (CI->getCalledValue() == FreeFunc) { // Replace call to free?
+        }
+      }
+
+      Users.pop_back();
+    }
+  }
+
+  // Next, process all free calls...
+  if (FreeFunc) {
+    std::vector<User*> Users(FreeFunc->use_begin(), FreeFunc->use_end());
+
+    while (!Users.empty()) {
+      if (Instruction *I = dyn_cast<Instruction>(Users.back())) {
+        CallSite CS = CallSite::get(I);
+        if (CS.getInstruction() && CS.getCalledFunction() == FreeFunc &&
+            CS.arg_begin() != CS.arg_end()) {
+          
           // If no prototype was provided for free, we may need to cast the
           // source pointer.  This should be really uncommon, but it's necessary
           // just in case we are dealing with wierd code like this:
           //   free((long)ptr);
           //
-        Value *Source = CI->getOperand(1);
+          Value *Source = *CS.arg_begin();
           if (!isa<PointerType>(Source->getType()))
             Source = new CastInst(Source, PointerType::get(Type::SByteTy),
-                                "FreePtrCast", BI);
+                                  "FreePtrCast", I);
-        BI = new FreeInst(Source, BI);
+          new FreeInst(Source, I);
-        BIL.erase(I);
+          I->getParent()->getInstList().erase(I);
           Changed = true;
           ++NumRaised;
         }
       }
+      
+      Users.pop_back();
+    }
   }
 
   return Changed;