[llvm-commits] CVS: poolalloc/lib/PoolAllocate/PoolAllocate.cpp PoolAllocate.h PoolOptimize.cpp TransformFunctionBody.cpp
Chris Lattner
lattner at cs.uiuc.edu
Mon Nov 15 13:05:20 PST 2004
Changes in directory poolalloc/lib/PoolAllocate:
PoolAllocate.cpp updated: 1.93 -> 1.94
PoolAllocate.h updated: 1.31 -> 1.32
PoolOptimize.cpp updated: 1.1 -> 1.2
TransformFunctionBody.cpp updated: 1.32 -> 1.33
---
Log message:
Implement support for memalign and initial support for posix_memalign,
transforming them into poolmemalign.
---
Diffs of the changes: (+104 -8)
Index: poolalloc/lib/PoolAllocate/PoolAllocate.cpp
diff -u poolalloc/lib/PoolAllocate/PoolAllocate.cpp:1.93 poolalloc/lib/PoolAllocate/PoolAllocate.cpp:1.94
--- poolalloc/lib/PoolAllocate/PoolAllocate.cpp:1.93 Wed Nov 10 17:41:04 2004
+++ poolalloc/lib/PoolAllocate/PoolAllocate.cpp Mon Nov 15 15:05:09 2004
@@ -165,6 +165,10 @@
PoolRealloc = CurModule->getOrInsertFunction("poolrealloc",
VoidPtrTy, PoolDescPtrTy,
VoidPtrTy, Type::UIntTy, 0);
+ // The poolmemalign function.
+ PoolMemAlign = CurModule->getOrInsertFunction("poolmemalign",
+ VoidPtrTy, PoolDescPtrTy,
+ Type::UIntTy, Type::UIntTy, 0);
// Get the poolfree function.
PoolFree = CurModule->getOrInsertFunction("poolfree", Type::VoidTy,
Index: poolalloc/lib/PoolAllocate/PoolAllocate.h
diff -u poolalloc/lib/PoolAllocate/PoolAllocate.h:1.31 poolalloc/lib/PoolAllocate/PoolAllocate.h:1.32
--- poolalloc/lib/PoolAllocate/PoolAllocate.h:1.31 Wed Nov 10 15:13:47 2004
+++ poolalloc/lib/PoolAllocate/PoolAllocate.h Mon Nov 15 15:05:09 2004
@@ -95,7 +95,8 @@
public:
- Function *PoolInit, *PoolDestroy, *PoolAlloc, *PoolRealloc, *PoolFree;
+ Function *PoolInit, *PoolDestroy, *PoolAlloc, *PoolRealloc, *PoolMemAlign;
+ Function *PoolFree;
static const Type *PoolDescPtrTy;
PA::Heuristic *CurHeuristic;
Index: poolalloc/lib/PoolAllocate/PoolOptimize.cpp
diff -u poolalloc/lib/PoolAllocate/PoolOptimize.cpp:1.1 poolalloc/lib/PoolAllocate/PoolOptimize.cpp:1.2
--- poolalloc/lib/PoolAllocate/PoolOptimize.cpp:1.1 Wed Nov 10 17:40:49 2004
+++ poolalloc/lib/PoolAllocate/PoolOptimize.cpp Mon Nov 15 15:05:09 2004
@@ -59,6 +59,10 @@
Function *PoolRealloc = M.getOrInsertFunction("poolrealloc",
VoidPtrTy, PoolDescPtrTy,
VoidPtrTy, Type::UIntTy, 0);
+ // The poolmemalign function.
+ Function *PoolMemAlign = M.getOrInsertFunction("poolmemalign",
+ VoidPtrTy, PoolDescPtrTy,
+ Type::UIntTy, Type::UIntTy, 0);
// Get the poolfree function.
Function *PoolFree = M.getOrInsertFunction("poolfree", Type::VoidTy,
@@ -81,6 +85,9 @@
Function *Realloc = M.getOrInsertFunction("realloc",
VoidPtrTy, VoidPtrTy, Type::UIntTy,
0);
+ Function *MemAlign = M.getOrInsertFunction("memalign",
+ VoidPtrTy, Type::UIntTy,
+ Type::UIntTy, 0);
// Optimize poolreallocs
@@ -130,6 +137,21 @@
}
}
+ // Optimize poolmemaligns
+ getCallsOf(PoolFree, Calls);
+ for (unsigned i = 0, e = Calls.size(); i != e; ++i) {
+ CallInst *CI = Calls[i];
+ // poolmemalign(null, X, Y) -> memalign(X, Y)
+ if (isa<ConstantPointerNull>(CI->getOperand(1))) {
+ std::vector<Value*> Ops;
+ Ops.push_back(CI->getOperand(2));
+ Ops.push_back(CI->getOperand(3));
+ Value *New = new CallInst(MemAlign, Ops, CI->getName(), CI);
+ CI->replaceAllUsesWith(New);
+ CI->eraseFromParent();
+ }
+ }
+
// Optimize poolfrees
getCallsOf(PoolFree, Calls);
for (unsigned i = 0, e = Calls.size(); i != e; ++i) {
Index: poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp
diff -u poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp:1.32 poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp:1.33
--- poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp:1.32 Thu Nov 4 14:13:00 2004
+++ poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp Mon Nov 15 15:05:09 2004
@@ -63,6 +63,7 @@
void visitMallocInst(MallocInst &MI);
void visitCallocCall(CallSite CS);
void visitReallocCall(CallSite CS);
+ void visitMemAlignCall(CallSite CS);
void visitFreeInst(FreeInst &FI);
void visitCallSite(CallSite CS);
void visitCallInst(CallInst &CI) { visitCallSite(&CI); }
@@ -232,8 +233,8 @@
void FuncTransform::visitCallocCall(CallSite CS) {
Module *M = CS.getInstruction()->getParent()->getParent()->getParent();
assert(CS.arg_end()-CS.arg_begin() == 2 && "calloc takes two arguments!");
- Value *V1 = *CS.arg_begin();
- Value *V2 = *(CS.arg_begin()+1);
+ Value *V1 = CS.getArgument(0);
+ Value *V2 = CS.getArgument(1);
if (V1->getType() != V2->getType()) {
V1 = new CastInst(V1, Type::UIntTy, V1->getName(), CS.getInstruction());
V2 = new CastInst(V2, Type::UIntTy, V2->getName(), CS.getInstruction());
@@ -271,8 +272,8 @@
assert(CS.arg_end()-CS.arg_begin() == 2 && "realloc takes two arguments!");
Instruction *I = CS.getInstruction();
Value *PH = getPoolHandle(I);
- Value *OldPtr = *CS.arg_begin();
- Value *Size = *(CS.arg_begin()+1);
+ Value *OldPtr = CS.getArgument(0);
+ Value *Size = CS.getArgument(1);
if (Size->getType() != Type::UIntTy)
Size = new CastInst(Size, Type::UIntTy, Size->getName(), I);
@@ -307,6 +308,71 @@
}
+/// visitMemAlignCall - Handle memalign and posix_memalign.
+///
+void FuncTransform::visitMemAlignCall(CallSite CS) {
+ Instruction *I = CS.getInstruction();
+ Value *ResultDest = 0;
+ Value *Align = 0;
+ Value *Size = 0;
+ Value *PH;
+
+ if (CS.getCalledFunction()->getName() == "memalign") {
+ Align = CS.getArgument(0);
+ Size = CS.getArgument(1);
+ PH = getPoolHandle(I);
+ } else {
+ assert(CS.getCalledFunction()->getName() == "posix_memalign");
+ ResultDest = CS.getArgument(0);
+ Align = CS.getArgument(1);
+ Size = CS.getArgument(2);
+
+ assert(0 && "posix_memalign not implemented fully!");
+ // We need to get the pool descriptor corresponding to *ResultDest.
+ PH = getPoolHandle(I);
+
+ // Return success always.
+ Value *RetVal = Constant::getNullValue(I->getType());
+ I->replaceAllUsesWith(RetVal);
+
+ static const Type *PtrPtr=PointerType::get(PointerType::get(Type::SByteTy));
+ if (ResultDest->getType() != PtrPtr)
+ ResultDest = new CastInst(ResultDest, PtrPtr, ResultDest->getName(), I);
+ }
+
+ if (Align->getType() != Type::UIntTy)
+ Align = new CastInst(Align, Type::UIntTy, Align->getName(), I);
+ if (Size->getType() != Type::UIntTy)
+ Size = new CastInst(Size, Type::UIntTy, Size->getName(), I);
+
+ std::string Name = I->getName(); I->setName("");
+ Instruction *V = new CallInst(PAInfo.PoolMemAlign,
+ make_vector(PH, Align, Size, 0), Name, I);
+
+ Instruction *Casted = V;
+ if (V->getType() != I->getType())
+ Casted = new CastInst(V, I->getType(), V->getName(), I);
+
+ if (ResultDest)
+ new StoreInst(V, ResultDest, I);
+ else
+ I->replaceAllUsesWith(Casted);
+
+ // If we are modifying the original function, update the DSGraph.
+ if (!FI.Clone) {
+ // V and Casted now point to whatever the original allocation did.
+ G.getScalarMap().replaceScalar(I, V);
+ if (V != Casted)
+ G.getScalarMap()[Casted] = G.getScalarMap()[V];
+ } else { // Otherwise, update the NewToOldValueMap
+ UpdateNewToOldValueMap(I, V, V != Casted ? Casted : 0);
+ }
+
+ // Remove old allocation instruction.
+ I->eraseFromParent();
+}
+
+
void FuncTransform::visitCallSite(CallSite CS) {
Function *CF = CS.getCalledFunction();
@@ -335,11 +401,14 @@
} else if (CF->getName() == "realloc") {
visitReallocCall(CS);
return;
- } else if (CF->getName() == "strdup") {
- assert(0 && "strdup should have been linked into the program!");
} else if (CF->getName() == "memalign" ||
CF->getName() == "posix_memalign") {
- std::cerr << "MEMALIGN USED BUT NOT HANDLED!\n";
+ visitMemAlignCall(CS);
+ return;
+ } else if (CF->getName() == "strdup") {
+ assert(0 && "strdup should have been linked into the program!");
+ } else if (CF->getName() == "valloc") {
+ std::cerr << "VALLOC USED BUT NOT HANDLED!\n";
abort();
}
More information about the llvm-commits
mailing list