From ade686e79bdd4938a5fe99257afce41ca27e736b Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 7 May 2002 19:02:48 +0000 Subject: [PATCH] Split ChangeAllocations.cpp into Raise & LowerAllocations.cpp git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2529 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/RaiseAllocations.cpp | 108 ++++++++++++++++++++++ lib/Transforms/Utils/LowerAllocations.cpp | 103 ++------------------- 2 files changed, 118 insertions(+), 93 deletions(-) create mode 100644 lib/Transforms/IPO/RaiseAllocations.cpp diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp new file mode 100644 index 00000000000..a0719e12bf9 --- /dev/null +++ b/lib/Transforms/IPO/RaiseAllocations.cpp @@ -0,0 +1,108 @@ +//===- ChangeAllocations.cpp - Modify %malloc & %free 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. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Transforms/ChangeAllocations.h" +#include "llvm/Transforms/Utils/BasicBlockUtils.h" +#include "llvm/Module.h" +#include "llvm/Function.h" +#include "llvm/DerivedTypes.h" +#include "llvm/iMemory.h" +#include "llvm/iOther.h" +#include "llvm/Pass.h" + +namespace { + +// RaiseAllocations - Turn %malloc and %free calls into the appropriate +// instruction. +// +class RaiseAllocations : public BasicBlockPass { + Function *MallocFunc; // Functions in the module we are processing + Function *FreeFunc; // Initialized by doPassInitializationVirt +public: + inline RaiseAllocations() : MallocFunc(0), FreeFunc(0) {} + + const char *getPassName() const { return "Raise Allocations"; } + + // doPassInitialization - For the raise allocations pass, this finds a + // declaration for malloc and free if they exist. + // + 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); +}; + +} // end anonymous namespace + + +// createRaiseAllocationsPass - The interface to this file... +Pass *createRaiseAllocationsPass() { + return new RaiseAllocations(); +} + + +bool RaiseAllocations::doInitialization(Module *M) { + // 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 FunctionType *MallocType = // Get the type for malloc + FunctionType::get(PointerType::get(Type::SByteTy), + std::vector(1, Type::UIntTy), false); + + const FunctionType *FreeType = // Get the type for free + FunctionType::get(Type::VoidTy, + std::vector(1, PointerType::get(Type::SByteTy)), + false); + + MallocFunc = M->getFunction("malloc", MallocType); + 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; +} + +// 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() == MallocFunc) { // 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() == FreeFunc) { // Replace call to free? + ReplaceInstWithInst(BIL, BI, new FreeInst(CI->getOperand(1))); + Changed = true; + continue; // Skip the ++BI + } + } + + ++BI; + } + + return Changed; +} diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index ff3c29f11a7..e5bf88fc00c 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -1,16 +1,14 @@ -//===- 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/Transforms/Utils/BasicBlockUtils.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" @@ -47,29 +45,13 @@ public: bool runOnBasicBlock(BasicBlock *BB); }; -// RaiseAllocations - Turn %malloc and %free calls into the appropriate -// instruction. -// -class RaiseAllocations : public BasicBlockPass { - Function *MallocFunc; // Functions in the module we are processing - Function *FreeFunc; // Initialized by doPassInitializationVirt -public: - inline RaiseAllocations() : MallocFunc(0), FreeFunc(0) {} +} - const char *getPassName() const { return "Raise Allocations"; } +// createLowerAllocationsPass - Interface to this file... +Pass *createLowerAllocationsPass(const TargetData &TD) { + return new LowerAllocations(TD); +} - // doPassInitialization - For the raise allocations pass, this finds a - // declaration for malloc and free if they exist. - // - 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); -}; - -} // end anonymous namespace // doInitialization - For the lower allocations pass, this ensures that a // module contains a declaration for a malloc and a free function. @@ -88,7 +70,7 @@ bool LowerAllocations::doInitialization(Module *M) { MallocFunc = M->getOrInsertFunction("malloc", MallocType); FreeFunc = M->getOrInsertFunction("free" , FreeType); - return false; + return true; } // runOnBasicBlock - This method does the actual work of converting @@ -155,68 +137,3 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock *BB) { return Changed; } - -bool RaiseAllocations::doInitialization(Module *M) { - // 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 FunctionType *MallocType = // Get the type for malloc - FunctionType::get(PointerType::get(Type::SByteTy), - vector(1, Type::UIntTy), false); - - const FunctionType *FreeType = // Get the type for free - FunctionType::get(Type::VoidTy, - vector(1, PointerType::get(Type::SByteTy)), - false); - - MallocFunc = M->getFunction("malloc", MallocType); - 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; -} - -// 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() == MallocFunc) { // 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() == FreeFunc) { // Replace call to free? - ReplaceInstWithInst(BIL, BI, new FreeInst(CI->getOperand(1))); - Changed = true; - continue; // Skip the ++BI - } - } - - ++BI; - } - - return Changed; -} - -Pass *createLowerAllocationsPass(const TargetData &TD) { - return new LowerAllocations(TD); -} -Pass *createRaiseAllocationsPass() { - return new RaiseAllocations(); -}