X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FUtils%2FLowerAllocations.cpp;h=003be33182a8c36614649e70e09983febe70e546;hb=56d27019e6aebd7cfa5d031c832193eb66d75830;hp=0d26e2a2336a36e4f829048a196f227959b19697;hpb=31b80d98ad2ee847edc636f15e0244dcac7e6643;p=oota-llvm.git diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index 0d26e2a2336..003be33182a 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -1,75 +1,96 @@ -//===- ChangeAllocations.cpp - Modify %malloc & %free calls -----------------=// +//===- LowerAllocations.cpp - Reduce malloc & free insts to calls ---------===// // -// This file defines two passes that convert malloc and free instructions to -// calls to and from %malloc & %free function calls. The LowerAllocations -// transformation is a target dependant tranformation because it depends on the -// size of data types and alignment constraints. +// The LowerAllocations transformation is a target dependant tranformation +// because it depends on the size of data types and alignment constraints. // //===----------------------------------------------------------------------===// #include "llvm/Transforms/ChangeAllocations.h" -#include "llvm/Target/TargetData.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/SymbolTable.h" -#include "llvm/ConstantVals.h" -#include "TransformInternals.h" +#include "llvm/Constants.h" +#include "llvm/Pass.h" +#include "llvm/Target/TargetData.h" +#include "Support/StatisticReporter.h" + +static Statistic<> NumLowered("lowerallocs\t- Number of allocations lowered"); using std::vector; +namespace { + +// 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); +}; + +} + +// createLowerAllocationsPass - Interface to this file... +Pass *createLowerAllocationsPass(const TargetData &TD) { + return new LowerAllocations(TD); +} + // doInitialization - 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 LowerAllocations::doInitialization(Module *M) { - bool Changed = false; - const MethodType *MallocType = - MethodType::get(PointerType::get(Type::SByteTy), - vector(1, Type::UIntTy), false); - - SymbolTable *SymTab = M->getSymbolTableSure(); - - // Check for a definition of malloc - if (Value *V = SymTab->lookup(PointerType::get(MallocType), "malloc")) { - MallocMeth = cast(V); // Yup, got it - } else { // Nope, add one - M->getMethodList().push_back(MallocMeth = new Method(MallocType, false, - "malloc")); - Changed = true; - } - - const MethodType *FreeType = - MethodType::get(Type::VoidTy, - vector(1, PointerType::get(Type::SByteTy)), - false); - - // Check for a definition of free - if (Value *V = SymTab->lookup(PointerType::get(FreeType), "free")) { - FreeMeth = cast(V); // Yup, got it - } else { // Nope, add one - M->getMethodList().push_back(FreeMeth = new Method(FreeType, false,"free")); - Changed = true; - } - - return Changed; +bool LowerAllocations::doInitialization(Module &M) { + const FunctionType *MallocType = + FunctionType::get(PointerType::get(Type::SByteTy), + vector(1, Type::UIntTy), false); + const FunctionType *FreeType = + FunctionType::get(Type::VoidTy, + vector(1, PointerType::get(Type::SByteTy)), + false); + + MallocFunc = M.getOrInsertFunction("malloc", MallocType); + FreeFunc = M.getOrInsertFunction("free" , FreeType); + + return true; } // 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(MallocMeth && FreeMeth && BB && "Pass not initialized!"); + assert(MallocFunc && FreeFunc && "Pass not initialized!"); + + BasicBlock::InstListType &BBIL = BB.getInstList(); // 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)) { + 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 // requested type... @@ -83,100 +104,41 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock *BB) { // Multiply it by the array size if neccesary... MallocArg = BinaryOperator::create(Instruction::Mul,MI->getOperand(0), MallocArg); - BBIL.insert(BBIL.begin()+i++, cast(MallocArg)); + I = ++BBIL.insert(I, cast(MallocArg)); } // Create the call to Malloc... - CallInst *MCall = new CallInst(MallocMeth, + CallInst *MCall = new CallInst(MallocFunc, vector(1, MallocArg)); - BBIL.insert(BBIL.begin()+i, MCall); + I = BBIL.insert(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); + I = BBIL.insert(++I, 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); + ++NumLowered; + } else if (FreeInst *FI = dyn_cast(&*I)) { + BBIL.remove(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); + I = ++BBIL.insert(I, MCast); // Insert a call to the free function... - CallInst *FCall = new CallInst(FreeMeth, - vector(1, MCast)); - BBIL.insert(BBIL.begin()+i+1, FCall); + CallInst *FCall = new CallInst(FreeFunc, vector(1, MCast)); + I = BBIL.insert(I, FCall); // Delete the old free instruction delete FI; Changed = true; + ++NumLowered; } } return Changed; } - -bool RaiseAllocations::doInitialization(Module *M) { - SymbolTable *ST = M->getSymbolTable(); - if (!ST) return false; - - // If the module has a symbol table, they might be referring to the malloc - // and free functions. If this is the case, grab the method pointers that - // the module is using. - // - // Lookup %malloc and %free in the symbol table, for later use. If they - // don't exist, or are not external, we do not worry about converting calls - // to that function into the appropriate instruction. - // - const PointerType *MallocType = // Get the type for malloc - PointerType::get(MethodType::get(PointerType::get(Type::SByteTy), - vector(1, Type::UIntTy), false)); - MallocMeth = cast_or_null(ST->lookup(MallocType, "malloc")); - if (MallocMeth && !MallocMeth->isExternal()) - MallocMeth = 0; // Don't mess with locally defined versions of the fn - - const PointerType *FreeType = // Get the type for free - PointerType::get(MethodType::get(Type::VoidTy, - vector(1, PointerType::get(Type::SByteTy)), false)); - FreeMeth = cast_or_null(ST->lookup(FreeType, "free")); - if (FreeMeth && !FreeMeth->isExternal()) - FreeMeth = 0; // Don't mess with locally defined versions of the fn - - return false; -} - -// doOneCleanupPass - Do one pass over the input method, fixing stuff up. -// -bool RaiseAllocations::runOnBasicBlock(BasicBlock *BB) { - bool Changed = false; - BasicBlock::InstListType &BIL = BB->getInstList(); - - for (BasicBlock::iterator BI = BB->begin(); BI != BB->end();) { - Instruction *I = *BI; - - if (CallInst *CI = dyn_cast(I)) { - if (CI->getCalledValue() == MallocMeth) { // Replace call to malloc? - const Type *PtrSByte = PointerType::get(Type::SByteTy); - MallocInst *MallocI = new MallocInst(PtrSByte, CI->getOperand(1), - CI->getName()); - CI->setName(""); - ReplaceInstWithInst(BIL, BI, MallocI); - Changed = true; - continue; // Skip the ++BI - } else if (CI->getCalledValue() == FreeMeth) { // Replace call to free? - ReplaceInstWithInst(BIL, BI, new FreeInst(CI->getOperand(1))); - Changed = true; - continue; // Skip the ++BI - } - } - - ++BI; - } - - return Changed; -}