From: Duncan Sands Date: Wed, 1 Oct 2008 15:25:41 +0000 (+0000) Subject: Factorize code: remove variants of "strip off X-Git-Tag: android-x86-6.0-r1~1003^2~25582 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=5d0392c6b370758750b397e254a6c6f028479969;p=android-x86%2Fexternal-llvm.git Factorize code: remove variants of "strip off 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 --- diff --git a/include/llvm/Value.h b/include/llvm/Value.h index f9edba116b5..95e175fae39 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -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(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(this)->getUnderlyingObject(); + } }; inline std::ostream &operator<<(std::ostream &OS, const Value &V) { diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp index aa47fb3be50..22b73b28400 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -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(V->getType())) return V; - - // If we are at some type of object, return it. GlobalValues and Allocations - // have unique addresses. - if (isa(V) || isa(V) || isa(V)) - return V; - - // Traverse through different addressing mechanisms... - if (const Instruction *I = dyn_cast(V)) { - if (isa(I) || isa(I)) - return getUnderlyingObject(I->getOperand(0)); - } else if (const ConstantExpr *CE = dyn_cast(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(V) || (isa(V) && @@ -314,7 +290,7 @@ ImmutablePass *llvm::createBasicAliasAnalysisPass() { /// global) or not. bool BasicAliasAnalysis::pointsToConstantMemory(const Value *P) { if (const GlobalVariable *GV = - dyn_cast(getUnderlyingObject(P))) + dyn_cast(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(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. diff --git a/lib/Analysis/IPA/GlobalsModRef.cpp b/lib/Analysis/IPA/GlobalsModRef.cpp index 74327d5c60b..99e9d215b01 100644 --- a/lib/Analysis/IPA/GlobalsModRef.cpp +++ b/lib/Analysis/IPA/GlobalsModRef.cpp @@ -157,29 +157,6 @@ static RegisterAnalysisGroup 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(V->getType())) return V; - - // If we are at some type of object... return it. - if (GlobalValue *GV = dyn_cast(V)) return GV; - - // Traverse through different addressing mechanisms. - if (Instruction *I = dyn_cast(V)) { - if (isa(I) || isa(I)) - return getUnderlyingObject(I->getOperand(0)); - } else if (ConstantExpr *CE = dyn_cast(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(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(V1)); - Value *UV2 = getUnderlyingObject(const_cast(V2)); + Value *UV1 = const_cast(V1->getUnderlyingObject()); + Value *UV2 = const_cast(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(getUnderlyingObject(P))) + if (GlobalValue *GV = dyn_cast(P->getUnderlyingObject())) if (GV->hasInternalLinkage()) if (Function *F = CS.getCalledFunction()) if (NonAddressTakenGlobals.count(GV)) diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp index 7e5fbcb8014..c9211c32523 100644 --- a/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -59,28 +59,7 @@ namespace { SetVector& possiblyDead); void DeleteDeadInstructionChains(Instruction *I, SetVector &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(v->getType()) && - "Translating a non-pointer type?"); - while (true) { - if (BitCastInst* C = dyn_cast(v)) - v = C->getOperand(0); - else if (GetElementPtrInst* G = dyn_cast(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(BBI) && !isa(BBI)) continue; - + Value* pointer = 0; if (StoreInst* S = dyn_cast(BBI)) { - if (!S->isVolatile()) - pointer = S->getPointerOperand(); - else + if (S->isVolatile()) continue; - } else + pointer = S->getPointerOperand(); + } else { pointer = cast(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(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(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); diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp index 1e5be4ab1a7..25b61c10957 100644 --- a/lib/Transforms/Scalar/GVN.cpp +++ b/lib/Transforms/Scalar/GVN.cpp @@ -992,16 +992,7 @@ bool GVN::processLoad(LoadInst *L, DenseMap &lastLoad, isa(dep)) { // Check that this load is actually from the // allocation we found - Value* v = L->getOperand(0); - while (true) { - if (BitCastInst *BC = dyn_cast(v)) - v = BC->getOperand(0); - else if (GetElementPtrInst *GEP = dyn_cast(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. diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 6cac395405b..4f489718f6f 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -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(Ptr)) { - if (CE->getOpcode() == Instruction::BitCast || - CE->getOpcode() == Instruction::GetElementPtr) - Ptr = CE->getOperand(0); - else - return Ptr; - } else if (BitCastInst *BCI = dyn_cast(Ptr)) { - Ptr = BCI->getOperand(0); - } else if (GetElementPtrInst *GEP = dyn_cast(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(GetUnderlyingObject(Op))) { + if (GlobalVariable *GV = dyn_cast(Op->getUnderlyingObject())){ if (GV->isConstant() && GV->hasInitializer()) { if (GV->getInitializer()->isNullValue()) return ReplaceInstUsesWith(LI, Constant::getNullValue(LI.getType())); diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index d143b6bf97e..0976a745991 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -322,22 +322,20 @@ void Value::replaceAllUsesWith(Value *New) { } Value *Value::stripPointerCasts() { + if (!isa(getType())) + return this; + if (ConstantExpr *CE = dyn_cast(this)) { if (CE->getOpcode() == Instruction::BitCast) { - if (isa(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(this)) { - if (isa(CI->getOperand(0)->getType())) - return CI->getOperand(0)->stripPointerCasts(); + } else if (BitCastInst *CI = dyn_cast(this)) { + return CI->getOperand(0)->stripPointerCasts(); } else if (GetElementPtrInst *GEP = dyn_cast(this)) { if (GEP->hasAllZeroIndices()) return GEP->getOperand(0)->stripPointerCasts(); @@ -345,6 +343,21 @@ Value *Value::stripPointerCasts() { return this; } +Value *Value::getUnderlyingObject() { + if (!isa(getType())) + return this; + + if (Instruction *I = dyn_cast(this)) { + if (isa(I) || isa(I)) + return I->getOperand(0)->getUnderlyingObject(); + } else if (ConstantExpr *CE = dyn_cast(this)) { + if (CE->getOpcode() == Instruction::BitCast || + CE->getOpcode() == Instruction::GetElementPtr) + return CE->getOperand(0)->getUnderlyingObject(); + } + return this; +} + //===----------------------------------------------------------------------===// // User Class //===----------------------------------------------------------------------===//