2007-07-06 23:14:35 +00:00
|
|
|
//===- MemoryDependenceAnalysis.cpp - Mem Deps Implementation --*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-07-06 23:14:35 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements an analysis that determines, for a given memory
|
|
|
|
// operation, what preceding memory operations it depends on. It builds on
|
2007-08-08 22:01:54 +00:00
|
|
|
// alias analysis information, and tries to provide a lazy, caching interface to
|
2007-07-06 23:14:35 +00:00
|
|
|
// a common kind of alias information query.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-11-28 21:45:17 +00:00
|
|
|
#define DEBUG_TYPE "memdep"
|
2007-07-06 23:14:35 +00:00
|
|
|
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
|
|
|
|
#include "llvm/Instructions.h"
|
2009-03-09 05:12:38 +00:00
|
|
|
#include "llvm/IntrinsicInst.h"
|
2007-07-06 23:14:35 +00:00
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2009-11-27 22:05:15 +00:00
|
|
|
#include "llvm/Analysis/Dominators.h"
|
teach phi translation of GEPs to simplify geps like 'gep x, 0'.
This allows us to compile the example from PR5313 into:
LBB1_2: ## %bb
incl %ecx
movb %al, (%rsi)
movslq %ecx, %rax
movb (%rdi,%rax), %al
testb %al, %al
jne LBB1_2
instead of:
LBB1_2: ## %bb
movslq %eax, %rcx
incl %eax
movb (%rdi,%rcx), %cl
movb %cl, (%rsi)
movslq %eax, %rcx
cmpb $0, (%rdi,%rcx)
jne LBB1_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@89981 91177308-0d34-0410-b5e6-96231b3b80d8
2009-11-27 00:34:38 +00:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
2009-10-27 20:05:49 +00:00
|
|
|
#include "llvm/Analysis/MemoryBuiltins.h"
|
2009-12-09 01:59:31 +00:00
|
|
|
#include "llvm/Analysis/PHITransAddr.h"
|
2008-11-28 22:28:27 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2008-12-10 09:38:36 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2008-12-09 06:28:49 +00:00
|
|
|
#include "llvm/Support/PredIteratorCache.h"
|
2008-11-28 21:45:17 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2007-07-06 23:14:35 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
STATISTIC(NumCacheNonLocal, "Number of fully cached non-local responses");
|
|
|
|
STATISTIC(NumCacheDirtyNonLocal, "Number of dirty cached non-local responses");
|
2008-11-29 22:02:15 +00:00
|
|
|
STATISTIC(NumUncacheNonLocal, "Number of uncached non-local responses");
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
STATISTIC(NumCacheNonLocalPtr,
|
|
|
|
"Number of fully cached non-local ptr responses");
|
|
|
|
STATISTIC(NumCacheDirtyNonLocalPtr,
|
|
|
|
"Number of cached, but dirty, non-local ptr responses");
|
|
|
|
STATISTIC(NumUncacheNonLocalPtr,
|
|
|
|
"Number of uncached non-local ptr responses");
|
2008-12-08 07:31:50 +00:00
|
|
|
STATISTIC(NumCacheCompleteNonLocalPtr,
|
|
|
|
"Number of block queries that were completely cached");
|
2008-12-07 08:50:20 +00:00
|
|
|
|
2007-07-06 23:14:35 +00:00
|
|
|
char MemoryDependenceAnalysis::ID = 0;
|
|
|
|
|
|
|
|
// Register this pass...
|
2007-07-10 20:21:08 +00:00
|
|
|
static RegisterPass<MemoryDependenceAnalysis> X("memdep",
|
2008-11-28 21:45:17 +00:00
|
|
|
"Memory Dependence Analysis", false, true);
|
2007-07-06 23:14:35 +00:00
|
|
|
|
2008-12-09 06:28:49 +00:00
|
|
|
MemoryDependenceAnalysis::MemoryDependenceAnalysis()
|
|
|
|
: FunctionPass(&ID), PredCache(0) {
|
|
|
|
}
|
|
|
|
MemoryDependenceAnalysis::~MemoryDependenceAnalysis() {
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Clean up memory in between runs
|
|
|
|
void MemoryDependenceAnalysis::releaseMemory() {
|
|
|
|
LocalDeps.clear();
|
|
|
|
NonLocalDeps.clear();
|
|
|
|
NonLocalPointerDeps.clear();
|
|
|
|
ReverseLocalDeps.clear();
|
|
|
|
ReverseNonLocalDeps.clear();
|
|
|
|
ReverseNonLocalPtrDeps.clear();
|
|
|
|
PredCache->clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2007-07-06 23:14:35 +00:00
|
|
|
/// getAnalysisUsage - Does not modify anything. It uses Alias Analysis.
|
|
|
|
///
|
|
|
|
void MemoryDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
|
|
|
AU.addRequiredTransitive<AliasAnalysis>();
|
|
|
|
}
|
|
|
|
|
2008-11-30 19:24:31 +00:00
|
|
|
bool MemoryDependenceAnalysis::runOnFunction(Function &) {
|
|
|
|
AA = &getAnalysis<AliasAnalysis>();
|
2008-12-09 06:28:49 +00:00
|
|
|
if (PredCache == 0)
|
|
|
|
PredCache.reset(new PredIteratorCache());
|
2008-11-30 19:24:31 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-12-07 18:39:13 +00:00
|
|
|
/// RemoveFromReverseMap - This is a helper function that removes Val from
|
|
|
|
/// 'Inst's set in ReverseMap. If the set becomes empty, remove Inst's entry.
|
|
|
|
template <typename KeyTy>
|
|
|
|
static void RemoveFromReverseMap(DenseMap<Instruction*,
|
2009-03-29 00:24:04 +00:00
|
|
|
SmallPtrSet<KeyTy, 4> > &ReverseMap,
|
|
|
|
Instruction *Inst, KeyTy Val) {
|
|
|
|
typename DenseMap<Instruction*, SmallPtrSet<KeyTy, 4> >::iterator
|
2008-12-07 18:39:13 +00:00
|
|
|
InstIt = ReverseMap.find(Inst);
|
|
|
|
assert(InstIt != ReverseMap.end() && "Reverse map out of sync?");
|
|
|
|
bool Found = InstIt->second.erase(Val);
|
|
|
|
assert(Found && "Invalid reverse map!"); Found=Found;
|
|
|
|
if (InstIt->second.empty())
|
|
|
|
ReverseMap.erase(InstIt);
|
|
|
|
}
|
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
|
2008-12-07 00:35:51 +00:00
|
|
|
/// getCallSiteDependencyFrom - Private helper for finding the local
|
|
|
|
/// dependencies of a call site.
|
2008-11-30 23:17:19 +00:00
|
|
|
MemDepResult MemoryDependenceAnalysis::
|
2008-12-09 21:19:42 +00:00
|
|
|
getCallSiteDependencyFrom(CallSite CS, bool isReadOnlyCall,
|
|
|
|
BasicBlock::iterator ScanIt, BasicBlock *BB) {
|
2007-08-08 22:26:03 +00:00
|
|
|
// Walk backwards through the block, looking for dependencies
|
2008-11-29 03:47:00 +00:00
|
|
|
while (ScanIt != BB->begin()) {
|
|
|
|
Instruction *Inst = --ScanIt;
|
2007-07-10 17:59:22 +00:00
|
|
|
|
|
|
|
// If this inst is a memory op, get the pointer it accessed
|
2008-11-29 09:15:21 +00:00
|
|
|
Value *Pointer = 0;
|
|
|
|
uint64_t PointerSize = 0;
|
|
|
|
if (StoreInst *S = dyn_cast<StoreInst>(Inst)) {
|
|
|
|
Pointer = S->getPointerOperand();
|
2009-07-31 20:53:12 +00:00
|
|
|
PointerSize = AA->getTypeStoreSize(S->getOperand(0)->getType());
|
2008-11-29 09:15:21 +00:00
|
|
|
} else if (VAArgInst *V = dyn_cast<VAArgInst>(Inst)) {
|
|
|
|
Pointer = V->getOperand(0);
|
2009-07-31 20:53:12 +00:00
|
|
|
PointerSize = AA->getTypeStoreSize(V->getType());
|
2009-10-26 23:43:48 +00:00
|
|
|
} else if (isFreeCall(Inst)) {
|
|
|
|
Pointer = Inst->getOperand(1);
|
|
|
|
// calls to free() erase the entire structure
|
2008-12-07 08:50:20 +00:00
|
|
|
PointerSize = ~0ULL;
|
2008-11-29 09:15:21 +00:00
|
|
|
} else if (isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) {
|
2009-03-09 05:12:38 +00:00
|
|
|
// Debug intrinsics don't cause dependences.
|
2009-03-11 21:13:01 +00:00
|
|
|
if (isa<DbgInfoIntrinsic>(Inst)) continue;
|
2008-12-05 21:04:20 +00:00
|
|
|
CallSite InstCS = CallSite::get(Inst);
|
|
|
|
// If these two calls do not interfere, look past it.
|
2008-12-09 21:19:42 +00:00
|
|
|
switch (AA->getModRefInfo(CS, InstCS)) {
|
|
|
|
case AliasAnalysis::NoModRef:
|
|
|
|
// If the two calls don't interact (e.g. InstCS is readnone) keep
|
|
|
|
// scanning.
|
2008-11-29 09:15:21 +00:00
|
|
|
continue;
|
2008-12-09 21:19:42 +00:00
|
|
|
case AliasAnalysis::Ref:
|
|
|
|
// If the two calls read the same memory locations and CS is a readonly
|
|
|
|
// function, then we have two cases: 1) the calls may not interfere with
|
|
|
|
// each other at all. 2) the calls may produce the same value. In case
|
|
|
|
// #1 we want to ignore the values, in case #2, we want to return Inst
|
|
|
|
// as a Def dependence. This allows us to CSE in cases like:
|
|
|
|
// X = strlen(P);
|
|
|
|
// memchr(...);
|
|
|
|
// Y = strlen(P); // Y = X
|
|
|
|
if (isReadOnlyCall) {
|
|
|
|
if (CS.getCalledFunction() != 0 &&
|
|
|
|
CS.getCalledFunction() == InstCS.getCalledFunction())
|
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
// Ignore unrelated read/read call dependences.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// FALL THROUGH
|
|
|
|
default:
|
2008-12-05 21:04:20 +00:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2008-12-09 21:19:42 +00:00
|
|
|
}
|
2008-11-30 01:44:00 +00:00
|
|
|
} else {
|
|
|
|
// Non-memory instruction.
|
2007-07-10 20:39:07 +00:00
|
|
|
continue;
|
2008-11-30 01:44:00 +00:00
|
|
|
}
|
2007-07-10 17:59:22 +00:00
|
|
|
|
2008-12-05 21:04:20 +00:00
|
|
|
if (AA->getModRefInfo(CS, Pointer, PointerSize) != AliasAnalysis::NoModRef)
|
|
|
|
return MemDepResult::getClobber(Inst);
|
2007-07-10 17:59:22 +00:00
|
|
|
}
|
|
|
|
|
2008-12-07 02:15:47 +00:00
|
|
|
// No dependence found. If this is the entry block of the function, it is a
|
|
|
|
// clobber, otherwise it is non-local.
|
|
|
|
if (BB != &BB->getParent()->getEntryBlock())
|
|
|
|
return MemDepResult::getNonLocal();
|
|
|
|
return MemDepResult::getClobber(ScanIt);
|
2007-07-10 17:59:22 +00:00
|
|
|
}
|
|
|
|
|
2008-12-07 01:50:16 +00:00
|
|
|
/// getPointerDependencyFrom - Return the instruction on which a memory
|
|
|
|
/// location depends. If isLoad is true, this routine ignore may-aliases with
|
|
|
|
/// read-only operations.
|
2008-11-30 23:17:19 +00:00
|
|
|
MemDepResult MemoryDependenceAnalysis::
|
2009-10-28 06:18:42 +00:00
|
|
|
getPointerDependencyFrom(Value *MemPtr, uint64_t MemSize, bool isLoad,
|
2008-12-07 01:50:16 +00:00
|
|
|
BasicBlock::iterator ScanIt, BasicBlock *BB) {
|
2008-12-07 02:15:47 +00:00
|
|
|
|
2009-12-01 21:16:01 +00:00
|
|
|
Value *InvariantTag = 0;
|
2009-10-28 06:18:42 +00:00
|
|
|
|
2008-12-07 08:50:20 +00:00
|
|
|
// Walk backwards through the basic block, looking for dependencies.
|
2008-11-29 03:47:00 +00:00
|
|
|
while (ScanIt != BB->begin()) {
|
|
|
|
Instruction *Inst = --ScanIt;
|
2008-11-29 09:09:48 +00:00
|
|
|
|
2009-10-28 06:18:42 +00:00
|
|
|
// If we're in an invariant region, no dependencies can be found before
|
|
|
|
// we pass an invariant-begin marker.
|
2009-12-01 21:16:01 +00:00
|
|
|
if (InvariantTag == Inst) {
|
|
|
|
InvariantTag = 0;
|
2009-10-28 06:18:42 +00:00
|
|
|
continue;
|
2009-12-01 21:15:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
|
2009-12-02 07:35:19 +00:00
|
|
|
// Debug intrinsics don't cause dependences.
|
|
|
|
if (isa<DbgInfoIntrinsic>(Inst)) continue;
|
|
|
|
|
2009-10-28 07:05:35 +00:00
|
|
|
// If we pass an invariant-end marker, then we've just entered an
|
|
|
|
// invariant region and can start ignoring dependencies.
|
2009-10-28 06:18:42 +00:00
|
|
|
if (II->getIntrinsicID() == Intrinsic::invariant_end) {
|
2009-12-02 07:35:19 +00:00
|
|
|
// FIXME: This only considers queries directly on the invariant-tagged
|
|
|
|
// pointer, not on query pointers that are indexed off of them. It'd
|
|
|
|
// be nice to handle that at some point.
|
|
|
|
AliasAnalysis::AliasResult R =
|
2009-12-02 15:33:44 +00:00
|
|
|
AA->alias(II->getOperand(3), ~0U, MemPtr, ~0U);
|
2009-10-28 06:18:42 +00:00
|
|
|
if (R == AliasAnalysis::MustAlias) {
|
2009-12-01 21:16:01 +00:00
|
|
|
InvariantTag = II->getOperand(1);
|
2009-10-28 06:18:42 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-10-28 07:05:35 +00:00
|
|
|
|
|
|
|
// If we reach a lifetime begin or end marker, then the query ends here
|
|
|
|
// because the value is undefined.
|
2009-12-02 07:35:19 +00:00
|
|
|
} else if (II->getIntrinsicID() == Intrinsic::lifetime_start) {
|
|
|
|
// FIXME: This only considers queries directly on the invariant-tagged
|
|
|
|
// pointer, not on query pointers that are indexed off of them. It'd
|
|
|
|
// be nice to handle that at some point.
|
2009-10-28 07:05:35 +00:00
|
|
|
AliasAnalysis::AliasResult R =
|
2009-12-02 15:33:44 +00:00
|
|
|
AA->alias(II->getOperand(2), ~0U, MemPtr, ~0U);
|
2009-10-28 07:05:35 +00:00
|
|
|
if (R == AliasAnalysis::MustAlias)
|
|
|
|
return MemDepResult::getDef(II);
|
2009-10-28 06:18:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we're querying on a load and we're in an invariant region, we're done
|
|
|
|
// at this point. Nothing a load depends on can live in an invariant region.
|
2009-12-01 21:16:01 +00:00
|
|
|
if (isLoad && InvariantTag) continue;
|
2009-10-28 06:18:42 +00:00
|
|
|
|
2008-11-30 01:44:00 +00:00
|
|
|
// Values depend on loads if the pointers are must aliased. This means that
|
|
|
|
// a load depends on another must aliased load from the same value.
|
2008-12-05 21:04:20 +00:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
|
|
|
|
Value *Pointer = LI->getPointerOperand();
|
2009-07-31 20:53:12 +00:00
|
|
|
uint64_t PointerSize = AA->getTypeStoreSize(LI->getType());
|
2007-07-10 18:11:42 +00:00
|
|
|
|
2008-12-05 21:04:20 +00:00
|
|
|
// If we found a pointer, check if it could be the same as our pointer.
|
2008-11-29 09:09:48 +00:00
|
|
|
AliasAnalysis::AliasResult R =
|
2008-11-30 19:24:31 +00:00
|
|
|
AA->alias(Pointer, PointerSize, MemPtr, MemSize);
|
2008-11-29 09:09:48 +00:00
|
|
|
if (R == AliasAnalysis::NoAlias)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// May-alias loads don't depend on each other without a dependence.
|
2008-12-07 01:50:16 +00:00
|
|
|
if (isLoad && R == AliasAnalysis::MayAlias)
|
2008-11-29 09:09:48 +00:00
|
|
|
continue;
|
2008-12-07 08:50:20 +00:00
|
|
|
// Stores depend on may and must aliased loads, loads depend on must-alias
|
|
|
|
// loads.
|
2008-12-05 21:04:20 +00:00
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
|
2009-10-28 06:30:52 +00:00
|
|
|
// There can't be stores to the value we care about inside an
|
|
|
|
// invariant region.
|
2009-12-01 21:16:01 +00:00
|
|
|
if (InvariantTag) continue;
|
2009-10-28 06:30:52 +00:00
|
|
|
|
2009-05-25 21:28:56 +00:00
|
|
|
// If alias analysis can tell that this store is guaranteed to not modify
|
|
|
|
// the query pointer, ignore it. Use getModRefInfo to handle cases where
|
|
|
|
// the query pointer points to constant memory etc.
|
|
|
|
if (AA->getModRefInfo(SI, MemPtr, MemSize) == AliasAnalysis::NoModRef)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Ok, this store might clobber the query pointer. Check to see if it is
|
|
|
|
// a must alias: in this case, we want to return this as a def.
|
2008-12-05 21:04:20 +00:00
|
|
|
Value *Pointer = SI->getPointerOperand();
|
2009-07-31 20:53:12 +00:00
|
|
|
uint64_t PointerSize = AA->getTypeStoreSize(SI->getOperand(0)->getType());
|
2009-05-25 21:28:56 +00:00
|
|
|
|
2008-12-05 21:04:20 +00:00
|
|
|
// If we found a pointer, check if it could be the same as our pointer.
|
|
|
|
AliasAnalysis::AliasResult R =
|
|
|
|
AA->alias(Pointer, PointerSize, MemPtr, MemSize);
|
|
|
|
|
|
|
|
if (R == AliasAnalysis::NoAlias)
|
|
|
|
continue;
|
|
|
|
if (R == AliasAnalysis::MayAlias)
|
|
|
|
return MemDepResult::getClobber(Inst);
|
|
|
|
return MemDepResult::getDef(Inst);
|
2008-11-29 09:09:48 +00:00
|
|
|
}
|
2008-11-30 01:39:32 +00:00
|
|
|
|
|
|
|
// If this is an allocation, and if we know that the accessed pointer is to
|
2008-12-05 21:04:20 +00:00
|
|
|
// the allocation, return Def. This means that there is no dependence and
|
2008-11-30 01:39:32 +00:00
|
|
|
// the access can be optimized based on that. For example, a load could
|
|
|
|
// turn into undef.
|
2009-10-13 01:42:53 +00:00
|
|
|
// Note: Only determine this to be a malloc if Inst is the malloc call, not
|
|
|
|
// a subsequent bitcast of the malloc call result. There can be stores to
|
|
|
|
// the malloced memory between the malloc call and its bitcast uses, and we
|
|
|
|
// need to continue scanning until the malloc call.
|
2009-12-22 01:00:32 +00:00
|
|
|
if (isa<AllocaInst>(Inst) ||
|
|
|
|
(isa<CallInst>(Inst) && extractMallocCall(Inst))) {
|
2009-09-18 21:34:51 +00:00
|
|
|
Value *AccessPtr = MemPtr->getUnderlyingObject();
|
|
|
|
|
|
|
|
if (AccessPtr == Inst ||
|
|
|
|
AA->alias(Inst, 1, AccessPtr, 1) == AliasAnalysis::MustAlias)
|
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-12-05 21:04:20 +00:00
|
|
|
// See if this instruction (e.g. a call or vaarg) mod/ref's the pointer.
|
2008-12-09 19:47:40 +00:00
|
|
|
switch (AA->getModRefInfo(Inst, MemPtr, MemSize)) {
|
|
|
|
case AliasAnalysis::NoModRef:
|
|
|
|
// If the call has no effect on the queried pointer, just ignore it.
|
2008-11-29 08:51:16 +00:00
|
|
|
continue;
|
2009-10-28 06:30:52 +00:00
|
|
|
case AliasAnalysis::Mod:
|
|
|
|
// If we're in an invariant region, we can ignore calls that ONLY
|
|
|
|
// modify the pointer.
|
2009-12-01 21:16:01 +00:00
|
|
|
if (InvariantTag) continue;
|
2009-10-28 06:30:52 +00:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2008-12-09 19:47:40 +00:00
|
|
|
case AliasAnalysis::Ref:
|
|
|
|
// If the call is known to never store to the pointer, and if this is a
|
|
|
|
// load query, we can safely ignore it (scan past it).
|
|
|
|
if (isLoad)
|
|
|
|
continue;
|
|
|
|
default:
|
|
|
|
// Otherwise, there is a potential dependence. Return a clobber.
|
|
|
|
return MemDepResult::getClobber(Inst);
|
|
|
|
}
|
2007-07-06 23:14:35 +00:00
|
|
|
}
|
|
|
|
|
2008-12-07 02:15:47 +00:00
|
|
|
// No dependence found. If this is the entry block of the function, it is a
|
|
|
|
// clobber, otherwise it is non-local.
|
|
|
|
if (BB != &BB->getParent()->getEntryBlock())
|
|
|
|
return MemDepResult::getNonLocal();
|
|
|
|
return MemDepResult::getClobber(ScanIt);
|
2007-07-06 23:14:35 +00:00
|
|
|
}
|
|
|
|
|
2008-11-29 03:47:00 +00:00
|
|
|
/// getDependency - Return the instruction on which a memory operation
|
|
|
|
/// depends.
|
|
|
|
MemDepResult MemoryDependenceAnalysis::getDependency(Instruction *QueryInst) {
|
|
|
|
Instruction *ScanPos = QueryInst;
|
|
|
|
|
|
|
|
// Check for a cached result
|
2008-11-30 23:17:19 +00:00
|
|
|
MemDepResult &LocalCache = LocalDeps[QueryInst];
|
2008-11-29 03:47:00 +00:00
|
|
|
|
2008-11-29 22:02:15 +00:00
|
|
|
// If the cached entry is non-dirty, just return it. Note that this depends
|
2008-11-30 23:17:19 +00:00
|
|
|
// on MemDepResult's default constructing to 'dirty'.
|
|
|
|
if (!LocalCache.isDirty())
|
|
|
|
return LocalCache;
|
2008-11-29 03:47:00 +00:00
|
|
|
|
|
|
|
// Otherwise, if we have a dirty entry, we know we can start the scan at that
|
|
|
|
// instruction, which may save us some work.
|
2008-11-30 23:17:19 +00:00
|
|
|
if (Instruction *Inst = LocalCache.getInst()) {
|
2008-11-29 03:47:00 +00:00
|
|
|
ScanPos = Inst;
|
2008-11-30 02:52:26 +00:00
|
|
|
|
2008-12-07 18:39:13 +00:00
|
|
|
RemoveFromReverseMap(ReverseLocalDeps, Inst, QueryInst);
|
2008-11-30 02:52:26 +00:00
|
|
|
}
|
2008-11-29 03:47:00 +00:00
|
|
|
|
2008-12-07 01:50:16 +00:00
|
|
|
BasicBlock *QueryParent = QueryInst->getParent();
|
|
|
|
|
|
|
|
Value *MemPtr = 0;
|
|
|
|
uint64_t MemSize = 0;
|
|
|
|
|
2008-11-29 03:47:00 +00:00
|
|
|
// Do the scan.
|
2008-12-07 01:50:16 +00:00
|
|
|
if (BasicBlock::iterator(QueryInst) == QueryParent->begin()) {
|
2008-12-07 02:15:47 +00:00
|
|
|
// No dependence found. If this is the entry block of the function, it is a
|
|
|
|
// clobber, otherwise it is non-local.
|
|
|
|
if (QueryParent != &QueryParent->getParent()->getEntryBlock())
|
|
|
|
LocalCache = MemDepResult::getNonLocal();
|
|
|
|
else
|
|
|
|
LocalCache = MemDepResult::getClobber(QueryInst);
|
2008-12-07 01:50:16 +00:00
|
|
|
} else if (StoreInst *SI = dyn_cast<StoreInst>(QueryInst)) {
|
|
|
|
// If this is a volatile store, don't mess around with it. Just return the
|
|
|
|
// previous instruction as a clobber.
|
|
|
|
if (SI->isVolatile())
|
|
|
|
LocalCache = MemDepResult::getClobber(--BasicBlock::iterator(ScanPos));
|
|
|
|
else {
|
|
|
|
MemPtr = SI->getPointerOperand();
|
2009-07-31 20:53:12 +00:00
|
|
|
MemSize = AA->getTypeStoreSize(SI->getOperand(0)->getType());
|
2008-12-07 01:50:16 +00:00
|
|
|
}
|
|
|
|
} else if (LoadInst *LI = dyn_cast<LoadInst>(QueryInst)) {
|
|
|
|
// If this is a volatile load, don't mess around with it. Just return the
|
|
|
|
// previous instruction as a clobber.
|
|
|
|
if (LI->isVolatile())
|
|
|
|
LocalCache = MemDepResult::getClobber(--BasicBlock::iterator(ScanPos));
|
|
|
|
else {
|
|
|
|
MemPtr = LI->getPointerOperand();
|
2009-07-31 20:53:12 +00:00
|
|
|
MemSize = AA->getTypeStoreSize(LI->getType());
|
2008-12-07 01:50:16 +00:00
|
|
|
}
|
2009-10-24 04:23:03 +00:00
|
|
|
} else if (isFreeCall(QueryInst)) {
|
2009-10-26 23:43:48 +00:00
|
|
|
MemPtr = QueryInst->getOperand(1);
|
2009-10-24 04:23:03 +00:00
|
|
|
// calls to free() erase the entire structure, not just a field.
|
|
|
|
MemSize = ~0UL;
|
2008-12-07 01:50:16 +00:00
|
|
|
} else if (isa<CallInst>(QueryInst) || isa<InvokeInst>(QueryInst)) {
|
2009-11-28 21:27:49 +00:00
|
|
|
int IntrinsicID = 0; // Intrinsic IDs start at 1.
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(QueryInst))
|
|
|
|
IntrinsicID = II->getIntrinsicID();
|
|
|
|
|
|
|
|
switch (IntrinsicID) {
|
2009-12-05 06:37:24 +00:00
|
|
|
case Intrinsic::lifetime_start:
|
|
|
|
case Intrinsic::lifetime_end:
|
|
|
|
case Intrinsic::invariant_start:
|
|
|
|
MemPtr = QueryInst->getOperand(2);
|
|
|
|
MemSize = cast<ConstantInt>(QueryInst->getOperand(1))->getZExtValue();
|
|
|
|
break;
|
|
|
|
case Intrinsic::invariant_end:
|
|
|
|
MemPtr = QueryInst->getOperand(3);
|
|
|
|
MemSize = cast<ConstantInt>(QueryInst->getOperand(2))->getZExtValue();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
CallSite QueryCS = CallSite::get(QueryInst);
|
|
|
|
bool isReadOnly = AA->onlyReadsMemory(QueryCS);
|
|
|
|
LocalCache = getCallSiteDependencyFrom(QueryCS, isReadOnly, ScanPos,
|
|
|
|
QueryParent);
|
|
|
|
break;
|
2009-11-28 21:27:49 +00:00
|
|
|
}
|
2008-12-07 01:50:16 +00:00
|
|
|
} else {
|
|
|
|
// Non-memory instruction.
|
|
|
|
LocalCache = MemDepResult::getClobber(--BasicBlock::iterator(ScanPos));
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we need to do a pointer scan, make it happen.
|
2009-11-28 21:27:49 +00:00
|
|
|
if (MemPtr) {
|
|
|
|
bool isLoad = !QueryInst->mayWriteToMemory();
|
|
|
|
if (IntrinsicInst *II = dyn_cast<MemoryUseIntrinsic>(QueryInst)) {
|
|
|
|
isLoad |= II->getIntrinsicID() == Intrinsic::lifetime_end;
|
|
|
|
}
|
|
|
|
LocalCache = getPointerDependencyFrom(MemPtr, MemSize, isLoad, ScanPos,
|
|
|
|
QueryParent);
|
|
|
|
}
|
2008-11-29 03:47:00 +00:00
|
|
|
|
|
|
|
// Remember the result!
|
2008-11-30 23:17:19 +00:00
|
|
|
if (Instruction *I = LocalCache.getInst())
|
2008-11-29 09:20:15 +00:00
|
|
|
ReverseLocalDeps[I].insert(QueryInst);
|
2008-11-29 03:47:00 +00:00
|
|
|
|
2008-11-30 23:17:19 +00:00
|
|
|
return LocalCache;
|
2008-11-29 03:47:00 +00:00
|
|
|
}
|
|
|
|
|
2009-01-22 07:04:01 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
/// AssertSorted - This method is used when -debug is specified to verify that
|
|
|
|
/// cache arrays are properly kept sorted.
|
|
|
|
static void AssertSorted(MemoryDependenceAnalysis::NonLocalDepInfo &Cache,
|
|
|
|
int Count = -1) {
|
|
|
|
if (Count == -1) Count = Cache.size();
|
|
|
|
if (Count == 0) return;
|
|
|
|
|
|
|
|
for (unsigned i = 1; i != unsigned(Count); ++i)
|
2009-12-09 07:08:01 +00:00
|
|
|
assert(!(Cache[i] < Cache[i-1]) && "Cache isn't sorted!");
|
2009-01-22 07:04:01 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-12-09 19:38:05 +00:00
|
|
|
/// getNonLocalCallDependency - Perform a full dependency query for the
|
|
|
|
/// specified call, returning the set of blocks that the value is
|
2008-11-30 01:18:27 +00:00
|
|
|
/// potentially live across. The returned set of results will include a
|
|
|
|
/// "NonLocal" result for all blocks where the value is live across.
|
|
|
|
///
|
2008-12-09 19:38:05 +00:00
|
|
|
/// This method assumes the instruction returns a "NonLocal" dependency
|
2008-11-30 01:18:27 +00:00
|
|
|
/// within its own block.
|
|
|
|
///
|
2008-12-09 19:38:05 +00:00
|
|
|
/// This returns a reference to an internal data structure that may be
|
|
|
|
/// invalidated on the next non-local query or when an instruction is
|
|
|
|
/// removed. Clients must copy this data if they want it around longer than
|
|
|
|
/// that.
|
2008-12-01 01:15:42 +00:00
|
|
|
const MemoryDependenceAnalysis::NonLocalDepInfo &
|
2008-12-09 19:38:05 +00:00
|
|
|
MemoryDependenceAnalysis::getNonLocalCallDependency(CallSite QueryCS) {
|
|
|
|
assert(getDependency(QueryCS.getInstruction()).isNonLocal() &&
|
|
|
|
"getNonLocalCallDependency should only be used on calls with non-local deps!");
|
|
|
|
PerInstNLInfo &CacheP = NonLocalDeps[QueryCS.getInstruction()];
|
2008-12-01 01:15:42 +00:00
|
|
|
NonLocalDepInfo &Cache = CacheP.first;
|
2008-11-30 01:18:27 +00:00
|
|
|
|
|
|
|
/// DirtyBlocks - This is the set of blocks that need to be recomputed. In
|
|
|
|
/// the cached case, this can happen due to instructions being deleted etc. In
|
|
|
|
/// the uncached case, this starts out as the set of predecessors we care
|
|
|
|
/// about.
|
|
|
|
SmallVector<BasicBlock*, 32> DirtyBlocks;
|
|
|
|
|
|
|
|
if (!Cache.empty()) {
|
2008-12-01 01:15:42 +00:00
|
|
|
// Okay, we have a cache entry. If we know it is not dirty, just return it
|
|
|
|
// with no computation.
|
|
|
|
if (!CacheP.second) {
|
|
|
|
NumCacheNonLocal++;
|
|
|
|
return Cache;
|
|
|
|
}
|
|
|
|
|
2008-11-30 01:18:27 +00:00
|
|
|
// If we already have a partially computed set of results, scan them to
|
2008-12-01 01:15:42 +00:00
|
|
|
// determine what is dirty, seeding our initial DirtyBlocks worklist.
|
|
|
|
for (NonLocalDepInfo::iterator I = Cache.begin(), E = Cache.end();
|
|
|
|
I != E; ++I)
|
2009-12-09 07:08:01 +00:00
|
|
|
if (I->getResult().isDirty())
|
|
|
|
DirtyBlocks.push_back(I->getBB());
|
2008-11-30 01:18:27 +00:00
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
// Sort the cache so that we can do fast binary search lookups below.
|
|
|
|
std::sort(Cache.begin(), Cache.end());
|
2008-11-30 01:18:27 +00:00
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
++NumCacheDirtyNonLocal;
|
2008-11-30 01:18:27 +00:00
|
|
|
//cerr << "CACHED CASE: " << DirtyBlocks.size() << " dirty: "
|
|
|
|
// << Cache.size() << " cached: " << *QueryInst;
|
|
|
|
} else {
|
|
|
|
// Seed DirtyBlocks with each of the preds of QueryInst's block.
|
2008-12-09 19:38:05 +00:00
|
|
|
BasicBlock *QueryBB = QueryCS.getInstruction()->getParent();
|
2008-12-09 06:44:17 +00:00
|
|
|
for (BasicBlock **PI = PredCache->GetPreds(QueryBB); *PI; ++PI)
|
|
|
|
DirtyBlocks.push_back(*PI);
|
2008-11-30 01:18:27 +00:00
|
|
|
NumUncacheNonLocal++;
|
|
|
|
}
|
|
|
|
|
2008-12-09 21:19:42 +00:00
|
|
|
// isReadonlyCall - If this is a read-only call, we can be more aggressive.
|
|
|
|
bool isReadonlyCall = AA->onlyReadsMemory(QueryCS);
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
SmallPtrSet<BasicBlock*, 64> Visited;
|
|
|
|
|
|
|
|
unsigned NumSortedEntries = Cache.size();
|
2009-01-22 07:04:01 +00:00
|
|
|
DEBUG(AssertSorted(Cache));
|
2008-12-01 01:15:42 +00:00
|
|
|
|
2008-11-30 01:18:27 +00:00
|
|
|
// Iterate while we still have blocks to update.
|
|
|
|
while (!DirtyBlocks.empty()) {
|
|
|
|
BasicBlock *DirtyBB = DirtyBlocks.back();
|
|
|
|
DirtyBlocks.pop_back();
|
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
// Already processed this block?
|
|
|
|
if (!Visited.insert(DirtyBB))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Do a binary search to see if we already have an entry for this block in
|
|
|
|
// the cache set. If so, find it.
|
2009-01-22 07:04:01 +00:00
|
|
|
DEBUG(AssertSorted(Cache, NumSortedEntries));
|
2008-12-01 01:15:42 +00:00
|
|
|
NonLocalDepInfo::iterator Entry =
|
|
|
|
std::upper_bound(Cache.begin(), Cache.begin()+NumSortedEntries,
|
2009-12-09 07:31:04 +00:00
|
|
|
NonLocalDepEntry(DirtyBB));
|
2009-12-09 07:08:01 +00:00
|
|
|
if (Entry != Cache.begin() && prior(Entry)->getBB() == DirtyBB)
|
2008-12-01 01:15:42 +00:00
|
|
|
--Entry;
|
|
|
|
|
2009-12-09 07:08:01 +00:00
|
|
|
NonLocalDepEntry *ExistingResult = 0;
|
2008-12-01 01:15:42 +00:00
|
|
|
if (Entry != Cache.begin()+NumSortedEntries &&
|
2009-12-09 07:08:01 +00:00
|
|
|
Entry->getBB() == DirtyBB) {
|
2008-12-01 01:15:42 +00:00
|
|
|
// If we already have an entry, and if it isn't already dirty, the block
|
|
|
|
// is done.
|
2009-12-09 07:08:01 +00:00
|
|
|
if (!Entry->getResult().isDirty())
|
2008-12-01 01:15:42 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// Otherwise, remember this slot so we can update the value.
|
2009-12-09 07:08:01 +00:00
|
|
|
ExistingResult = &*Entry;
|
2008-12-01 01:15:42 +00:00
|
|
|
}
|
2008-11-30 01:18:27 +00:00
|
|
|
|
|
|
|
// 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();
|
2008-12-01 01:15:42 +00:00
|
|
|
if (ExistingResult) {
|
2009-12-09 07:08:01 +00:00
|
|
|
if (Instruction *Inst = ExistingResult->getResult().getInst()) {
|
2008-12-01 01:15:42 +00:00
|
|
|
ScanPos = Inst;
|
|
|
|
// We're removing QueryInst's use of Inst.
|
2008-12-09 19:38:05 +00:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalDeps, Inst,
|
|
|
|
QueryCS.getInstruction());
|
2008-12-01 01:15:42 +00:00
|
|
|
}
|
2008-11-30 02:28:25 +00:00
|
|
|
}
|
2008-11-30 01:18:27 +00:00
|
|
|
|
2008-11-30 01:26:32 +00:00
|
|
|
// Find out if this block has a local dependency for QueryInst.
|
2008-12-07 01:21:14 +00:00
|
|
|
MemDepResult Dep;
|
2008-12-07 01:50:16 +00:00
|
|
|
|
2008-12-09 19:38:05 +00:00
|
|
|
if (ScanPos != DirtyBB->begin()) {
|
2008-12-09 21:19:42 +00:00
|
|
|
Dep = getCallSiteDependencyFrom(QueryCS, isReadonlyCall,ScanPos, DirtyBB);
|
2008-12-09 19:38:05 +00:00
|
|
|
} else if (DirtyBB != &DirtyBB->getParent()->getEntryBlock()) {
|
|
|
|
// No dependence found. If this is the entry block of the function, it is
|
|
|
|
// a clobber, otherwise it is non-local.
|
|
|
|
Dep = MemDepResult::getNonLocal();
|
2008-12-07 01:50:16 +00:00
|
|
|
} else {
|
2008-12-09 19:38:05 +00:00
|
|
|
Dep = MemDepResult::getClobber(ScanPos);
|
2008-12-07 01:50:16 +00:00
|
|
|
}
|
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
// If we had a dirty entry for the block, update it. Otherwise, just add
|
|
|
|
// a new entry.
|
|
|
|
if (ExistingResult)
|
2009-12-22 04:25:02 +00:00
|
|
|
ExistingResult->setResult(Dep);
|
2008-12-01 01:15:42 +00:00
|
|
|
else
|
2009-12-22 04:25:02 +00:00
|
|
|
Cache.push_back(NonLocalDepEntry(DirtyBB, Dep));
|
2008-12-01 01:15:42 +00:00
|
|
|
|
2008-11-30 01:18:27 +00:00
|
|
|
// If the block has a dependency (i.e. it isn't completely transparent to
|
2008-12-01 01:15:42 +00:00
|
|
|
// the value), remember the association!
|
|
|
|
if (!Dep.isNonLocal()) {
|
2008-11-30 01:18:27 +00:00
|
|
|
// Keep the ReverseNonLocalDeps map up to date so we can efficiently
|
|
|
|
// update this when we remove instructions.
|
2008-12-01 01:15:42 +00:00
|
|
|
if (Instruction *Inst = Dep.getInst())
|
2008-12-09 19:38:05 +00:00
|
|
|
ReverseNonLocalDeps[Inst].insert(QueryCS.getInstruction());
|
2008-12-01 01:15:42 +00:00
|
|
|
} else {
|
2008-11-30 01:18:27 +00:00
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
// If the block *is* completely transparent to the load, we need to check
|
|
|
|
// the predecessors of this block. Add them to our worklist.
|
2008-12-09 06:44:17 +00:00
|
|
|
for (BasicBlock **PI = PredCache->GetPreds(DirtyBB); *PI; ++PI)
|
|
|
|
DirtyBlocks.push_back(*PI);
|
2008-12-01 01:15:42 +00:00
|
|
|
}
|
2008-11-30 01:18:27 +00:00
|
|
|
}
|
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
return Cache;
|
2008-11-30 01:18:27 +00:00
|
|
|
}
|
|
|
|
|
2008-12-07 02:15:47 +00:00
|
|
|
/// getNonLocalPointerDependency - Perform a full dependency query for an
|
|
|
|
/// access to the specified (non-volatile) memory location, returning the
|
|
|
|
/// set of instructions that either define or clobber the value.
|
|
|
|
///
|
|
|
|
/// This method assumes the pointer has a "NonLocal" dependency within its
|
|
|
|
/// own block.
|
|
|
|
///
|
|
|
|
void MemoryDependenceAnalysis::
|
|
|
|
getNonLocalPointerDependency(Value *Pointer, bool isLoad, BasicBlock *FromBB,
|
2009-12-22 04:25:02 +00:00
|
|
|
SmallVectorImpl<NonLocalDepResult> &Result) {
|
2008-12-07 18:45:15 +00:00
|
|
|
assert(isa<PointerType>(Pointer->getType()) &&
|
|
|
|
"Can't get pointer deps of a non-pointer!");
|
2008-12-07 02:56:57 +00:00
|
|
|
Result.clear();
|
|
|
|
|
2008-12-07 02:15:47 +00:00
|
|
|
// We know that the pointer value is live into FromBB find the def/clobbers
|
|
|
|
// from presecessors.
|
|
|
|
const Type *EltTy = cast<PointerType>(Pointer->getType())->getElementType();
|
2009-07-31 20:53:12 +00:00
|
|
|
uint64_t PointeeSize = AA->getTypeStoreSize(EltTy);
|
2008-12-07 02:15:47 +00:00
|
|
|
|
2009-12-09 01:59:31 +00:00
|
|
|
PHITransAddr Address(Pointer, TD);
|
|
|
|
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
// This is the set of blocks we've inspected, and the pointer we consider in
|
|
|
|
// each block. Because of critical edges, we currently bail out if querying
|
|
|
|
// a block with multiple different pointers. This can happen during PHI
|
|
|
|
// translation.
|
|
|
|
DenseMap<BasicBlock*, Value*> Visited;
|
2009-12-09 01:59:31 +00:00
|
|
|
if (!getNonLocalPointerDepFromBB(Address, PointeeSize, isLoad, FromBB,
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
Result, Visited, true))
|
|
|
|
return;
|
2008-12-15 04:58:29 +00:00
|
|
|
Result.clear();
|
2009-12-22 04:25:02 +00:00
|
|
|
Result.push_back(NonLocalDepResult(FromBB,
|
|
|
|
MemDepResult::getClobber(FromBB->begin()),
|
|
|
|
Pointer));
|
2008-12-07 02:56:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-09 07:47:11 +00:00
|
|
|
/// GetNonLocalInfoForBlock - Compute the memdep value for BB with
|
|
|
|
/// Pointer/PointeeSize using either cached information in Cache or by doing a
|
|
|
|
/// lookup (which may use dirty cache info if available). If we do a lookup,
|
|
|
|
/// add the result to the cache.
|
|
|
|
MemDepResult MemoryDependenceAnalysis::
|
|
|
|
GetNonLocalInfoForBlock(Value *Pointer, uint64_t PointeeSize,
|
|
|
|
bool isLoad, BasicBlock *BB,
|
|
|
|
NonLocalDepInfo *Cache, unsigned NumSortedEntries) {
|
|
|
|
|
|
|
|
// Do a binary search to see if we already have an entry for this block in
|
|
|
|
// the cache set. If so, find it.
|
|
|
|
NonLocalDepInfo::iterator Entry =
|
|
|
|
std::upper_bound(Cache->begin(), Cache->begin()+NumSortedEntries,
|
2009-12-09 07:31:04 +00:00
|
|
|
NonLocalDepEntry(BB));
|
2009-12-09 07:08:01 +00:00
|
|
|
if (Entry != Cache->begin() && (Entry-1)->getBB() == BB)
|
2008-12-09 07:47:11 +00:00
|
|
|
--Entry;
|
|
|
|
|
2009-12-09 07:08:01 +00:00
|
|
|
NonLocalDepEntry *ExistingResult = 0;
|
|
|
|
if (Entry != Cache->begin()+NumSortedEntries && Entry->getBB() == BB)
|
|
|
|
ExistingResult = &*Entry;
|
2008-12-09 07:47:11 +00:00
|
|
|
|
|
|
|
// If we have a cached entry, and it is non-dirty, use it as the value for
|
|
|
|
// this dependency.
|
2009-12-09 07:08:01 +00:00
|
|
|
if (ExistingResult && !ExistingResult->getResult().isDirty()) {
|
2008-12-09 07:47:11 +00:00
|
|
|
++NumCacheNonLocalPtr;
|
2009-12-09 07:08:01 +00:00
|
|
|
return ExistingResult->getResult();
|
2008-12-09 07:47:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we have to scan for the value. If we have a dirty cache
|
|
|
|
// entry, start scanning from its position, otherwise we scan from the end
|
|
|
|
// of the block.
|
|
|
|
BasicBlock::iterator ScanPos = BB->end();
|
2009-12-09 07:08:01 +00:00
|
|
|
if (ExistingResult && ExistingResult->getResult().getInst()) {
|
|
|
|
assert(ExistingResult->getResult().getInst()->getParent() == BB &&
|
2008-12-09 07:47:11 +00:00
|
|
|
"Instruction invalidated?");
|
|
|
|
++NumCacheDirtyNonLocalPtr;
|
2009-12-09 07:08:01 +00:00
|
|
|
ScanPos = ExistingResult->getResult().getInst();
|
2008-12-09 07:47:11 +00:00
|
|
|
|
|
|
|
// Eliminating the dirty entry from 'Cache', so update the reverse info.
|
|
|
|
ValueIsLoadPair CacheKey(Pointer, isLoad);
|
2009-03-29 00:24:04 +00:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalPtrDeps, ScanPos, CacheKey);
|
2008-12-09 07:47:11 +00:00
|
|
|
} else {
|
|
|
|
++NumUncacheNonLocalPtr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scan the block for the dependency.
|
|
|
|
MemDepResult Dep = getPointerDependencyFrom(Pointer, PointeeSize, isLoad,
|
|
|
|
ScanPos, BB);
|
|
|
|
|
|
|
|
// If we had a dirty entry for the block, update it. Otherwise, just add
|
|
|
|
// a new entry.
|
|
|
|
if (ExistingResult)
|
2009-12-22 04:25:02 +00:00
|
|
|
ExistingResult->setResult(Dep);
|
2008-12-09 07:47:11 +00:00
|
|
|
else
|
2009-12-22 04:25:02 +00:00
|
|
|
Cache->push_back(NonLocalDepEntry(BB, Dep));
|
2008-12-09 07:47:11 +00:00
|
|
|
|
|
|
|
// If the block has a dependency (i.e. it isn't completely transparent to
|
|
|
|
// the value), remember the reverse association because we just added it
|
|
|
|
// to Cache!
|
|
|
|
if (Dep.isNonLocal())
|
|
|
|
return Dep;
|
|
|
|
|
|
|
|
// Keep the ReverseNonLocalPtrDeps map up to date so we can efficiently
|
|
|
|
// update MemDep when we remove instructions.
|
|
|
|
Instruction *Inst = Dep.getInst();
|
|
|
|
assert(Inst && "Didn't depend on anything?");
|
|
|
|
ValueIsLoadPair CacheKey(Pointer, isLoad);
|
2009-03-29 00:24:04 +00:00
|
|
|
ReverseNonLocalPtrDeps[Inst].insert(CacheKey);
|
2008-12-09 07:47:11 +00:00
|
|
|
return Dep;
|
|
|
|
}
|
|
|
|
|
2009-07-13 17:20:05 +00:00
|
|
|
/// SortNonLocalDepInfoCache - Sort the a NonLocalDepInfo cache, given a certain
|
|
|
|
/// number of elements in the array that are already properly ordered. This is
|
|
|
|
/// optimized for the case when only a few entries are added.
|
|
|
|
static void
|
|
|
|
SortNonLocalDepInfoCache(MemoryDependenceAnalysis::NonLocalDepInfo &Cache,
|
|
|
|
unsigned NumSortedEntries) {
|
|
|
|
switch (Cache.size() - NumSortedEntries) {
|
|
|
|
case 0:
|
|
|
|
// done, no new entries.
|
|
|
|
break;
|
|
|
|
case 2: {
|
|
|
|
// Two new entries, insert the last one into place.
|
2009-12-09 07:08:01 +00:00
|
|
|
NonLocalDepEntry Val = Cache.back();
|
2009-07-13 17:20:05 +00:00
|
|
|
Cache.pop_back();
|
|
|
|
MemoryDependenceAnalysis::NonLocalDepInfo::iterator Entry =
|
|
|
|
std::upper_bound(Cache.begin(), Cache.end()-1, Val);
|
|
|
|
Cache.insert(Entry, Val);
|
|
|
|
// FALL THROUGH.
|
|
|
|
}
|
|
|
|
case 1:
|
|
|
|
// One new entry, Just insert the new value at the appropriate position.
|
|
|
|
if (Cache.size() != 1) {
|
2009-12-09 07:08:01 +00:00
|
|
|
NonLocalDepEntry Val = Cache.back();
|
2009-07-13 17:20:05 +00:00
|
|
|
Cache.pop_back();
|
|
|
|
MemoryDependenceAnalysis::NonLocalDepInfo::iterator Entry =
|
|
|
|
std::upper_bound(Cache.begin(), Cache.end(), Val);
|
|
|
|
Cache.insert(Entry, Val);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Added many values, do a full scale sort.
|
|
|
|
std::sort(Cache.begin(), Cache.end());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
/// getNonLocalPointerDepFromBB - Perform a dependency query based on
|
|
|
|
/// pointer/pointeesize starting at the end of StartBB. Add any clobber/def
|
|
|
|
/// results to the results vector and keep track of which blocks are visited in
|
|
|
|
/// 'Visited'.
|
|
|
|
///
|
|
|
|
/// This has special behavior for the first block queries (when SkipFirstBlock
|
|
|
|
/// is true). In this special case, it ignores the contents of the specified
|
|
|
|
/// block and starts returning dependence info for its predecessors.
|
|
|
|
///
|
|
|
|
/// This function returns false on success, or true to indicate that it could
|
|
|
|
/// not compute dependence information for some reason. This should be treated
|
|
|
|
/// as a clobber dependence on the first instruction in the predecessor block.
|
|
|
|
bool MemoryDependenceAnalysis::
|
2009-12-09 01:59:31 +00:00
|
|
|
getNonLocalPointerDepFromBB(const PHITransAddr &Pointer, uint64_t PointeeSize,
|
2008-12-09 07:47:11 +00:00
|
|
|
bool isLoad, BasicBlock *StartBB,
|
2009-12-22 04:25:02 +00:00
|
|
|
SmallVectorImpl<NonLocalDepResult> &Result,
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
DenseMap<BasicBlock*, Value*> &Visited,
|
|
|
|
bool SkipFirstBlock) {
|
2009-09-20 22:44:26 +00:00
|
|
|
|
2008-12-07 08:50:20 +00:00
|
|
|
// Look up the cached info for Pointer.
|
2009-12-09 01:59:31 +00:00
|
|
|
ValueIsLoadPair CacheKey(Pointer.getAddr(), isLoad);
|
2008-12-08 07:31:50 +00:00
|
|
|
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
std::pair<BBSkipFirstBlockPair, NonLocalDepInfo> *CacheInfo =
|
|
|
|
&NonLocalPointerDeps[CacheKey];
|
|
|
|
NonLocalDepInfo *Cache = &CacheInfo->second;
|
2008-12-08 07:31:50 +00:00
|
|
|
|
|
|
|
// If we have valid cached information for exactly the block we are
|
|
|
|
// investigating, just return it with no recomputation.
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
if (CacheInfo->first == BBSkipFirstBlockPair(StartBB, SkipFirstBlock)) {
|
2008-12-16 07:10:09 +00:00
|
|
|
// We have a fully cached result for this query then we can just return the
|
|
|
|
// cached results and populate the visited set. However, we have to verify
|
|
|
|
// that we don't already have conflicting results for these blocks. Check
|
|
|
|
// to ensure that if a block in the results set is in the visited set that
|
|
|
|
// it was for the same pointer query.
|
|
|
|
if (!Visited.empty()) {
|
|
|
|
for (NonLocalDepInfo::iterator I = Cache->begin(), E = Cache->end();
|
|
|
|
I != E; ++I) {
|
2009-12-09 07:08:01 +00:00
|
|
|
DenseMap<BasicBlock*, Value*>::iterator VI = Visited.find(I->getBB());
|
2009-12-09 01:59:31 +00:00
|
|
|
if (VI == Visited.end() || VI->second == Pointer.getAddr())
|
|
|
|
continue;
|
2008-12-16 07:10:09 +00:00
|
|
|
|
|
|
|
// We have a pointer mismatch in a block. Just return clobber, saying
|
|
|
|
// that something was clobbered in this result. We could also do a
|
|
|
|
// non-fully cached query, but there is little point in doing this.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-22 04:25:02 +00:00
|
|
|
Value *Addr = Pointer.getAddr();
|
2008-12-08 07:31:50 +00:00
|
|
|
for (NonLocalDepInfo::iterator I = Cache->begin(), E = Cache->end();
|
2008-12-16 07:10:09 +00:00
|
|
|
I != E; ++I) {
|
2009-12-22 04:25:02 +00:00
|
|
|
Visited.insert(std::make_pair(I->getBB(), Addr));
|
2009-12-09 07:08:01 +00:00
|
|
|
if (!I->getResult().isNonLocal())
|
2009-12-22 04:25:02 +00:00
|
|
|
Result.push_back(NonLocalDepResult(I->getBB(), I->getResult(), Addr));
|
2008-12-16 07:10:09 +00:00
|
|
|
}
|
2008-12-08 07:31:50 +00:00
|
|
|
++NumCacheCompleteNonLocalPtr;
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
return false;
|
2008-12-08 07:31:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, either this is a new block, a block with an invalid cache
|
|
|
|
// pointer or one that we're about to invalidate by putting more info into it
|
|
|
|
// than its valid cache info. If empty, the result will be valid cache info,
|
|
|
|
// otherwise it isn't.
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
if (Cache->empty())
|
|
|
|
CacheInfo->first = BBSkipFirstBlockPair(StartBB, SkipFirstBlock);
|
|
|
|
else
|
|
|
|
CacheInfo->first = BBSkipFirstBlockPair();
|
2008-12-08 07:31:50 +00:00
|
|
|
|
|
|
|
SmallVector<BasicBlock*, 32> Worklist;
|
|
|
|
Worklist.push_back(StartBB);
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
// Keep track of the entries that we know are sorted. Previously cached
|
|
|
|
// entries will all be sorted. The entries we add we only sort on demand (we
|
|
|
|
// don't insert every element into its sorted position). We know that we
|
|
|
|
// won't get any reuse from currently inserted values, because we don't
|
|
|
|
// revisit blocks after we insert info for them.
|
|
|
|
unsigned NumSortedEntries = Cache->size();
|
2009-01-22 07:04:01 +00:00
|
|
|
DEBUG(AssertSorted(*Cache));
|
2008-12-07 08:50:20 +00:00
|
|
|
|
2008-12-07 02:15:47 +00:00
|
|
|
while (!Worklist.empty()) {
|
2008-12-07 02:56:57 +00:00
|
|
|
BasicBlock *BB = Worklist.pop_back_val();
|
2008-12-07 02:15:47 +00:00
|
|
|
|
2008-12-09 07:52:59 +00:00
|
|
|
// Skip the first block if we have it.
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
if (!SkipFirstBlock) {
|
2008-12-09 07:52:59 +00:00
|
|
|
// Analyze the dependency of *Pointer in FromBB. See if we already have
|
|
|
|
// been here.
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
assert(Visited.count(BB) && "Should check 'visited' before adding to WL");
|
2008-12-07 08:50:20 +00:00
|
|
|
|
2008-12-09 07:52:59 +00:00
|
|
|
// Get the dependency info for Pointer in BB. If we have cached
|
|
|
|
// information, we will use it, otherwise we compute it.
|
2009-01-22 07:04:01 +00:00
|
|
|
DEBUG(AssertSorted(*Cache, NumSortedEntries));
|
2009-12-09 01:59:31 +00:00
|
|
|
MemDepResult Dep = GetNonLocalInfoForBlock(Pointer.getAddr(), PointeeSize,
|
|
|
|
isLoad, BB, Cache,
|
|
|
|
NumSortedEntries);
|
2008-12-09 07:52:59 +00:00
|
|
|
|
|
|
|
// If we got a Def or Clobber, add this to the list of results.
|
|
|
|
if (!Dep.isNonLocal()) {
|
2009-12-22 04:25:02 +00:00
|
|
|
Result.push_back(NonLocalDepResult(BB, Dep, Pointer.getAddr()));
|
2008-12-09 07:52:59 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-12-07 02:15:47 +00:00
|
|
|
}
|
|
|
|
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
// If 'Pointer' is an instruction defined in this block, then we need to do
|
|
|
|
// phi translation to change it into a value live in the predecessor block.
|
2009-12-09 01:59:31 +00:00
|
|
|
// If not, we just add the predecessors to the worklist and scan them with
|
|
|
|
// the same Pointer.
|
|
|
|
if (!Pointer.NeedsPHITranslationFromBlock(BB)) {
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
SkipFirstBlock = false;
|
|
|
|
for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
|
|
|
|
// Verify that we haven't looked at this block yet.
|
|
|
|
std::pair<DenseMap<BasicBlock*,Value*>::iterator, bool>
|
2009-12-09 01:59:31 +00:00
|
|
|
InsertRes = Visited.insert(std::make_pair(*PI, Pointer.getAddr()));
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
if (InsertRes.second) {
|
|
|
|
// First time we've looked at *PI.
|
|
|
|
Worklist.push_back(*PI);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we have seen this block before, but it was with a different
|
|
|
|
// pointer then we have a phi translation failure and we have to treat
|
|
|
|
// this as a clobber.
|
2009-12-09 01:59:31 +00:00
|
|
|
if (InsertRes.first->second != Pointer.getAddr())
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
goto PredTranslationFailure;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-12-09 01:59:31 +00:00
|
|
|
// We do need to do phi translation, if we know ahead of time we can't phi
|
|
|
|
// translate this value, don't even try.
|
|
|
|
if (!Pointer.IsPotentiallyPHITranslatable())
|
|
|
|
goto PredTranslationFailure;
|
|
|
|
|
2009-07-13 17:14:23 +00:00
|
|
|
// We may have added values to the cache list before this PHI translation.
|
|
|
|
// If so, we haven't done anything to ensure that the cache remains sorted.
|
|
|
|
// Sort it now (if needed) so that recursive invocations of
|
|
|
|
// getNonLocalPointerDepFromBB and other routines that could reuse the cache
|
|
|
|
// value will only see properly sorted cache arrays.
|
|
|
|
if (Cache && NumSortedEntries != Cache->size()) {
|
2009-07-13 17:20:05 +00:00
|
|
|
SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
|
2009-07-13 17:14:23 +00:00
|
|
|
NumSortedEntries = Cache->size();
|
|
|
|
}
|
2009-11-27 08:37:22 +00:00
|
|
|
Cache = 0;
|
2009-12-09 01:59:31 +00:00
|
|
|
|
2009-11-27 08:37:22 +00:00
|
|
|
for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
|
|
|
|
BasicBlock *Pred = *PI;
|
2009-12-09 01:59:31 +00:00
|
|
|
|
|
|
|
// Get the PHI translated pointer in this predecessor. This can fail if
|
|
|
|
// not translatable, in which case the getAddr() returns null.
|
|
|
|
PHITransAddr PredPointer(Pointer);
|
|
|
|
PredPointer.PHITranslateValue(BB, Pred);
|
|
|
|
|
|
|
|
Value *PredPtrVal = PredPointer.getAddr();
|
2009-11-27 08:37:22 +00:00
|
|
|
|
|
|
|
// Check to see if we have already visited this pred block with another
|
|
|
|
// pointer. If so, we can't do this lookup. This failure can occur
|
|
|
|
// with PHI translation when a critical edge exists and the PHI node in
|
|
|
|
// the successor translates to a pointer value different than the
|
|
|
|
// pointer the block was first analyzed with.
|
|
|
|
std::pair<DenseMap<BasicBlock*,Value*>::iterator, bool>
|
2009-12-09 01:59:31 +00:00
|
|
|
InsertRes = Visited.insert(std::make_pair(Pred, PredPtrVal));
|
2009-01-22 07:04:01 +00:00
|
|
|
|
2009-11-27 08:37:22 +00:00
|
|
|
if (!InsertRes.second) {
|
|
|
|
// If the predecessor was visited with PredPtr, then we already did
|
|
|
|
// the analysis and can ignore it.
|
2009-12-09 01:59:31 +00:00
|
|
|
if (InsertRes.first->second == PredPtrVal)
|
2009-11-27 08:37:22 +00:00
|
|
|
continue;
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
|
2009-11-27 08:37:22 +00:00
|
|
|
// Otherwise, the block was previously analyzed with a different
|
|
|
|
// pointer. We can't represent the result of this case, so we just
|
|
|
|
// treat this as a phi translation failure.
|
|
|
|
goto PredTranslationFailure;
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
}
|
2009-11-27 22:05:15 +00:00
|
|
|
|
|
|
|
// If PHI translation was unable to find an available pointer in this
|
|
|
|
// predecessor, then we have to assume that the pointer is clobbered in
|
|
|
|
// that predecessor. We can still do PRE of the load, which would insert
|
|
|
|
// a computation of the pointer in this predecessor.
|
2009-12-09 01:59:31 +00:00
|
|
|
if (PredPtrVal == 0) {
|
2009-12-01 07:33:32 +00:00
|
|
|
// Add the entry to the Result list.
|
2009-12-22 04:25:02 +00:00
|
|
|
NonLocalDepResult Entry(Pred,
|
|
|
|
MemDepResult::getClobber(Pred->getTerminator()),
|
|
|
|
PredPtrVal);
|
2009-12-01 07:33:32 +00:00
|
|
|
Result.push_back(Entry);
|
|
|
|
|
2009-12-19 21:29:22 +00:00
|
|
|
// Since we had a phi translation failure, the cache for CacheKey won't
|
|
|
|
// include all of the entries that we need to immediately satisfy future
|
|
|
|
// queries. Mark this in NonLocalPointerDeps by setting the
|
|
|
|
// BBSkipFirstBlockPair pointer to null. This requires reuse of the
|
|
|
|
// cached value to do more work but not miss the phi trans failure.
|
|
|
|
NonLocalPointerDeps[CacheKey].first = BBSkipFirstBlockPair();
|
2009-11-27 22:05:15 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-27 08:37:22 +00:00
|
|
|
|
|
|
|
// FIXME: it is entirely possible that PHI translating will end up with
|
|
|
|
// the same value. Consider PHI translating something like:
|
|
|
|
// X = phi [x, bb1], [y, bb2]. PHI translating for bb1 doesn't *need*
|
|
|
|
// to recurse here, pedantically speaking.
|
2009-07-13 17:14:23 +00:00
|
|
|
|
2009-11-27 08:37:22 +00:00
|
|
|
// If we have a problem phi translating, fall through to the code below
|
|
|
|
// to handle the failure condition.
|
2009-12-09 01:59:31 +00:00
|
|
|
if (getNonLocalPointerDepFromBB(PredPointer, PointeeSize, isLoad, Pred,
|
2009-11-27 08:37:22 +00:00
|
|
|
Result, Visited))
|
|
|
|
goto PredTranslationFailure;
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
}
|
2009-11-27 08:37:22 +00:00
|
|
|
|
|
|
|
// Refresh the CacheInfo/Cache pointer so that it isn't invalidated.
|
|
|
|
CacheInfo = &NonLocalPointerDeps[CacheKey];
|
|
|
|
Cache = &CacheInfo->second;
|
|
|
|
NumSortedEntries = Cache->size();
|
|
|
|
|
|
|
|
// Since we did phi translation, the "Cache" set won't contain all of the
|
|
|
|
// results for the query. This is ok (we can still use it to accelerate
|
|
|
|
// specific block queries) but we can't do the fastpath "return all
|
|
|
|
// results from the set" Clear out the indicator for this.
|
|
|
|
CacheInfo->first = BBSkipFirstBlockPair();
|
|
|
|
SkipFirstBlock = false;
|
|
|
|
continue;
|
2009-11-26 23:18:49 +00:00
|
|
|
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
PredTranslationFailure:
|
|
|
|
|
2009-01-23 07:12:16 +00:00
|
|
|
if (Cache == 0) {
|
|
|
|
// Refresh the CacheInfo/Cache pointer if it got invalidated.
|
|
|
|
CacheInfo = &NonLocalPointerDeps[CacheKey];
|
|
|
|
Cache = &CacheInfo->second;
|
|
|
|
NumSortedEntries = Cache->size();
|
|
|
|
}
|
2009-07-13 17:14:23 +00:00
|
|
|
|
2009-12-19 21:29:22 +00:00
|
|
|
// Since we failed phi translation, the "Cache" set won't contain all of the
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
// results for the query. This is ok (we can still use it to accelerate
|
|
|
|
// specific block queries) but we can't do the fastpath "return all
|
2009-12-19 21:29:22 +00:00
|
|
|
// results from the set". Clear out the indicator for this.
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
CacheInfo->first = BBSkipFirstBlockPair();
|
|
|
|
|
|
|
|
// If *nothing* works, mark the pointer as being clobbered by the first
|
|
|
|
// instruction in this block.
|
|
|
|
//
|
|
|
|
// If this is the magic first block, return this as a clobber of the whole
|
|
|
|
// incoming value. Since we can't phi translate to one of the predecessors,
|
|
|
|
// we have to bail out.
|
|
|
|
if (SkipFirstBlock)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
for (NonLocalDepInfo::reverse_iterator I = Cache->rbegin(); ; ++I) {
|
|
|
|
assert(I != Cache->rend() && "Didn't find current block??");
|
2009-12-09 07:08:01 +00:00
|
|
|
if (I->getBB() != BB)
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
continue;
|
|
|
|
|
2009-12-09 07:08:01 +00:00
|
|
|
assert(I->getResult().isNonLocal() &&
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
"Should only be here with transparent block");
|
2009-12-22 04:25:02 +00:00
|
|
|
I->setResult(MemDepResult::getClobber(BB->begin()));
|
2009-03-29 00:24:04 +00:00
|
|
|
ReverseNonLocalPtrDeps[BB->begin()].insert(CacheKey);
|
2009-12-22 04:25:02 +00:00
|
|
|
Result.push_back(NonLocalDepResult(I->getBB(), I->getResult(),
|
|
|
|
Pointer.getAddr()));
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
break;
|
2008-12-07 02:56:57 +00:00
|
|
|
}
|
2008-12-07 02:15:47 +00:00
|
|
|
}
|
2009-01-23 07:12:16 +00:00
|
|
|
|
2008-12-09 07:47:11 +00:00
|
|
|
// Okay, we're done now. If we added new values to the cache, re-sort it.
|
2009-07-13 17:20:05 +00:00
|
|
|
SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
|
2009-01-22 07:04:01 +00:00
|
|
|
DEBUG(AssertSorted(*Cache));
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
return false;
|
2008-12-07 08:50:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// RemoveCachedNonLocalPointerDependencies - If P exists in
|
|
|
|
/// CachedNonLocalPointerInfo, remove it.
|
|
|
|
void MemoryDependenceAnalysis::
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair P) {
|
|
|
|
CachedNonLocalPointerInfo::iterator It =
|
|
|
|
NonLocalPointerDeps.find(P);
|
|
|
|
if (It == NonLocalPointerDeps.end()) return;
|
|
|
|
|
|
|
|
// Remove all of the entries in the BB->val map. This involves removing
|
|
|
|
// instructions from the reverse map.
|
2008-12-08 07:31:50 +00:00
|
|
|
NonLocalDepInfo &PInfo = It->second.second;
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = PInfo.size(); i != e; ++i) {
|
2009-12-09 07:08:01 +00:00
|
|
|
Instruction *Target = PInfo[i].getResult().getInst();
|
2008-12-07 08:50:20 +00:00
|
|
|
if (Target == 0) continue; // Ignore non-local dep results.
|
2009-12-09 07:08:01 +00:00
|
|
|
assert(Target->getParent() == PInfo[i].getBB());
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
// Eliminating the dirty entry from 'Cache', so update the reverse info.
|
2009-03-29 00:24:04 +00:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalPtrDeps, Target, P);
|
2008-12-07 08:50:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remove P from NonLocalPointerDeps (which deletes NonLocalDepInfo).
|
|
|
|
NonLocalPointerDeps.erase(It);
|
2008-12-07 02:15:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-12-09 22:06:23 +00:00
|
|
|
/// invalidateCachedPointerInfo - This method is used to invalidate cached
|
|
|
|
/// information about the specified pointer, because it may be too
|
|
|
|
/// conservative in memdep. This is an optional call that can be used when
|
|
|
|
/// the client detects an equivalence between the pointer and some other
|
|
|
|
/// value and replaces the other value with ptr. This can make Ptr available
|
|
|
|
/// in more places that cached info does not necessarily keep.
|
|
|
|
void MemoryDependenceAnalysis::invalidateCachedPointerInfo(Value *Ptr) {
|
|
|
|
// If Ptr isn't really a pointer, just ignore it.
|
|
|
|
if (!isa<PointerType>(Ptr->getType())) return;
|
|
|
|
// Flush store info for the pointer.
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, false));
|
|
|
|
// Flush load info for the pointer.
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, true));
|
|
|
|
}
|
|
|
|
|
2007-07-06 23:14:35 +00:00
|
|
|
/// removeInstruction - Remove an instruction from the dependence analysis,
|
|
|
|
/// updating the dependence of instructions that previously depended on it.
|
2007-08-08 22:26:03 +00:00
|
|
|
/// This method attempts to keep the cache coherent using the reverse map.
|
2008-11-28 22:04:47 +00:00
|
|
|
void MemoryDependenceAnalysis::removeInstruction(Instruction *RemInst) {
|
|
|
|
// Walk through the Non-local dependencies, removing this one as the value
|
|
|
|
// for any cached queries.
|
2008-11-30 02:28:25 +00:00
|
|
|
NonLocalDepMapType::iterator NLDI = NonLocalDeps.find(RemInst);
|
|
|
|
if (NLDI != NonLocalDeps.end()) {
|
2008-12-01 01:15:42 +00:00
|
|
|
NonLocalDepInfo &BlockMap = NLDI->second.first;
|
2008-11-30 02:30:50 +00:00
|
|
|
for (NonLocalDepInfo::iterator DI = BlockMap.begin(), DE = BlockMap.end();
|
|
|
|
DI != DE; ++DI)
|
2009-12-09 07:08:01 +00:00
|
|
|
if (Instruction *Inst = DI->getResult().getInst())
|
2008-12-07 18:39:13 +00:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalDeps, Inst, RemInst);
|
2008-11-30 02:28:25 +00:00
|
|
|
NonLocalDeps.erase(NLDI);
|
|
|
|
}
|
2007-07-31 20:01:27 +00:00
|
|
|
|
2008-11-28 22:04:47 +00:00
|
|
|
// If we have a cached local dependence query for this instruction, remove it.
|
2008-11-28 22:28:27 +00:00
|
|
|
//
|
2008-11-29 01:43:36 +00:00
|
|
|
LocalDepMapType::iterator LocalDepEntry = LocalDeps.find(RemInst);
|
|
|
|
if (LocalDepEntry != LocalDeps.end()) {
|
2008-11-28 22:28:27 +00:00
|
|
|
// Remove us from DepInst's reverse set now that the local dep info is gone.
|
2008-12-07 18:39:13 +00:00
|
|
|
if (Instruction *Inst = LocalDepEntry->second.getInst())
|
|
|
|
RemoveFromReverseMap(ReverseLocalDeps, Inst, RemInst);
|
2008-11-30 01:09:30 +00:00
|
|
|
|
|
|
|
// Remove this local dependency info.
|
|
|
|
LocalDeps.erase(LocalDepEntry);
|
2008-12-07 08:50:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// If we have any cached pointer dependencies on this instruction, remove
|
|
|
|
// them. If the instruction has non-pointer type, then it can't be a pointer
|
|
|
|
// base.
|
|
|
|
|
|
|
|
// Remove it from both the load info and the store info. The instruction
|
|
|
|
// can't be in either of these maps if it is non-pointer.
|
|
|
|
if (isa<PointerType>(RemInst->getType())) {
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, false));
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, true));
|
|
|
|
}
|
2008-11-28 22:28:27 +00:00
|
|
|
|
2008-11-28 22:51:08 +00:00
|
|
|
// Loop over all of the things that depend on the instruction we're removing.
|
|
|
|
//
|
2008-11-29 23:30:39 +00:00
|
|
|
SmallVector<std::pair<Instruction*, Instruction*>, 8> ReverseDepsToAdd;
|
2008-12-07 18:42:51 +00:00
|
|
|
|
|
|
|
// If we find RemInst as a clobber or Def in any of the maps for other values,
|
|
|
|
// we need to replace its entry with a dirty version of the instruction after
|
|
|
|
// it. If RemInst is a terminator, we use a null dirty value.
|
|
|
|
//
|
|
|
|
// Using a dirty version of the instruction after RemInst saves having to scan
|
|
|
|
// the entire block to get to this point.
|
|
|
|
MemDepResult NewDirtyVal;
|
|
|
|
if (!RemInst->isTerminator())
|
|
|
|
NewDirtyVal = MemDepResult::getDirty(++BasicBlock::iterator(RemInst));
|
2008-11-29 23:30:39 +00:00
|
|
|
|
2008-11-29 09:20:15 +00:00
|
|
|
ReverseDepMapType::iterator ReverseDepIt = ReverseLocalDeps.find(RemInst);
|
|
|
|
if (ReverseDepIt != ReverseLocalDeps.end()) {
|
2008-11-28 22:51:08 +00:00
|
|
|
SmallPtrSet<Instruction*, 4> &ReverseDeps = ReverseDepIt->second;
|
2008-12-07 08:50:20 +00:00
|
|
|
// RemInst can't be the terminator if it has local stuff depending on it.
|
2008-11-30 01:09:30 +00:00
|
|
|
assert(!ReverseDeps.empty() && !isa<TerminatorInst>(RemInst) &&
|
|
|
|
"Nothing can locally depend on a terminator");
|
|
|
|
|
2008-11-28 22:51:08 +00:00
|
|
|
for (SmallPtrSet<Instruction*, 4>::iterator I = ReverseDeps.begin(),
|
|
|
|
E = ReverseDeps.end(); I != E; ++I) {
|
|
|
|
Instruction *InstDependingOnRemInst = *I;
|
2008-11-30 02:28:25 +00:00
|
|
|
assert(InstDependingOnRemInst != RemInst &&
|
|
|
|
"Already removed our local dep info");
|
2008-11-30 01:09:30 +00:00
|
|
|
|
2008-12-07 18:42:51 +00:00
|
|
|
LocalDeps[InstDependingOnRemInst] = NewDirtyVal;
|
2008-11-28 22:51:08 +00:00
|
|
|
|
2008-11-30 01:09:30 +00:00
|
|
|
// Make sure to remember that new things depend on NewDepInst.
|
2008-12-07 18:42:51 +00:00
|
|
|
assert(NewDirtyVal.getInst() && "There is no way something else can have "
|
|
|
|
"a local dep on this if it is a terminator!");
|
|
|
|
ReverseDepsToAdd.push_back(std::make_pair(NewDirtyVal.getInst(),
|
2008-11-30 01:09:30 +00:00
|
|
|
InstDependingOnRemInst));
|
2008-11-29 23:30:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ReverseLocalDeps.erase(ReverseDepIt);
|
|
|
|
|
|
|
|
// Add new reverse deps after scanning the set, to avoid invalidating the
|
|
|
|
// 'ReverseDeps' reference.
|
|
|
|
while (!ReverseDepsToAdd.empty()) {
|
|
|
|
ReverseLocalDeps[ReverseDepsToAdd.back().first]
|
|
|
|
.insert(ReverseDepsToAdd.back().second);
|
|
|
|
ReverseDepsToAdd.pop_back();
|
2008-11-28 22:51:08 +00:00
|
|
|
}
|
2007-07-06 23:14:35 +00:00
|
|
|
}
|
2007-08-16 21:27:05 +00:00
|
|
|
|
2008-11-29 09:20:15 +00:00
|
|
|
ReverseDepIt = ReverseNonLocalDeps.find(RemInst);
|
|
|
|
if (ReverseDepIt != ReverseNonLocalDeps.end()) {
|
2008-12-07 08:50:20 +00:00
|
|
|
SmallPtrSet<Instruction*, 4> &Set = ReverseDepIt->second;
|
|
|
|
for (SmallPtrSet<Instruction*, 4>::iterator I = Set.begin(), E = Set.end();
|
2008-11-30 02:28:25 +00:00
|
|
|
I != E; ++I) {
|
|
|
|
assert(*I != RemInst && "Already removed NonLocalDep info for RemInst");
|
|
|
|
|
2008-11-30 02:52:26 +00:00
|
|
|
PerInstNLInfo &INLD = NonLocalDeps[*I];
|
|
|
|
// The information is now dirty!
|
2008-12-01 01:15:42 +00:00
|
|
|
INLD.second = true;
|
2008-11-30 02:28:25 +00:00
|
|
|
|
2008-12-01 01:15:42 +00:00
|
|
|
for (NonLocalDepInfo::iterator DI = INLD.first.begin(),
|
|
|
|
DE = INLD.first.end(); DI != DE; ++DI) {
|
2009-12-09 07:08:01 +00:00
|
|
|
if (DI->getResult().getInst() != RemInst) continue;
|
2008-11-30 02:28:25 +00:00
|
|
|
|
|
|
|
// Convert to a dirty entry for the subsequent instruction.
|
2009-12-22 04:25:02 +00:00
|
|
|
DI->setResult(NewDirtyVal);
|
2008-12-07 18:42:51 +00:00
|
|
|
|
|
|
|
if (Instruction *NextI = NewDirtyVal.getInst())
|
2008-11-30 02:28:25 +00:00
|
|
|
ReverseDepsToAdd.push_back(std::make_pair(NextI, *I));
|
|
|
|
}
|
|
|
|
}
|
2008-11-29 23:30:39 +00:00
|
|
|
|
|
|
|
ReverseNonLocalDeps.erase(ReverseDepIt);
|
|
|
|
|
2008-11-29 22:02:15 +00:00
|
|
|
// Add new reverse deps after scanning the set, to avoid invalidating 'Set'
|
|
|
|
while (!ReverseDepsToAdd.empty()) {
|
|
|
|
ReverseNonLocalDeps[ReverseDepsToAdd.back().first]
|
|
|
|
.insert(ReverseDepsToAdd.back().second);
|
|
|
|
ReverseDepsToAdd.pop_back();
|
|
|
|
}
|
2007-08-16 21:27:05 +00:00
|
|
|
}
|
2007-12-08 01:37:09 +00:00
|
|
|
|
2008-12-07 08:50:20 +00:00
|
|
|
// If the instruction is in ReverseNonLocalPtrDeps then it appears as a
|
|
|
|
// value in the NonLocalPointerDeps info.
|
|
|
|
ReverseNonLocalPtrDepTy::iterator ReversePtrDepIt =
|
|
|
|
ReverseNonLocalPtrDeps.find(RemInst);
|
|
|
|
if (ReversePtrDepIt != ReverseNonLocalPtrDeps.end()) {
|
2009-03-29 00:24:04 +00:00
|
|
|
SmallPtrSet<ValueIsLoadPair, 4> &Set = ReversePtrDepIt->second;
|
2008-12-07 08:50:20 +00:00
|
|
|
SmallVector<std::pair<Instruction*, ValueIsLoadPair>,8> ReversePtrDepsToAdd;
|
|
|
|
|
2009-03-29 00:24:04 +00:00
|
|
|
for (SmallPtrSet<ValueIsLoadPair, 4>::iterator I = Set.begin(),
|
|
|
|
E = Set.end(); I != E; ++I) {
|
|
|
|
ValueIsLoadPair P = *I;
|
2008-12-07 08:50:20 +00:00
|
|
|
assert(P.getPointer() != RemInst &&
|
|
|
|
"Already removed NonLocalPointerDeps info for RemInst");
|
|
|
|
|
2008-12-08 07:31:50 +00:00
|
|
|
NonLocalDepInfo &NLPDI = NonLocalPointerDeps[P].second;
|
|
|
|
|
|
|
|
// The cache is not valid for any specific block anymore.
|
Implement initial support for PHI translation in memdep. This means that
memdep keeps track of how PHIs affect the pointer in dep queries, which
allows it to eliminate the load in cases like rle-phi-translate.ll, which
basically end up being:
BB1:
X = load P
br BB3
BB2:
Y = load Q
br BB3
BB3:
R = phi [P] [Q]
load R
turning "load R" into a phi of X/Y. In addition to additional exposed
opportunities, this makes memdep safe in many cases that it wasn't before
(which is required for load PRE) and also makes it substantially more
efficient. For example, consider:
bb1: // has many predecessors.
P = some_operator()
load P
In this example, previously memdep would scan all the predecessors of BB1
to see if they had something that would mustalias P. In some cases (e.g.
test/Transforms/GVN/rle-must-alias.ll) it would actually find them and end
up eliminating something. In many other cases though, it would scan and not
find anything useful. MemDep now stops at a block if the pointer is defined
in that block and cannot be phi translated to predecessors. This causes it
to miss the (rare) cases like rle-must-alias.ll, but makes it faster by not
scanning tons of stuff that is unlikely to be useful. For example, this
speeds up GVN as a whole from 3.928s to 2.448s (60%)!. IMO, scalar GVN
should be enhanced to simplify the rle-must-alias pointer base anyway, which
would allow the loads to be eliminated.
In the future, this should be enhanced to phi translate through geps and
bitcasts as well (as indicated by FIXMEs) making memdep even more powerful.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61022 91177308-0d34-0410-b5e6-96231b3b80d8
2008-12-15 03:35:32 +00:00
|
|
|
NonLocalPointerDeps[P].first = BBSkipFirstBlockPair();
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
// Update any entries for RemInst to use the instruction after it.
|
|
|
|
for (NonLocalDepInfo::iterator DI = NLPDI.begin(), DE = NLPDI.end();
|
|
|
|
DI != DE; ++DI) {
|
2009-12-09 07:08:01 +00:00
|
|
|
if (DI->getResult().getInst() != RemInst) continue;
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
// Convert to a dirty entry for the subsequent instruction.
|
2009-12-22 04:25:02 +00:00
|
|
|
DI->setResult(NewDirtyVal);
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
if (Instruction *NewDirtyInst = NewDirtyVal.getInst())
|
|
|
|
ReversePtrDepsToAdd.push_back(std::make_pair(NewDirtyInst, P));
|
|
|
|
}
|
2009-01-23 07:12:16 +00:00
|
|
|
|
|
|
|
// Re-sort the NonLocalDepInfo. Changing the dirty entry to its
|
|
|
|
// subsequent value may invalidate the sortedness.
|
|
|
|
std::sort(NLPDI.begin(), NLPDI.end());
|
2008-12-07 08:50:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ReverseNonLocalPtrDeps.erase(ReversePtrDepIt);
|
|
|
|
|
|
|
|
while (!ReversePtrDepsToAdd.empty()) {
|
|
|
|
ReverseNonLocalPtrDeps[ReversePtrDepsToAdd.back().first]
|
2009-03-29 00:24:04 +00:00
|
|
|
.insert(ReversePtrDepsToAdd.back().second);
|
2008-12-07 08:50:20 +00:00
|
|
|
ReversePtrDepsToAdd.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-11-30 02:28:25 +00:00
|
|
|
assert(!NonLocalDeps.count(RemInst) && "RemInst got reinserted?");
|
2008-11-30 19:24:31 +00:00
|
|
|
AA->deleteValue(RemInst);
|
2008-11-28 22:04:47 +00:00
|
|
|
DEBUG(verifyRemoved(RemInst));
|
2007-07-06 23:14:35 +00:00
|
|
|
}
|
2008-11-29 21:25:10 +00:00
|
|
|
/// verifyRemoved - Verify that the specified instruction does not occur
|
|
|
|
/// in our internal data structures.
|
|
|
|
void MemoryDependenceAnalysis::verifyRemoved(Instruction *D) const {
|
|
|
|
for (LocalDepMapType::const_iterator I = LocalDeps.begin(),
|
|
|
|
E = LocalDeps.end(); I != E; ++I) {
|
|
|
|
assert(I->first != D && "Inst occurs in data structures");
|
2008-11-30 23:17:19 +00:00
|
|
|
assert(I->second.getInst() != D &&
|
2008-11-29 21:25:10 +00:00
|
|
|
"Inst occurs in data structures");
|
|
|
|
}
|
|
|
|
|
2008-12-07 08:50:20 +00:00
|
|
|
for (CachedNonLocalPointerInfo::const_iterator I =NonLocalPointerDeps.begin(),
|
|
|
|
E = NonLocalPointerDeps.end(); I != E; ++I) {
|
|
|
|
assert(I->first.getPointer() != D && "Inst occurs in NLPD map key");
|
2008-12-08 07:31:50 +00:00
|
|
|
const NonLocalDepInfo &Val = I->second.second;
|
2008-12-07 08:50:20 +00:00
|
|
|
for (NonLocalDepInfo::const_iterator II = Val.begin(), E = Val.end();
|
|
|
|
II != E; ++II)
|
2009-12-09 07:08:01 +00:00
|
|
|
assert(II->getResult().getInst() != D && "Inst occurs as NLPD value");
|
2008-12-07 08:50:20 +00:00
|
|
|
}
|
|
|
|
|
2008-11-29 21:25:10 +00:00
|
|
|
for (NonLocalDepMapType::const_iterator I = NonLocalDeps.begin(),
|
|
|
|
E = NonLocalDeps.end(); I != E; ++I) {
|
|
|
|
assert(I->first != D && "Inst occurs in data structures");
|
2008-11-30 02:52:26 +00:00
|
|
|
const PerInstNLInfo &INLD = I->second;
|
2008-12-01 01:15:42 +00:00
|
|
|
for (NonLocalDepInfo::const_iterator II = INLD.first.begin(),
|
|
|
|
EE = INLD.first.end(); II != EE; ++II)
|
2009-12-09 07:08:01 +00:00
|
|
|
assert(II->getResult().getInst() != D && "Inst occurs in data structures");
|
2008-11-29 21:25:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (ReverseDepMapType::const_iterator I = ReverseLocalDeps.begin(),
|
2008-11-30 02:28:25 +00:00
|
|
|
E = ReverseLocalDeps.end(); I != E; ++I) {
|
|
|
|
assert(I->first != D && "Inst occurs in data structures");
|
2008-11-29 21:25:10 +00:00
|
|
|
for (SmallPtrSet<Instruction*, 4>::const_iterator II = I->second.begin(),
|
|
|
|
EE = I->second.end(); II != EE; ++II)
|
|
|
|
assert(*II != D && "Inst occurs in data structures");
|
2008-11-30 02:28:25 +00:00
|
|
|
}
|
2008-11-29 21:25:10 +00:00
|
|
|
|
|
|
|
for (ReverseDepMapType::const_iterator I = ReverseNonLocalDeps.begin(),
|
|
|
|
E = ReverseNonLocalDeps.end();
|
2008-11-30 02:28:25 +00:00
|
|
|
I != E; ++I) {
|
|
|
|
assert(I->first != D && "Inst occurs in data structures");
|
2008-11-29 21:25:10 +00:00
|
|
|
for (SmallPtrSet<Instruction*, 4>::const_iterator II = I->second.begin(),
|
|
|
|
EE = I->second.end(); II != EE; ++II)
|
|
|
|
assert(*II != D && "Inst occurs in data structures");
|
2008-11-30 02:28:25 +00:00
|
|
|
}
|
2008-12-07 08:50:20 +00:00
|
|
|
|
|
|
|
for (ReverseNonLocalPtrDepTy::const_iterator
|
|
|
|
I = ReverseNonLocalPtrDeps.begin(),
|
|
|
|
E = ReverseNonLocalPtrDeps.end(); I != E; ++I) {
|
|
|
|
assert(I->first != D && "Inst occurs in rev NLPD map");
|
|
|
|
|
2009-03-29 00:24:04 +00:00
|
|
|
for (SmallPtrSet<ValueIsLoadPair, 4>::const_iterator II = I->second.begin(),
|
2008-12-07 08:50:20 +00:00
|
|
|
E = I->second.end(); II != E; ++II)
|
2009-03-29 00:24:04 +00:00
|
|
|
assert(*II != ValueIsLoadPair(D, false) &&
|
|
|
|
*II != ValueIsLoadPair(D, true) &&
|
2008-12-07 08:50:20 +00:00
|
|
|
"Inst occurs in ReverseNonLocalPtrDeps map");
|
|
|
|
}
|
|
|
|
|
2008-11-29 21:25:10 +00:00
|
|
|
}
|