diff --git a/include/llvm/Transforms/ChangeAllocations.h b/include/llvm/Transforms/ChangeAllocations.h index 05fb1334100..9adac5dd91d 100644 --- a/include/llvm/Transforms/ChangeAllocations.h +++ b/include/llvm/Transforms/ChangeAllocations.h @@ -13,7 +13,7 @@ #include "llvm/Pass.h" class TargetData; -class LowerAllocations : public MethodPass { +class LowerAllocations : public BasicBlockPass { Method *MallocMeth; // Methods in the module we are processing Method *FreeMeth; // Initialized by doPassInitializationVirt @@ -26,14 +26,12 @@ public: // doPassInitialization - For the lower allocations pass, this ensures that a // module contains a declaration for a malloc and a free function. // - // This function is always successful. - // bool doInitialization(Module *M); - // doPerMethodWork - 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 runOnMethod(Method *M); + bool runOnBasicBlock(BasicBlock *BB); }; #endif diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index 4f3f182cf32..1acaea7d29c 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(*(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(*(BBIL.begin()+i))) { + BBIL.remove(BBIL.begin()+i); // remove the malloc instr... - const Type *AllocTy =cast(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(MallocArg)); - } - - // Create the call to Malloc... - CallInst *MCall = new CallInst(MallocMeth, - vector(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(*(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(1, MCast)); - BBIL.insert(BBIL.begin()+i+1, FCall); - - // Delete the old free instruction - delete FI; - Changed = true; + const Type *AllocTy =cast(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(MallocArg)); } + + // Create the call to Malloc... + CallInst *MCall = new CallInst(MallocMeth, + vector(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(*(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(1, MCast)); + BBIL.insert(BBIL.begin()+i+1, FCall); + + // Delete the old free instruction + delete FI; + Changed = true; } }