From 73ec3cdd7140aee6d2b9ac32bc2298254ff48c97 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 30 Nov 2008 01:26:32 +0000 Subject: [PATCH] implement a fixme by introducing a new getDependencyFromInternal method that returns its result as a DepResultTy instead of as a MemDepResult. This reduces conversion back and forth. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60266 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../llvm/Analysis/MemoryDependenceAnalysis.h | 25 +++++------ lib/Analysis/MemoryDependenceAnalysis.cpp | 43 ++++++++----------- 2 files changed, 32 insertions(+), 36 deletions(-) diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h index 00dcaf508c1..fa457187589 100644 --- a/include/llvm/Analysis/MemoryDependenceAnalysis.h +++ b/include/llvm/Analysis/MemoryDependenceAnalysis.h @@ -170,8 +170,13 @@ namespace llvm { /// getDependencyFrom - Return the instruction on which the memory operation /// 'QueryInst' depends. This starts scanning from the instruction before /// the position indicated by ScanIt. + /// + /// Note that this method does no caching at all. You should use + /// getDependency where possible. MemDepResult getDependencyFrom(Instruction *QueryInst, - BasicBlock::iterator ScanIt, BasicBlock *BB); + BasicBlock::iterator ScanIt, BasicBlock *BB){ + return ConvToResult(getDependencyFromInternal(QueryInst, ScanIt, BB)); + } /// getNonLocalDependency - Perform a full dependency query for the @@ -190,15 +195,6 @@ namespace llvm { void removeInstruction(Instruction *InstToRemove); private: - DepResultTy ConvFromResult(MemDepResult R) { - if (Instruction *I = R.getInst()) - return DepResultTy(I, Normal); - if (R.isNonLocal()) - return DepResultTy(0, NonLocal); - assert(R.isNone() && "Unknown MemDepResult!"); - return DepResultTy(0, None); - } - MemDepResult ConvToResult(DepResultTy R) { if (R.getInt() == Normal) return MemDepResult::get(R.getPointer()); @@ -212,8 +208,13 @@ namespace llvm { /// in our internal data structures. void verifyRemoved(Instruction *Inst) const; - MemDepResult getCallSiteDependency(CallSite C, BasicBlock::iterator ScanIt, - BasicBlock *BB); + /// getDependencyFromInternal - Return the instruction on which the memory + /// operation 'QueryInst' depends. This starts scanning from the + /// instruction before the position indicated by ScanIt. + DepResultTy getDependencyFromInternal(Instruction *QueryInst, + BasicBlock::iterator ScanIt, BasicBlock *BB); + DepResultTy getCallSiteDependency(CallSite C, BasicBlock::iterator ScanIt, + BasicBlock *BB); }; } // End llvm namespace diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp index b034f7d3bc2..94a3d1ba789 100644 --- a/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -47,7 +47,7 @@ void MemoryDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { /// getCallSiteDependency - Private helper for finding the local dependencies /// of a call site. -MemDepResult MemoryDependenceAnalysis:: +MemoryDependenceAnalysis::DepResultTy MemoryDependenceAnalysis:: getCallSiteDependency(CallSite C, BasicBlock::iterator ScanIt, BasicBlock *BB) { AliasAnalysis &AA = getAnalysis(); @@ -84,24 +84,24 @@ getCallSiteDependency(CallSite C, BasicBlock::iterator ScanIt, if (AA.getModRefBehavior(CallSite::get(Inst)) == AliasAnalysis::DoesNotAccessMemory) continue; - return MemDepResult::get(Inst); + return DepResultTy(Inst, Normal); } else continue; if (AA.getModRefInfo(C, Pointer, PointerSize) != AliasAnalysis::NoModRef) - return MemDepResult::get(Inst); + return DepResultTy(Inst, Normal); } // No dependence found. - return MemDepResult::getNonLocal(); + return DepResultTy(0, NonLocal); } /// getDependency - Return the instruction on which a memory operation /// depends. The local parameter indicates if the query should only /// evaluate dependencies within the same basic block. -MemDepResult MemoryDependenceAnalysis:: -getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, - BasicBlock *BB) { +MemoryDependenceAnalysis::DepResultTy MemoryDependenceAnalysis:: +getDependencyFromInternal(Instruction *QueryInst, BasicBlock::iterator ScanIt, + BasicBlock *BB) { AliasAnalysis &AA = getAnalysis(); TargetData &TD = getAnalysis(); @@ -128,7 +128,7 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, } else if (isa(QueryInst) || isa(QueryInst)) return getCallSiteDependency(CallSite::get(QueryInst), ScanIt, BB); else // Non-memory instructions depend on nothing. - return MemDepResult::getNone(); + return DepResultTy(0, None); // Walk backwards through the basic block, looking for dependencies while (ScanIt != BB->begin()) { @@ -139,7 +139,7 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, if (MemVolatile && ((isa(Inst) && cast(Inst)->isVolatile()) || (isa(Inst) && cast(Inst)->isVolatile()))) - return MemDepResult::get(Inst); + return DepResultTy(Inst, Normal); // MemDep is broken w.r.t. loads: it says that two loads of the same pointer // depend on each other. :( @@ -157,7 +157,7 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, // May-alias loads don't depend on each other without a dependence. if (isa(QueryInst) && R == AliasAnalysis::MayAlias) continue; - return MemDepResult::get(Inst); + return DepResultTy(Inst, Normal); } // FIXME: This claims that an access depends on the allocation. This may @@ -179,7 +179,7 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, if (R == AliasAnalysis::NoAlias) continue; - return MemDepResult::get(Inst); + return DepResultTy(Inst, Normal); } @@ -194,11 +194,11 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt, continue; // Otherwise, there is a dependence. - return MemDepResult::get(Inst); + return DepResultTy(Inst, Normal); } // If we found nothing, return the non-local flag. - return MemDepResult::getNonLocal(); + return DepResultTy(0, NonLocal); } /// getDependency - Return the instruction on which a memory operation @@ -220,16 +220,14 @@ MemDepResult MemoryDependenceAnalysis::getDependency(Instruction *QueryInst) { ScanPos = Inst; // Do the scan. - MemDepResult Res = - getDependencyFrom(QueryInst, ScanPos, QueryInst->getParent()); + LocalCache = getDependencyFromInternal(QueryInst, ScanPos, + QueryInst->getParent()); // Remember the result! - // FIXME: Don't convert back and forth! Make a shared helper function. - LocalCache = ConvFromResult(Res); - if (Instruction *I = Res.getInst()) + if (Instruction *I = LocalCache.getPointer()) ReverseLocalDeps[I].insert(QueryInst); - return Res; + return ConvToResult(LocalCache); } /// getNonLocalDependency - Perform a full dependency query for the @@ -287,17 +285,14 @@ getNonLocalDependency(Instruction *QueryInst, // If DirtyBBEntry isn't dirty, it ended up on the worklist multiple times. if (DirtyBBEntry.getInt() != Dirty) continue; - // Find out if this block has a local dependency for QueryInst. - // FIXME: Don't convert back and forth for MemDepResult <-> DepResultTy. - // If the dirty entry has a pointer, start scanning from it so we don't have // to rescan the entire block. BasicBlock::iterator ScanPos = DirtyBB->end(); if (Instruction *Inst = DirtyBBEntry.getPointer()) ScanPos = Inst; - DirtyBBEntry = ConvFromResult(getDependencyFrom(QueryInst, ScanPos, - DirtyBB)); + // Find out if this block has a local dependency for QueryInst. + DirtyBBEntry = getDependencyFromInternal(QueryInst, ScanPos, DirtyBB); // If the block has a dependency (i.e. it isn't completely transparent to // the value), remember it!