mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-23 04:28:30 +00:00
Split ChangeAllocations.cpp into Raise & LowerAllocations.cpp
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2529 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
parent
148a0bfcea
commit
ade686e79b
108
lib/Transforms/IPO/RaiseAllocations.cpp
Normal file
108
lib/Transforms/IPO/RaiseAllocations.cpp
Normal file
@ -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<const Type*>(1, Type::UIntTy), false);
|
||||
|
||||
const FunctionType *FreeType = // Get the type for free
|
||||
FunctionType::get(Type::VoidTy,
|
||||
std::vector<const Type*>(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<CallInst>(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;
|
||||
}
|
||||
@ -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<const Type*>(1, Type::UIntTy), false);
|
||||
|
||||
const FunctionType *FreeType = // Get the type for free
|
||||
FunctionType::get(Type::VoidTy,
|
||||
vector<const Type*>(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<CallInst>(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();
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user