RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-09 12:36:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Factorize code: remove variants of "strip off

Browse Source 
pointer bitcasts and GEP's", and centralize the
logic in Value::getUnderlyingObject.  The
difference with stripPointerCasts is that
stripPointerCasts only strips GEPs if all
indices are zero, while getUnderlyingObject
strips GEPs no matter what the indices are.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56922 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands 2008-10-01 15:25:41 +00:00
parent 38ac062c2f
commit 5d0392c6b3
7 changed files with 57 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/llvm/Value.h
View File

@ -228,11 +228,20 @@ public:
/// stripPointerCasts - This method strips off any unneeded pointer
/// casts from the specified value, returning the original uncasted value.
/// Note that the returned value is guaranteed to have pointer type.
/// Note that the returned value has pointer type if the specified value does.
Value *stripPointerCasts();
const Value *stripPointerCasts() const {
return const_cast<Value*>(this)->stripPointerCasts();
}
/// getUnderlyingObject - This method strips off any GEP address adjustments
/// and pointer casts from the specified value, returning the original object
/// being addressed. Note that the returned value has pointer type if the
/// specified value does.
Value *getUnderlyingObject();
const Value *getUnderlyingObject() const {
return const_cast<Value*>(this)->getUnderlyingObject();
}
};
inline std::ostream &operator<<(std::ostream &OS, const Value &V) {

32
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -76,30 +76,6 @@ static bool AddressMightEscape(const Value *V) {
return false;
}
/// getUnderlyingObject - This traverses the use chain to figure out what object
/// the specified value points to. If the value points to, or is derived from,
/// a unique object or an argument, return it. This returns:
/// Arguments, GlobalVariables, Functions, Allocas, Mallocs.
static const Value *getUnderlyingObject(const Value *V) {
if (!isa<PointerType>(V->getType())) return V;
// If we are at some type of object, return it. GlobalValues and Allocations
// have unique addresses.
if (isa<GlobalValue>(V) || isa<AllocationInst>(V) || isa<Argument>(V))
return V;
// Traverse through different addressing mechanisms...
if (const Instruction *I = dyn_cast<Instruction>(V)) {
if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I))
return getUnderlyingObject(I->getOperand(0));
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
if (CE->getOpcode() == Instruction::BitCast ||
CE->getOpcode() == Instruction::GetElementPtr)
return getUnderlyingObject(CE->getOperand(0));
}
return V;
}
static const User *isGEP(const Value *V) {
if (isa<GetElementPtrInst>(V) ||
(isa<ConstantExpr>(V) &&
@ -314,7 +290,7 @@ ImmutablePass *llvm::createBasicAliasAnalysisPass() {
/// global) or not.
bool BasicAliasAnalysis::pointsToConstantMemory(const Value *P) {
if (const GlobalVariable *GV =
dyn_cast<GlobalVariable>(getUnderlyingObject(P)))
dyn_cast<GlobalVariable>(P->getUnderlyingObject()))
return GV->isConstant();
return false;
}
@ -327,7 +303,7 @@ bool BasicAliasAnalysis::pointsToConstantMemory(const Value *P) {
AliasAnalysis::ModRefResult
BasicAliasAnalysis::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
if (!isa<Constant>(P)) {
const Value *Object = getUnderlyingObject(P);
const Value *Object = P->getUnderlyingObject();
// If this is a tail call and P points to a stack location, we know that
// the tail call cannot access or modify the local stack.
@ -390,8 +366,8 @@ BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
return alias(V1, V1Size, I->getOperand(0), V2Size);
// Figure out what objects these things are pointing to if we can...
const Value *O1 = getUnderlyingObject(V1);
const Value *O2 = getUnderlyingObject(V2);
const Value *O1 = V1->getUnderlyingObject();
const Value *O2 = V2->getUnderlyingObject();
if (O1 != O2) {
// If V1/V2 point to two different objects we know that we have no alias.

31
lib/Analysis/IPA/GlobalsModRef.cpp
View File

@ -157,29 +157,6 @@ static RegisterAnalysisGroup<AliasAnalysis> Y(X);
Pass *llvm::createGlobalsModRefPass() { return new GlobalsModRef(); }
/// getUnderlyingObject - This traverses the use chain to figure out what object
/// the specified value points to. If the value points to, or is derived from,
/// a global object, return it.
static Value *getUnderlyingObject(Value *V) {
if (!isa<PointerType>(V->getType())) return V;
// If we are at some type of object... return it.
if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) return GV;
// Traverse through different addressing mechanisms.
if (Instruction *I = dyn_cast<Instruction>(V)) {
if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I))
return getUnderlyingObject(I->getOperand(0));
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
if (CE->getOpcode() == Instruction::BitCast ||
CE->getOpcode() == Instruction::GetElementPtr)
return getUnderlyingObject(CE->getOperand(0));
}
// Otherwise, we don't know what this is, return it as the base pointer.
return V;
}
/// AnalyzeGlobals - Scan through the users of all of the internal
/// GlobalValue's in the program. If none of them have their "address taken"
/// (really, their address passed to something nontrivial), record this fact,
@ -304,7 +281,7 @@ bool GlobalsModRef::AnalyzeIndirectGlobalMemory(GlobalValue *GV) {
continue;
// Check the value being stored.
Value *Ptr = getUnderlyingObject(SI->getOperand(0));
Value *Ptr = SI->getOperand(0)->getUnderlyingObject();
if (isa<MallocInst>(Ptr)) {
// Okay, easy case.
@ -468,8 +445,8 @@ AliasAnalysis::AliasResult
GlobalsModRef::alias(const Value *V1, unsigned V1Size,
const Value *V2, unsigned V2Size) {
// Get the base object these pointers point to.
Value *UV1 = getUnderlyingObject(const_cast<Value*>(V1));
Value *UV2 = getUnderlyingObject(const_cast<Value*>(V2));
Value *UV1 = const_cast<Value*>(V1->getUnderlyingObject());
Value *UV2 = const_cast<Value*>(V2->getUnderlyingObject());
// If either of the underlying values is a global, they may be non-addr-taken
// globals, which we can answer queries about.
@ -526,7 +503,7 @@ GlobalsModRef::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
// If we are asking for mod/ref info of a direct call with a pointer to a
// global we are tracking, return information if we have it.
if (GlobalValue *GV = dyn_cast<GlobalValue>(getUnderlyingObject(P)))
if (GlobalValue *GV = dyn_cast<GlobalValue>(P->getUnderlyingObject()))
if (GV->hasInternalLinkage())
if (Function *F = CS.getCalledFunction())
if (NonAddressTakenGlobals.count(GV))

55
lib/Transforms/Scalar/DeadStoreElimination.cpp
View File

@ -59,28 +59,7 @@ namespace {
SetVector<Instruction*>& possiblyDead);
void DeleteDeadInstructionChains(Instruction *I,
SetVector<Instruction*> &DeadInsts);
/// Find the base pointer that a pointer came from
/// Because this is used to find pointers that originate
/// from allocas, it is safe to ignore GEP indices, since
/// either the store will be in the alloca, and thus dead,
/// or beyond the end of the alloca, and thus undefined.
void TranslatePointerBitCasts(Value*& v, bool zeroGepsOnly = false) {
assert(isa<PointerType>(v->getType()) &&
"Translating a non-pointer type?");
while (true) {
if (BitCastInst* C = dyn_cast<BitCastInst>(v))
v = C->getOperand(0);
else if (GetElementPtrInst* G = dyn_cast<GetElementPtrInst>(v))
if (!zeroGepsOnly || G->hasAllZeroIndices()) {
v = G->getOperand(0);
} else {
break;
}
else
break;
}
}
// getAnalysisUsage - We require post dominance frontiers (aka Control
// Dependence Graph)
@ -119,20 +98,20 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) {
// If we find a store or a free...
if (!isa<StoreInst>(BBI) && !isa<FreeInst>(BBI))
continue;
Value* pointer = 0;
if (StoreInst* S = dyn_cast<StoreInst>(BBI)) {
if (!S->isVolatile())
pointer = S->getPointerOperand();
else
if (S->isVolatile())
continue;
} else
pointer = S->getPointerOperand();
} else {
pointer = cast<FreeInst>(BBI)->getPointerOperand();
TranslatePointerBitCasts(pointer, true);
}
pointer = pointer->stripPointerCasts();
StoreInst*& last = lastStore[pointer];
bool deletedStore = false;
// ... to a pointer that has been stored to before...
if (last) {
Instruction* dep = MD.getDependency(BBI);
@ -302,10 +281,9 @@ bool DSE::handleEndBlock(BasicBlock& BB,
// If we find a store whose pointer is dead...
if (StoreInst* S = dyn_cast<StoreInst>(BBI)) {
if (!S->isVolatile()) {
Value* pointerOperand = S->getPointerOperand();
// See through pointer-to-pointer bitcasts
TranslatePointerBitCasts(pointerOperand);
Value* pointerOperand = S->getPointerOperand()->getUnderlyingObject();
// Alloca'd pointers or byval arguments (which are functionally like
// alloca's) are valid candidates for removal.
if (deadPointers.count(pointerOperand)) {
@ -330,9 +308,8 @@ bool DSE::handleEndBlock(BasicBlock& BB,
// We can also remove memcpy's to local variables at the end of a function
} else if (MemCpyInst* M = dyn_cast<MemCpyInst>(BBI)) {
Value* dest = M->getDest();
TranslatePointerBitCasts(dest);
Value* dest = M->getDest()->getUnderlyingObject();
if (deadPointers.count(dest)) {
MD.removeInstruction(M);
@ -480,9 +457,9 @@ bool DSE::handleEndBlock(BasicBlock& BB,
if (!killPointer)
continue;
TranslatePointerBitCasts(killPointer);
killPointer = killPointer->getUnderlyingObject();
// Deal with undead pointers
MadeChange |= RemoveUndeadPointers(killPointer, killPointerSize, BBI,
deadPointers, possiblyDead);

11
lib/Transforms/Scalar/GVN.cpp
View File

@ -992,16 +992,7 @@ bool GVN::processLoad(LoadInst *L, DenseMap<Value*, LoadInst*> &lastLoad,
isa<AllocationInst>(dep)) {
// Check that this load is actually from the
// allocation we found
Value* v = L->getOperand(0);
while (true) {
if (BitCastInst *BC = dyn_cast<BitCastInst>(v))
v = BC->getOperand(0);
else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(v))
v = GEP->getOperand(0);
else
break;
}
if (v == dep) {
if (L->getOperand(0)->getUnderlyingObject() == dep) {
// If this load depends directly on an allocation, there isn't
// anything stored there; therefore, we can optimize this load
// to undef.

24
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -10367,28 +10367,6 @@ static bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom) {
return false;
}
/// GetUnderlyingObject - Trace through a series of getelementptrs and bitcasts
/// until we find the underlying object a pointer is referring to or something
/// we don't understand. Note that the returned pointer may be offset from the
/// input, because we ignore GEP indices.
static Value *GetUnderlyingObject(Value *Ptr) {
while (1) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
if (CE->getOpcode() == Instruction::BitCast ||
CE->getOpcode() == Instruction::GetElementPtr)
Ptr = CE->getOperand(0);
else
return Ptr;
} else if (BitCastInst *BCI = dyn_cast<BitCastInst>(Ptr)) {
Ptr = BCI->getOperand(0);
} else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr)) {
Ptr = GEP->getOperand(0);
} else {
return Ptr;
}
}
}
Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
Value *Op = LI.getOperand(0);
@ -10479,7 +10457,7 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
// If this load comes from anywhere in a constant global, and if the global
// is all undef or zero, we know what it loads.
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Op))) {
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op->getUnderlyingObject())){
if (GV->isConstant() && GV->hasInitializer()) {
if (GV->getInitializer()->isNullValue())
return ReplaceInstUsesWith(LI, Constant::getNullValue(LI.getType()));

29
lib/VMCore/Value.cpp
View File

@ -322,22 +322,20 @@ void Value::replaceAllUsesWith(Value *New) {
}
Value *Value::stripPointerCasts() {
if (!isa<PointerType>(getType()))
return this;
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
if (CE->getOpcode() == Instruction::BitCast) {
if (isa<PointerType>(CE->getOperand(0)->getType()))
return CE->getOperand(0)->stripPointerCasts();
return CE->getOperand(0)->stripPointerCasts();
} else if (CE->getOpcode() == Instruction::GetElementPtr) {
for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
if (!CE->getOperand(i)->isNullValue())
return this;
return CE->getOperand(0)->stripPointerCasts();
}
return this;
}
if (BitCastInst *CI = dyn_cast<BitCastInst>(this)) {
if (isa<PointerType>(CI->getOperand(0)->getType()))
return CI->getOperand(0)->stripPointerCasts();
} else if (BitCastInst *CI = dyn_cast<BitCastInst>(this)) {
return CI->getOperand(0)->stripPointerCasts();
} else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(this)) {
if (GEP->hasAllZeroIndices())
return GEP->getOperand(0)->stripPointerCasts();
@ -345,6 +343,21 @@ Value *Value::stripPointerCasts() {
return this;
}
Value *Value::getUnderlyingObject() {
if (!isa<PointerType>(getType()))
return this;
if (Instruction *I = dyn_cast<Instruction>(this)) {
if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I))
return I->getOperand(0)->getUnderlyingObject();
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
if (CE->getOpcode() == Instruction::BitCast ||
CE->getOpcode() == Instruction::GetElementPtr)
return CE->getOperand(0)->getUnderlyingObject();
}
return this;
}
//===----------------------------------------------------------------------===//
// User Class
//===----------------------------------------------------------------------===//