X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FUtils%2FLowerAllocations.cpp;h=8c6550003dd72b0dbe78a4c0ca89148bc83349a2;hb=dee430d26e14a3d7c8d86688d49ac8b116aa044f;hp=e5bf88fc00caa70bd65abe4956739d57836b2b3a;hpb=ade686e79bdd4938a5fe99257afce41ca27e736b;p=oota-llvm.git diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index e5bf88fc00c..8c6550003dd 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -5,51 +5,52 @@ // //===----------------------------------------------------------------------===// -#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/Statistic.h" + 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(); + } -// 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: - inline LowerAllocations(const TargetData &TD) : DataLayout(TD) { - MallocFunc = FreeFunc = 0; - } - - const char *getPassName() const { return "Lower Allocations"; } - - // 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 + 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(); } @@ -58,7 +59,7 @@ Pass *createLowerAllocationsPass(const TargetData &TD) { // // This function is always successful. // -bool LowerAllocations::doInitialization(Module *M) { +bool LowerAllocations::doInitialization(Module &M) { const FunctionType *MallocType = FunctionType::get(PointerType::get(Type::SByteTy), vector(1, Type::UIntTy), false); @@ -67,8 +68,8 @@ bool LowerAllocations::doInitialization(Module *M) { vector(1, PointerType::get(Type::SByteTy)), false); - MallocFunc = M->getOrInsertFunction("malloc", MallocType); - FreeFunc = M->getOrInsertFunction("free" , FreeType); + MallocFunc = M.getOrInsertFunction("malloc", MallocType); + FreeFunc = M.getOrInsertFunction("free" , FreeType); return true; } @@ -76,17 +77,17 @@ bool LowerAllocations::doInitialization(Module *M) { // runOnBasicBlock - This method does the actual work of converting // instructions over, assuming that the pass has already been initialized. // -bool LowerAllocations::runOnBasicBlock(BasicBlock *BB) { +bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { bool Changed = false; - assert(MallocFunc && FreeFunc && BB && "Pass not initialized!"); + assert(MallocFunc && FreeFunc && "Pass not initialized!"); + + BasicBlock::InstListType &BBIL = BB.getInstList(); + TargetData &DataLayout = getAnalysis(); // Loop over all of the instructions, looking for malloc or free instructions - for (unsigned i = 0; i < BB->size(); ++i) { - BasicBlock::InstListType &BBIL = BB->getInstList(); - if (MallocInst *MI = dyn_cast(*(BBIL.begin()+i))) { - BBIL.remove(BBIL.begin()+i); // remove the malloc instr... - - const Type *AllocTy = cast(MI->getType())->getElementType(); + for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) { + if (MallocInst *MI = dyn_cast(&*I)) { + const Type *AllocTy = MI->getType()->getElementType(); // Get the number of bytes to be allocated for one element of the // requested type... @@ -98,40 +99,34 @@ 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); - BBIL.insert(BBIL.begin()+i++, cast(MallocArg)); + MallocArg = BinaryOperator::create(Instruction::Mul, MI->getOperand(0), + MallocArg, "", I); } // Create the call to Malloc... CallInst *MCall = new CallInst(MallocFunc, - vector(1, MallocArg)); - BBIL.insert(BBIL.begin()+i, MCall); + vector(1, MallocArg), "", I); // Create a cast instruction to convert to the right type... - CastInst *MCast = new CastInst(MCall, MI->getType()); - BBIL.insert(BBIL.begin()+i+1, 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; - } else if (FreeInst *FI = dyn_cast(*(BBIL.begin()+i))) { - BBIL.remove(BB->getInstList().begin()+i); - + ++NumLowered; + } else if (FreeInst *FI = dyn_cast(&*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); + PointerType::get(Type::UByteTy), "", I); // Insert a call to the free function... - CallInst *FCall = new CallInst(FreeFunc, - vector(1, MCast)); - BBIL.insert(BBIL.begin()+i+1, FCall); + CallInst *FCall = new CallInst(FreeFunc, vector(1, MCast), "", I); // Delete the old free instruction - delete FI; + I = --BBIL.erase(I); Changed = true; + ++NumLowered; } }