2013-06-11 01:10:59 +02:00
|
|
|
//===- MemoryDependenceAnalysis.cpp - Mem Deps Implementation -------------===//
|
2007-07-07 01:14:35 +02:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 21:36:04 +01:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-07-07 01:14:35 +02:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements an analysis that determines, for a given memory
|
2013-03-20 22:47:51 +01:00
|
|
|
// operation, what preceding memory operations it depends on. It builds on
|
2007-08-09 00:01:54 +02:00
|
|
|
// alias analysis information, and tries to provide a lazy, caching interface to
|
2007-07-07 01:14:35 +02:00
|
|
|
// a common kind of alias information query.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
|
2016-08-25 02:45:04 +02:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2012-12-03 17:50:05 +01:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
2007-07-07 01:14:35 +02:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2016-12-19 09:22:17 +01:00
|
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
2009-10-27 21:05:49 +01:00
|
|
|
#include "llvm/Analysis/MemoryBuiltins.h"
|
2009-12-09 02:59:31 +01:00
|
|
|
#include "llvm/Analysis/PHITransAddr.h"
|
2015-07-31 16:31:35 +02:00
|
|
|
#include "llvm/Analysis/OrderedBasicBlock.h"
|
2010-12-15 21:02:24 +01:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2015-08-12 19:47:44 +02:00
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
2016-08-25 02:45:04 +02:00
|
|
|
#include "llvm/IR/CallSite.h"
|
|
|
|
#include "llvm/IR/Constants.h"
|
2013-01-02 12:36:10 +01:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2016-08-25 02:45:04 +02:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-01-13 10:26:24 +01:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 12:36:10 +01:00
|
|
|
#include "llvm/IR/Function.h"
|
2016-08-25 02:45:04 +02:00
|
|
|
#include "llvm/IR/Instruction.h"
|
2013-01-02 12:36:10 +01:00
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2014-03-04 13:09:19 +01:00
|
|
|
#include "llvm/IR/PredIteratorCache.h"
|
2016-08-25 02:45:04 +02:00
|
|
|
#include "llvm/Support/AtomicOrdering.h"
|
|
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Support/Compiler.h"
|
2012-12-03 17:50:05 +01:00
|
|
|
#include "llvm/Support/Debug.h"
|
2016-08-25 02:45:04 +02:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <cassert>
|
|
|
|
#include <iterator>
|
|
|
|
|
2007-07-07 01:14:35 +02:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 04:48:03 +02:00
|
|
|
#define DEBUG_TYPE "memdep"
|
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
STATISTIC(NumCacheNonLocal, "Number of fully cached non-local responses");
|
|
|
|
STATISTIC(NumCacheDirtyNonLocal, "Number of dirty cached non-local responses");
|
2008-11-29 23:02:15 +01:00
|
|
|
STATISTIC(NumUncacheNonLocal, "Number of uncached non-local responses");
|
2008-12-07 09:50:20 +01:00
|
|
|
|
|
|
|
STATISTIC(NumCacheNonLocalPtr,
|
|
|
|
"Number of fully cached non-local ptr responses");
|
|
|
|
STATISTIC(NumCacheDirtyNonLocalPtr,
|
|
|
|
"Number of cached, but dirty, non-local ptr responses");
|
2016-03-07 11:19:30 +01:00
|
|
|
STATISTIC(NumUncacheNonLocalPtr, "Number of uncached non-local ptr responses");
|
2008-12-08 08:31:50 +01:00
|
|
|
STATISTIC(NumCacheCompleteNonLocalPtr,
|
|
|
|
"Number of block queries that were completely cached");
|
2008-12-07 09:50:20 +01:00
|
|
|
|
2011-06-16 01:59:25 +02:00
|
|
|
// Limit for the number of instructions to scan in a block.
|
2015-07-21 23:50:39 +02:00
|
|
|
|
|
|
|
static cl::opt<unsigned> BlockScanLimit(
|
|
|
|
"memdep-block-scan-limit", cl::Hidden, cl::init(100),
|
|
|
|
cl::desc("The number of instructions to scan in a block in memory "
|
|
|
|
"dependency analysis (default = 100)"));
|
2011-06-16 01:59:25 +02:00
|
|
|
|
2016-03-07 11:19:30 +01:00
|
|
|
static cl::opt<unsigned>
|
|
|
|
BlockNumberLimit("memdep-block-number-limit", cl::Hidden, cl::init(1000),
|
|
|
|
cl::desc("The number of blocks to scan during memory "
|
|
|
|
"dependency analysis (default = 1000)"));
|
2016-02-20 12:24:44 +01:00
|
|
|
|
2014-10-01 22:07:13 +02:00
|
|
|
// Limit on the number of memdep results to process.
|
2014-10-02 15:17:11 +02:00
|
|
|
static const unsigned int NumResultsLimit = 100;
|
2014-10-01 22:07:13 +02:00
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// This is a helper function that removes Val from 'Inst's set in ReverseMap.
|
|
|
|
///
|
|
|
|
/// If the set becomes empty, remove Inst's entry.
|
2008-12-07 19:39:13 +01:00
|
|
|
template <typename KeyTy>
|
2016-03-07 11:19:30 +01:00
|
|
|
static void
|
|
|
|
RemoveFromReverseMap(DenseMap<Instruction *, SmallPtrSet<KeyTy, 4>> &ReverseMap,
|
|
|
|
Instruction *Inst, KeyTy Val) {
|
|
|
|
typename DenseMap<Instruction *, SmallPtrSet<KeyTy, 4>>::iterator InstIt =
|
|
|
|
ReverseMap.find(Inst);
|
2008-12-07 19:39:13 +01:00
|
|
|
assert(InstIt != ReverseMap.end() && "Reverse map out of sync?");
|
|
|
|
bool Found = InstIt->second.erase(Val);
|
2016-03-07 11:19:30 +01:00
|
|
|
assert(Found && "Invalid reverse map!");
|
|
|
|
(void)Found;
|
2008-12-07 19:39:13 +01:00
|
|
|
if (InstIt->second.empty())
|
|
|
|
ReverseMap.erase(InstIt);
|
|
|
|
}
|
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// If the given instruction references a specific memory location, fill in Loc
|
|
|
|
/// with the details, otherwise set Loc.Ptr to null.
|
|
|
|
///
|
|
|
|
/// Returns a ModRefInfo value describing the general behavior of the
|
2010-11-10 22:51:35 +01:00
|
|
|
/// instruction.
|
2015-07-23 01:15:57 +02:00
|
|
|
static ModRefInfo GetLocation(const Instruction *Inst, MemoryLocation &Loc,
|
2015-08-12 19:47:44 +02:00
|
|
|
const TargetLibraryInfo &TLI) {
|
2010-11-10 22:51:35 +01:00
|
|
|
if (const LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
|
2011-08-15 22:54:19 +02:00
|
|
|
if (LI->isUnordered()) {
|
2015-06-04 04:03:15 +02:00
|
|
|
Loc = MemoryLocation::get(LI);
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_Ref;
|
2013-03-21 00:53:45 +01:00
|
|
|
}
|
2016-04-06 23:19:33 +02:00
|
|
|
if (LI->getOrdering() == AtomicOrdering::Monotonic) {
|
2015-06-04 04:03:15 +02:00
|
|
|
Loc = MemoryLocation::get(LI);
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_ModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
2015-06-17 09:18:54 +02:00
|
|
|
Loc = MemoryLocation();
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_ModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
|
2011-08-15 22:54:19 +02:00
|
|
|
if (SI->isUnordered()) {
|
2015-06-04 04:03:15 +02:00
|
|
|
Loc = MemoryLocation::get(SI);
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_Mod;
|
2013-03-21 00:53:45 +01:00
|
|
|
}
|
2016-04-06 23:19:33 +02:00
|
|
|
if (SI->getOrdering() == AtomicOrdering::Monotonic) {
|
2015-06-04 04:03:15 +02:00
|
|
|
Loc = MemoryLocation::get(SI);
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_ModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
2015-06-17 09:18:54 +02:00
|
|
|
Loc = MemoryLocation();
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_ModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const VAArgInst *V = dyn_cast<VAArgInst>(Inst)) {
|
2015-06-04 04:03:15 +02:00
|
|
|
Loc = MemoryLocation::get(V);
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_ModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
|
|
|
|
2015-08-12 19:47:44 +02:00
|
|
|
if (const CallInst *CI = isFreeCall(Inst, &TLI)) {
|
2010-11-10 22:51:35 +01:00
|
|
|
// calls to free() deallocate the entire structure
|
2015-06-17 09:18:54 +02:00
|
|
|
Loc = MemoryLocation(CI->getArgOperand(0));
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_Mod;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
|
|
|
|
2014-07-24 14:16:19 +02:00
|
|
|
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
|
|
|
|
AAMDNodes AAInfo;
|
|
|
|
|
2010-11-10 22:51:35 +01:00
|
|
|
switch (II->getIntrinsicID()) {
|
|
|
|
case Intrinsic::lifetime_start:
|
|
|
|
case Intrinsic::lifetime_end:
|
|
|
|
case Intrinsic::invariant_start:
|
2014-07-24 14:16:19 +02:00
|
|
|
II->getAAMetadata(AAInfo);
|
2015-06-17 09:18:54 +02:00
|
|
|
Loc = MemoryLocation(
|
|
|
|
II->getArgOperand(1),
|
|
|
|
cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AAInfo);
|
2010-11-10 22:51:35 +01:00
|
|
|
// These intrinsics don't really modify the memory, but returning Mod
|
|
|
|
// will allow them to be handled conservatively.
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_Mod;
|
2010-11-10 22:51:35 +01:00
|
|
|
case Intrinsic::invariant_end:
|
2014-07-24 14:16:19 +02:00
|
|
|
II->getAAMetadata(AAInfo);
|
2015-06-17 09:18:54 +02:00
|
|
|
Loc = MemoryLocation(
|
|
|
|
II->getArgOperand(2),
|
|
|
|
cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AAInfo);
|
2010-11-10 22:51:35 +01:00
|
|
|
// These intrinsics don't really modify the memory, but returning Mod
|
|
|
|
// will allow them to be handled conservatively.
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_Mod;
|
2010-11-10 22:51:35 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2014-07-24 14:16:19 +02:00
|
|
|
}
|
2010-11-10 22:51:35 +01:00
|
|
|
|
|
|
|
// Otherwise, just do the coarse-grained thing that always works.
|
|
|
|
if (Inst->mayWriteToMemory())
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_ModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
if (Inst->mayReadFromMemory())
|
2015-07-23 01:15:57 +02:00
|
|
|
return MRI_Ref;
|
|
|
|
return MRI_NoModRef;
|
2010-11-10 22:51:35 +01:00
|
|
|
}
|
2008-12-01 02:15:42 +01:00
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// Private helper for finding the local dependencies of a call site.
|
2016-03-10 01:55:30 +01:00
|
|
|
MemDepResult MemoryDependenceResults::getCallSiteDependencyFrom(
|
2016-03-07 11:19:30 +01:00
|
|
|
CallSite CS, bool isReadOnlyCall, BasicBlock::iterator ScanIt,
|
|
|
|
BasicBlock *BB) {
|
2011-06-16 01:59:25 +02:00
|
|
|
unsigned Limit = BlockScanLimit;
|
|
|
|
|
2016-10-06 12:58:41 +02:00
|
|
|
// Walk backwards through the block, looking for dependencies.
|
2008-11-29 04:47:00 +01:00
|
|
|
while (ScanIt != BB->begin()) {
|
2011-06-16 01:59:25 +02:00
|
|
|
// Limit the amount of scanning we do so we don't end up with quadratic
|
2013-03-20 22:47:51 +01:00
|
|
|
// running time on extreme testcases.
|
2011-06-16 01:59:25 +02:00
|
|
|
--Limit;
|
|
|
|
if (!Limit)
|
|
|
|
return MemDepResult::getUnknown();
|
|
|
|
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
Instruction *Inst = &*--ScanIt;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2007-07-10 19:59:22 +02:00
|
|
|
// If this inst is a memory op, get the pointer it accessed
|
2015-06-17 09:18:54 +02:00
|
|
|
MemoryLocation Loc;
|
2016-03-10 01:55:30 +01:00
|
|
|
ModRefInfo MR = GetLocation(Inst, Loc, TLI);
|
2010-11-10 22:51:35 +01:00
|
|
|
if (Loc.Ptr) {
|
|
|
|
// A simple instruction.
|
2016-03-10 01:55:30 +01:00
|
|
|
if (AA.getModRefInfo(CS, Loc) != MRI_NoModRef)
|
2010-11-10 22:51:35 +01:00
|
|
|
return MemDepResult::getClobber(Inst);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-04-10 16:50:08 +02:00
|
|
|
if (auto InstCS = CallSite(Inst)) {
|
2009-03-09 06:12:38 +01:00
|
|
|
// Debug intrinsics don't cause dependences.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (isa<DbgInfoIntrinsic>(Inst))
|
|
|
|
continue;
|
2008-12-05 22:04:20 +01:00
|
|
|
// If these two calls do not interfere, look past it.
|
2016-03-10 01:55:30 +01:00
|
|
|
switch (AA.getModRefInfo(CS, InstCS)) {
|
2015-07-23 01:15:57 +02:00
|
|
|
case MRI_NoModRef:
|
2010-08-06 00:09:15 +02:00
|
|
|
// If the two calls are the same, return InstCS as a Def, so that
|
|
|
|
// CS can be found redundant and eliminated.
|
2015-07-23 01:15:57 +02:00
|
|
|
if (isReadOnlyCall && !(MR & MRI_Mod) &&
|
2010-08-06 00:09:15 +02:00
|
|
|
CS.getInstruction()->isIdenticalToWhenDefined(Inst))
|
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
|
|
|
|
// Otherwise if the two calls don't interact (e.g. InstCS is readnone)
|
|
|
|
// keep scanning.
|
2012-08-14 01:03:43 +02:00
|
|
|
continue;
|
2008-12-09 22:19:42 +01:00
|
|
|
default:
|
2008-12-05 22:04:20 +01:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2008-12-09 22:19:42 +01:00
|
|
|
}
|
2008-11-30 02:44:00 +01:00
|
|
|
}
|
2012-08-14 01:03:43 +02:00
|
|
|
|
|
|
|
// If we could not obtain a pointer for the instruction and the instruction
|
|
|
|
// touches memory then assume that this is a dependency.
|
2015-07-23 01:15:57 +02:00
|
|
|
if (MR != MRI_NoModRef)
|
2012-08-14 01:03:43 +02:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2007-07-10 19:59:22 +02:00
|
|
|
}
|
2012-08-14 01:03:43 +02:00
|
|
|
|
2011-06-15 02:47:34 +02:00
|
|
|
// No dependence found. If this is the entry block of the function, it is
|
|
|
|
// unknown, otherwise it is non-local.
|
2008-12-07 03:15:47 +01:00
|
|
|
if (BB != &BB->getParent()->getEntryBlock())
|
|
|
|
return MemDepResult::getNonLocal();
|
2011-10-14 00:14:57 +02:00
|
|
|
return MemDepResult::getNonFuncLocal();
|
2007-07-10 19:59:22 +02:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
unsigned MemoryDependenceResults::getLoadLoadClobberFullWidthSize(
|
2015-03-10 03:37:25 +01:00
|
|
|
const Value *MemLocBase, int64_t MemLocOffs, unsigned MemLocSize,
|
|
|
|
const LoadInst *LI) {
|
2011-08-15 22:54:19 +02:00
|
|
|
// We can only extend simple integer loads.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (!isa<IntegerType>(LI->getType()) || !LI->isSimple())
|
|
|
|
return 0;
|
2013-02-13 06:59:45 +01:00
|
|
|
|
|
|
|
// Load widening is hostile to ThreadSanitizer: it may cause false positives
|
|
|
|
// or make the reports more cryptic (access sizes are wrong).
|
2015-02-14 01:12:15 +01:00
|
|
|
if (LI->getParent()->getParent()->hasFnAttribute(Attribute::SanitizeThread))
|
2013-02-13 06:59:45 +01:00
|
|
|
return 0;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2015-03-10 03:37:25 +01:00
|
|
|
const DataLayout &DL = LI->getModule()->getDataLayout();
|
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// Get the base of this load.
|
|
|
|
int64_t LIOffs = 0;
|
2013-03-20 22:47:51 +01:00
|
|
|
const Value *LIBase =
|
2015-03-10 03:37:25 +01:00
|
|
|
GetPointerBaseWithConstantOffset(LI->getPointerOperand(), LIOffs, DL);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// If the two pointers are not based on the same pointer, we can't tell that
|
|
|
|
// they are related.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (LIBase != MemLocBase)
|
|
|
|
return 0;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// Okay, the two values are based on the same pointer, but returned as
|
|
|
|
// no-alias. This happens when we have things like two byte loads at "P+1"
|
|
|
|
// and "P+3". Check to see if increasing the size of the "LI" load up to its
|
|
|
|
// alignment (or the largest native integer type) will allow us to load all
|
|
|
|
// the bits required by MemLoc.
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// If MemLoc is before LI, then no widening of LI will help us out.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (MemLocOffs < LIOffs)
|
|
|
|
return 0;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// Get the alignment of the load in bytes. We assume that it is safe to load
|
|
|
|
// any legal integer up to this size without a problem. For example, if we're
|
|
|
|
// looking at an i8 load on x86-32 that is known 1024 byte aligned, we can
|
|
|
|
// widen it up to an i32 load. If it is known 2-byte aligned, we can widen it
|
|
|
|
// to i16.
|
|
|
|
unsigned LoadAlign = LI->getAlignment();
|
|
|
|
|
2016-03-07 11:19:30 +01:00
|
|
|
int64_t MemLocEnd = MemLocOffs + MemLocSize;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// If no amount of rounding up will let MemLoc fit into LI, then bail out.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (LIOffs + LoadAlign < MemLocEnd)
|
|
|
|
return 0;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// This is the size of the load to try. Start with the next larger power of
|
|
|
|
// two.
|
2016-03-07 11:19:30 +01:00
|
|
|
unsigned NewLoadByteSize = LI->getType()->getPrimitiveSizeInBits() / 8U;
|
2011-04-27 00:42:01 +02:00
|
|
|
NewLoadByteSize = NextPowerOf2(NewLoadByteSize);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-08-25 02:45:04 +02:00
|
|
|
while (true) {
|
2011-04-27 00:42:01 +02:00
|
|
|
// If this load size is bigger than our known alignment or would not fit
|
|
|
|
// into a native integer register, then we fail.
|
|
|
|
if (NewLoadByteSize > LoadAlign ||
|
2016-03-07 11:19:30 +01:00
|
|
|
!DL.fitsInLegalInteger(NewLoadByteSize * 8))
|
2011-04-28 09:29:08 +02:00
|
|
|
return 0;
|
2011-04-27 00:42:01 +02:00
|
|
|
|
2015-02-14 01:12:15 +01:00
|
|
|
if (LIOffs + NewLoadByteSize > MemLocEnd &&
|
|
|
|
LI->getParent()->getParent()->hasFnAttribute(
|
|
|
|
Attribute::SanitizeAddress))
|
2012-02-06 23:48:56 +01:00
|
|
|
// We will be reading past the location accessed by the original program.
|
|
|
|
// While this is safe in a regular build, Address Safety analysis tools
|
|
|
|
// may start reporting false warnings. So, don't do widening.
|
|
|
|
return 0;
|
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// If a load of this width would include all of MemLoc, then we succeed.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (LIOffs + NewLoadByteSize >= MemLocEnd)
|
2011-04-28 09:29:08 +02:00
|
|
|
return NewLoadByteSize;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
NewLoadByteSize <<= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-26 19:54:27 +01:00
|
|
|
static bool isVolatile(Instruction *Inst) {
|
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
|
|
|
|
return LI->isVolatile();
|
|
|
|
else if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
|
|
|
|
return SI->isVolatile();
|
|
|
|
else if (AtomicCmpXchgInst *AI = dyn_cast<AtomicCmpXchgInst>(Inst))
|
|
|
|
return AI->isVolatile();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
MemDepResult MemoryDependenceResults::getPointerDependencyFrom(
|
2015-06-17 09:18:54 +02:00
|
|
|
const MemoryLocation &MemLoc, bool isLoad, BasicBlock::iterator ScanIt,
|
limit the number of instructions per block examined by dead store elimination
Summary: Dead store elimination gets very expensive when large numbers of instructions need to be analyzed. This patch limits the number of instructions analyzed per store to the value of the memdep-block-scan-limit parameter (which defaults to 100). This resulted in no observed difference in performance of the generated code, and no change in the statistics for the dead store elimination pass, but improved compilation time on some files by more than an order of magnitude.
Reviewers: dexonsmith, bruno, george.burgess.iv, dberlin, reames, davidxl
Subscribers: davide, chandlerc, dberlin, davidxl, eraman, tejohnson, mbodart, llvm-commits
Differential Revision: https://reviews.llvm.org/D15537
llvm-svn: 279833
2016-08-26 18:34:27 +02:00
|
|
|
BasicBlock *BB, Instruction *QueryInst, unsigned *Limit) {
|
2008-12-07 03:15:47 +01:00
|
|
|
|
2017-01-12 12:33:58 +01:00
|
|
|
MemDepResult InvariantGroupDependency = MemDepResult::getUnknown();
|
2015-10-03 00:12:22 +02:00
|
|
|
if (QueryInst != nullptr) {
|
|
|
|
if (auto *LI = dyn_cast<LoadInst>(QueryInst)) {
|
2017-01-12 12:33:58 +01:00
|
|
|
InvariantGroupDependency = getInvariantGroupPointerDependency(LI, BB);
|
2015-10-03 00:12:22 +02:00
|
|
|
|
2017-01-11 17:23:54 +01:00
|
|
|
if (InvariantGroupDependency.isDef())
|
|
|
|
return InvariantGroupDependency;
|
2015-10-03 00:12:22 +02:00
|
|
|
}
|
|
|
|
}
|
2017-01-12 12:33:58 +01:00
|
|
|
MemDepResult SimpleDep = getSimplePointerDependencyFrom(
|
|
|
|
MemLoc, isLoad, ScanIt, BB, QueryInst, Limit);
|
|
|
|
if (SimpleDep.isDef())
|
|
|
|
return SimpleDep;
|
|
|
|
// Non-local invariant group dependency indicates there is non local Def
|
|
|
|
// (it only returns nonLocal if it finds nonLocal def), which is better than
|
|
|
|
// local clobber and everything else.
|
|
|
|
if (InvariantGroupDependency.isNonLocal())
|
|
|
|
return InvariantGroupDependency;
|
|
|
|
|
|
|
|
assert(InvariantGroupDependency.isUnknown() &&
|
|
|
|
"InvariantGroupDependency should be only unknown at this point");
|
|
|
|
return SimpleDep;
|
2015-10-03 00:12:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
MemDepResult
|
2016-03-10 01:55:30 +01:00
|
|
|
MemoryDependenceResults::getInvariantGroupPointerDependency(LoadInst *LI,
|
2016-11-08 19:20:51 +01:00
|
|
|
BasicBlock *BB) {
|
2016-12-30 19:45:07 +01:00
|
|
|
|
|
|
|
auto *InvariantGroupMD = LI->getMetadata(LLVMContext::MD_invariant_group);
|
|
|
|
if (!InvariantGroupMD)
|
|
|
|
return MemDepResult::getUnknown();
|
|
|
|
|
2017-01-08 23:26:06 +01:00
|
|
|
// Take the ptr operand after all casts and geps 0. This way we can search
|
|
|
|
// cast graph down only.
|
|
|
|
Value *LoadOperand = LI->getPointerOperand()->stripPointerCasts();
|
|
|
|
|
2015-10-03 00:12:22 +02:00
|
|
|
// It's is not safe to walk the use list of global value, because function
|
|
|
|
// passes aren't allowed to look outside their functions.
|
2017-01-08 23:26:06 +01:00
|
|
|
// FIXME: this could be fixed by filtering instructions from outside
|
|
|
|
// of current function.
|
2015-10-03 00:12:22 +02:00
|
|
|
if (isa<GlobalValue>(LoadOperand))
|
|
|
|
return MemDepResult::getUnknown();
|
|
|
|
|
|
|
|
// Queue to process all pointers that are equivalent to load operand.
|
2016-12-30 19:45:07 +01:00
|
|
|
SmallVector<const Value *, 8> LoadOperandsQueue;
|
2017-01-08 23:26:06 +01:00
|
|
|
LoadOperandsQueue.push_back(LoadOperand);
|
2017-01-12 12:33:58 +01:00
|
|
|
|
|
|
|
Instruction *ClosestDependency = nullptr;
|
|
|
|
// Order of instructions in uses list is unpredictible. In order to always
|
|
|
|
// get the same result, we will look for the closest dominance.
|
|
|
|
auto GetClosestDependency = [this](Instruction *Best, Instruction *Other) {
|
|
|
|
assert(Other && "Must call it with not null instruction");
|
|
|
|
if (Best == nullptr || DT.dominates(Best, Other))
|
|
|
|
return Other;
|
|
|
|
return Best;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// FIXME: This loop is O(N^2) because dominates can be O(n) and in worst case
|
|
|
|
// we will see all the instructions. This should be fixed in MSSA.
|
2015-10-03 00:12:22 +02:00
|
|
|
while (!LoadOperandsQueue.empty()) {
|
2016-12-30 19:45:07 +01:00
|
|
|
const Value *Ptr = LoadOperandsQueue.pop_back_val();
|
2017-01-08 23:26:06 +01:00
|
|
|
assert(Ptr && !isa<GlobalValue>(Ptr) &&
|
|
|
|
"Null or GlobalValue should not be inserted");
|
2016-12-30 19:45:07 +01:00
|
|
|
|
|
|
|
for (const Use &Us : Ptr->uses()) {
|
2015-10-03 00:12:22 +02:00
|
|
|
auto *U = dyn_cast<Instruction>(Us.getUser());
|
2016-03-11 14:46:00 +01:00
|
|
|
if (!U || U == LI || !DT.dominates(U, LI))
|
2015-10-03 00:12:22 +02:00
|
|
|
continue;
|
|
|
|
|
2016-12-30 19:45:07 +01:00
|
|
|
// Bitcast or gep with zeros are using Ptr. Add to queue to check it's
|
|
|
|
// users. U = bitcast Ptr
|
|
|
|
if (isa<BitCastInst>(U)) {
|
2017-01-08 23:26:06 +01:00
|
|
|
LoadOperandsQueue.push_back(U);
|
2015-10-03 00:12:22 +02:00
|
|
|
continue;
|
|
|
|
}
|
2017-01-08 23:26:06 +01:00
|
|
|
// Gep with zeros is equivalent to bitcast.
|
|
|
|
// FIXME: we are not sure if some bitcast should be canonicalized to gep 0
|
|
|
|
// or gep 0 to bitcast because of SROA, so there are 2 forms. When
|
|
|
|
// typeless pointers will be ready then both cases will be gone
|
|
|
|
// (and this BFS also won't be needed).
|
2016-12-30 19:45:07 +01:00
|
|
|
if (auto *GEP = dyn_cast<GetElementPtrInst>(U))
|
|
|
|
if (GEP->hasAllZeroIndices()) {
|
2017-01-08 23:26:06 +01:00
|
|
|
LoadOperandsQueue.push_back(U);
|
2016-12-30 19:45:07 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-10-03 00:12:22 +02:00
|
|
|
// If we hit load/store with the same invariant.group metadata (and the
|
|
|
|
// same pointer operand) we can assume that value pointed by pointer
|
|
|
|
// operand didn't change.
|
2017-01-12 12:33:58 +01:00
|
|
|
if ((isa<LoadInst>(U) || isa<StoreInst>(U)) &&
|
2015-10-03 00:12:22 +02:00
|
|
|
U->getMetadata(LLVMContext::MD_invariant_group) == InvariantGroupMD)
|
2017-01-12 12:33:58 +01:00
|
|
|
ClosestDependency = GetClosestDependency(ClosestDependency, U);
|
2015-10-03 00:12:22 +02:00
|
|
|
}
|
|
|
|
}
|
2017-01-12 12:33:58 +01:00
|
|
|
|
|
|
|
if (!ClosestDependency)
|
|
|
|
return MemDepResult::getUnknown();
|
|
|
|
if (ClosestDependency->getParent() == BB)
|
|
|
|
return MemDepResult::getDef(ClosestDependency);
|
|
|
|
// Def(U) can't be returned here because it is non-local. If local
|
|
|
|
// dependency won't be found then return nonLocal counting that the
|
|
|
|
// user will call getNonLocalPointerDependency, which will return cached
|
|
|
|
// result.
|
|
|
|
NonLocalDefsCache.try_emplace(
|
|
|
|
LI, NonLocalDepResult(ClosestDependency->getParent(),
|
|
|
|
MemDepResult::getDef(ClosestDependency), nullptr));
|
|
|
|
return MemDepResult::getNonLocal();
|
2015-10-03 00:12:22 +02:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
MemDepResult MemoryDependenceResults::getSimplePointerDependencyFrom(
|
2015-10-03 00:12:22 +02:00
|
|
|
const MemoryLocation &MemLoc, bool isLoad, BasicBlock::iterator ScanIt,
|
limit the number of instructions per block examined by dead store elimination
Summary: Dead store elimination gets very expensive when large numbers of instructions need to be analyzed. This patch limits the number of instructions analyzed per store to the value of the memdep-block-scan-limit parameter (which defaults to 100). This resulted in no observed difference in performance of the generated code, and no change in the statistics for the dead store elimination pass, but improved compilation time on some files by more than an order of magnitude.
Reviewers: dexonsmith, bruno, george.burgess.iv, dberlin, reames, davidxl
Subscribers: davide, chandlerc, dberlin, davidxl, eraman, tejohnson, mbodart, llvm-commits
Differential Revision: https://reviews.llvm.org/D15537
llvm-svn: 279833
2016-08-26 18:34:27 +02:00
|
|
|
BasicBlock *BB, Instruction *QueryInst, unsigned *Limit) {
|
2013-03-06 18:48:48 +01:00
|
|
|
bool isInvariantLoad = false;
|
2014-08-29 22:32:58 +02:00
|
|
|
|
limit the number of instructions per block examined by dead store elimination
Summary: Dead store elimination gets very expensive when large numbers of instructions need to be analyzed. This patch limits the number of instructions analyzed per store to the value of the memdep-block-scan-limit parameter (which defaults to 100). This resulted in no observed difference in performance of the generated code, and no change in the statistics for the dead store elimination pass, but improved compilation time on some files by more than an order of magnitude.
Reviewers: dexonsmith, bruno, george.burgess.iv, dberlin, reames, davidxl
Subscribers: davide, chandlerc, dberlin, davidxl, eraman, tejohnson, mbodart, llvm-commits
Differential Revision: https://reviews.llvm.org/D15537
llvm-svn: 279833
2016-08-26 18:34:27 +02:00
|
|
|
if (!Limit) {
|
|
|
|
unsigned DefaultLimit = BlockScanLimit;
|
|
|
|
return getSimplePointerDependencyFrom(MemLoc, isLoad, ScanIt, BB, QueryInst,
|
|
|
|
&DefaultLimit);
|
|
|
|
}
|
|
|
|
|
2014-08-29 22:32:58 +02:00
|
|
|
// We must be careful with atomic accesses, as they may allow another thread
|
2016-06-28 19:19:10 +02:00
|
|
|
// to touch this location, clobbering it. We are conservative: if the
|
2014-08-29 22:32:58 +02:00
|
|
|
// QueryInst is not a simple (non-atomic) memory access, we automatically
|
|
|
|
// return getClobber.
|
|
|
|
// If it is simple, we know based on the results of
|
|
|
|
// "Compiler testing via a theory of sound optimisations in the C11/C++11
|
|
|
|
// memory model" in PLDI 2013, that a non-atomic location can only be
|
|
|
|
// clobbered between a pair of a release and an acquire action, with no
|
|
|
|
// access to the location in between.
|
|
|
|
// Here is an example for giving the general intuition behind this rule.
|
|
|
|
// In the following code:
|
|
|
|
// store x 0;
|
|
|
|
// release action; [1]
|
|
|
|
// acquire action; [4]
|
|
|
|
// %val = load x;
|
|
|
|
// It is unsafe to replace %val by 0 because another thread may be running:
|
|
|
|
// acquire action; [2]
|
|
|
|
// store x 42;
|
|
|
|
// release action; [3]
|
|
|
|
// with synchronization from 1 to 2 and from 3 to 4, resulting in %val
|
|
|
|
// being 42. A key property of this program however is that if either
|
|
|
|
// 1 or 4 were missing, there would be a race between the store of 42
|
2016-06-28 19:19:10 +02:00
|
|
|
// either the store of 0 or the load (making the whole program racy).
|
2016-01-04 17:44:44 +01:00
|
|
|
// The paper mentioned above shows that the same property is respected
|
2016-06-28 19:19:10 +02:00
|
|
|
// by every program that can detect any optimization of that kind: either
|
2014-08-29 22:32:58 +02:00
|
|
|
// it is racy (undefined) or there is a release followed by an acquire
|
|
|
|
// between the pair of accesses under consideration.
|
|
|
|
|
2015-03-25 00:54:54 +01:00
|
|
|
// If the load is invariant, we "know" that it doesn't alias *any* write. We
|
|
|
|
// do want to respect mustalias results since defs are useful for value
|
|
|
|
// forwarding, but any mayalias write can be assumed to be noalias.
|
|
|
|
// Arguably, this logic should be pushed inside AliasAnalysis itself.
|
2013-03-06 18:48:48 +01:00
|
|
|
if (isLoad && QueryInst) {
|
|
|
|
LoadInst *LI = dyn_cast<LoadInst>(QueryInst);
|
2014-04-15 06:59:12 +02:00
|
|
|
if (LI && LI->getMetadata(LLVMContext::MD_invariant_load) != nullptr)
|
2013-03-06 18:48:48 +01:00
|
|
|
isInvariantLoad = true;
|
|
|
|
}
|
2011-06-16 01:59:25 +02:00
|
|
|
|
2015-03-10 03:37:25 +01:00
|
|
|
const DataLayout &DL = BB->getModule()->getDataLayout();
|
|
|
|
|
2015-07-31 16:31:35 +02:00
|
|
|
// Create a numbered basic block to lazily compute and cache instruction
|
|
|
|
// positions inside a BB. This is used to provide fast queries for relative
|
|
|
|
// position between two instructions in a BB and can be used by
|
|
|
|
// AliasAnalysis::callCapturesBefore.
|
|
|
|
OrderedBasicBlock OBB(BB);
|
|
|
|
|
2016-02-23 00:07:43 +01:00
|
|
|
// Return "true" if and only if the instruction I is either a non-simple
|
|
|
|
// load or a non-simple store.
|
2016-03-07 11:19:30 +01:00
|
|
|
auto isNonSimpleLoadOrStore = [](Instruction *I) -> bool {
|
2016-02-23 00:07:43 +01:00
|
|
|
if (auto *LI = dyn_cast<LoadInst>(I))
|
|
|
|
return !LI->isSimple();
|
|
|
|
if (auto *SI = dyn_cast<StoreInst>(I))
|
|
|
|
return !SI->isSimple();
|
|
|
|
return false;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Return "true" if I is not a load and not a store, but it does access
|
|
|
|
// memory.
|
2016-03-07 11:19:30 +01:00
|
|
|
auto isOtherMemAccess = [](Instruction *I) -> bool {
|
2016-02-23 00:07:43 +01:00
|
|
|
return !isa<LoadInst>(I) && !isa<StoreInst>(I) && I->mayReadOrWriteMemory();
|
|
|
|
};
|
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// Walk backwards through the basic block, looking for dependencies.
|
2015-02-15 20:07:31 +01:00
|
|
|
while (ScanIt != BB->begin()) {
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
Instruction *Inst = &*--ScanIt;
|
2013-11-14 02:10:52 +01:00
|
|
|
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst))
|
|
|
|
// Debug intrinsics don't (and can't) cause dependencies.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (isa<DbgInfoIntrinsic>(II))
|
|
|
|
continue;
|
2013-11-14 02:10:52 +01:00
|
|
|
|
2011-06-16 01:59:25 +02:00
|
|
|
// Limit the amount of scanning we do so we don't end up with quadratic
|
|
|
|
// running time on extreme testcases.
|
limit the number of instructions per block examined by dead store elimination
Summary: Dead store elimination gets very expensive when large numbers of instructions need to be analyzed. This patch limits the number of instructions analyzed per store to the value of the memdep-block-scan-limit parameter (which defaults to 100). This resulted in no observed difference in performance of the generated code, and no change in the statistics for the dead store elimination pass, but improved compilation time on some files by more than an order of magnitude.
Reviewers: dexonsmith, bruno, george.burgess.iv, dberlin, reames, davidxl
Subscribers: davide, chandlerc, dberlin, davidxl, eraman, tejohnson, mbodart, llvm-commits
Differential Revision: https://reviews.llvm.org/D15537
llvm-svn: 279833
2016-08-26 18:34:27 +02:00
|
|
|
--*Limit;
|
|
|
|
if (!*Limit)
|
2011-06-16 01:59:25 +02:00
|
|
|
return MemDepResult::getUnknown();
|
|
|
|
|
2009-12-01 22:15:15 +01:00
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
|
2009-10-28 08:05:35 +01:00
|
|
|
// If we reach a lifetime begin or end marker, then the query ends here
|
|
|
|
// because the value is undefined.
|
2010-09-06 05:58:04 +02:00
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start) {
|
2009-12-02 08:35:19 +01:00
|
|
|
// FIXME: This only considers queries directly on the invariant-tagged
|
|
|
|
// pointer, not on query pointers that are indexed off of them. It'd
|
2011-04-27 00:42:01 +02:00
|
|
|
// be nice to handle that at some point (the right approach is to use
|
|
|
|
// GetPointerBaseWithConstantOffset).
|
2016-03-10 01:55:30 +01:00
|
|
|
if (AA.isMustAlias(MemoryLocation(II->getArgOperand(1)), MemLoc))
|
2009-10-28 08:05:35 +01:00
|
|
|
return MemDepResult::getDef(II);
|
2010-09-06 05:58:04 +02:00
|
|
|
continue;
|
2009-10-28 07:18:42 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-07 11:19:30 +01: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.
|
|
|
|
// One exception is atomic loads: a value can depend on an atomic load that
|
|
|
|
// it does not alias with when this atomic load indicates that another
|
|
|
|
// thread may be accessing the location.
|
2008-12-05 22:04:20 +01:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
|
2015-01-26 19:54:27 +01:00
|
|
|
|
|
|
|
// While volatile access cannot be eliminated, they do not have to clobber
|
|
|
|
// non-aliasing locations, as normal accesses, for example, can be safely
|
|
|
|
// reordered with volatile accesses.
|
|
|
|
if (LI->isVolatile()) {
|
|
|
|
if (!QueryInst)
|
|
|
|
// Original QueryInst *may* be volatile
|
|
|
|
return MemDepResult::getClobber(LI);
|
|
|
|
if (isVolatile(QueryInst))
|
|
|
|
// Ordering required if QueryInst is itself volatile
|
|
|
|
return MemDepResult::getClobber(LI);
|
|
|
|
// Otherwise, volatile doesn't imply any special ordering
|
|
|
|
}
|
2016-02-23 00:07:43 +01:00
|
|
|
|
2011-08-15 22:54:19 +02:00
|
|
|
// Atomic loads have complications involved.
|
2016-03-07 11:19:30 +01:00
|
|
|
// A Monotonic (or higher) load is OK if the query inst is itself not
|
|
|
|
// atomic.
|
2011-08-15 22:54:19 +02:00
|
|
|
// FIXME: This is overly conservative.
|
2016-04-06 23:19:33 +02:00
|
|
|
if (LI->isAtomic() && isStrongerThanUnordered(LI->getOrdering())) {
|
2016-02-23 00:07:43 +01:00
|
|
|
if (!QueryInst || isNonSimpleLoadOrStore(QueryInst) ||
|
|
|
|
isOtherMemAccess(QueryInst))
|
2014-08-19 00:18:14 +02:00
|
|
|
return MemDepResult::getClobber(LI);
|
2016-04-06 23:19:33 +02:00
|
|
|
if (LI->getOrdering() != AtomicOrdering::Monotonic)
|
2015-03-21 07:19:17 +01:00
|
|
|
return MemDepResult::getClobber(LI);
|
2014-08-19 00:18:11 +02:00
|
|
|
}
|
2011-08-15 22:54:19 +02:00
|
|
|
|
2015-06-17 09:18:54 +02:00
|
|
|
MemoryLocation LoadLoc = MemoryLocation::get(LI);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-05 22:04:20 +01:00
|
|
|
// If we found a pointer, check if it could be the same as our pointer.
|
2016-03-10 01:55:30 +01:00
|
|
|
AliasResult R = AA.alias(LoadLoc, MemLoc);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-26 03:21:15 +02:00
|
|
|
if (isLoad) {
|
Do not widen load for different variable in GVN.
Summary:
Widening load in GVN is too early because it will block other optimizations like PRE, LICM.
https://llvm.org/bugs/show_bug.cgi?id=29110
The SPECCPU2006 benchmark impact of this patch:
Reference: o2_nopatch
(1): o2_patched
Benchmark Base:Reference (1)
-------------------------------------------------------
spec/2006/fp/C++/444.namd 25.2 -0.08%
spec/2006/fp/C++/447.dealII 45.92 +1.05%
spec/2006/fp/C++/450.soplex 41.7 -0.26%
spec/2006/fp/C++/453.povray 35.65 +1.68%
spec/2006/fp/C/433.milc 23.79 +0.42%
spec/2006/fp/C/470.lbm 41.88 -1.12%
spec/2006/fp/C/482.sphinx3 47.94 +1.67%
spec/2006/int/C++/471.omnetpp 22.46 -0.36%
spec/2006/int/C++/473.astar 21.19 +0.24%
spec/2006/int/C++/483.xalancbmk 36.09 -0.11%
spec/2006/int/C/400.perlbench 33.28 +1.35%
spec/2006/int/C/401.bzip2 22.76 -0.04%
spec/2006/int/C/403.gcc 32.36 +0.12%
spec/2006/int/C/429.mcf 41.04 -0.41%
spec/2006/int/C/445.gobmk 26.94 +0.04%
spec/2006/int/C/456.hmmer 24.5 -0.20%
spec/2006/int/C/458.sjeng 28 -0.46%
spec/2006/int/C/462.libquantum 55.25 +0.27%
spec/2006/int/C/464.h264ref 45.87 +0.72%
geometric mean +0.23%
For most benchmarks, it's a wash, but we do see stable improvements on some benchmarks, e.g. 447,453,482,400.
Reviewers: davidxl, hfinkel, dberlin, sanjoy, reames
Subscribers: gberry, junbuml
Differential Revision: https://reviews.llvm.org/D24096
llvm-svn: 281074
2016-09-09 20:42:35 +02:00
|
|
|
if (R == NoAlias)
|
2011-04-27 00:42:01 +02:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-26 03:21:15 +02:00
|
|
|
// Must aliased loads are defs of each other.
|
2015-06-22 04:16:51 +02:00
|
|
|
if (R == MustAlias)
|
2011-04-26 03:21:15 +02:00
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
|
2011-06-04 08:48:50 +02:00
|
|
|
#if 0 // FIXME: Temporarily disabled. GVN is cleverly rewriting loads
|
|
|
|
// in terms of clobbering loads, but since it does this by looking
|
|
|
|
// at the clobbering load directly, it doesn't know about any
|
|
|
|
// phi translation that may have happened along the way.
|
|
|
|
|
2011-04-26 03:21:15 +02:00
|
|
|
// If we have a partial alias, then return this as a clobber for the
|
|
|
|
// client to handle.
|
2015-06-22 04:16:51 +02:00
|
|
|
if (R == PartialAlias)
|
2011-04-26 03:21:15 +02:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2011-06-04 08:48:50 +02:00
|
|
|
#endif
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-04-26 03:21:15 +02:00
|
|
|
// Random may-alias loads don't depend on each other without a
|
|
|
|
// dependence.
|
2008-11-29 10:09:48 +01:00
|
|
|
continue;
|
2011-04-26 03:21:15 +02:00
|
|
|
}
|
2010-10-29 03:14:04 +02:00
|
|
|
|
2011-04-27 00:42:01 +02:00
|
|
|
// Stores don't depend on other no-aliased accesses.
|
2015-06-22 04:16:51 +02:00
|
|
|
if (R == NoAlias)
|
2011-04-27 00:42:01 +02:00
|
|
|
continue;
|
|
|
|
|
2010-10-29 03:14:04 +02:00
|
|
|
// Stores don't alias loads from read-only memory.
|
2016-03-10 01:55:30 +01:00
|
|
|
if (AA.pointsToConstantMemory(LoadLoc))
|
2010-10-29 03:14:04 +02:00
|
|
|
continue;
|
|
|
|
|
2011-04-26 03:21:15 +02:00
|
|
|
// Stores depend on may/must aliased loads.
|
2008-12-05 22:04:20 +01:00
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-05 22:04:20 +01:00
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
|
2011-08-15 22:54:19 +02:00
|
|
|
// Atomic stores have complications involved.
|
2014-08-29 22:32:58 +02:00
|
|
|
// A Monotonic store is OK if the query inst is itself not atomic.
|
2011-08-15 22:54:19 +02:00
|
|
|
// FIXME: This is overly conservative.
|
2016-02-23 00:07:43 +01:00
|
|
|
if (!SI->isUnordered() && SI->isAtomic()) {
|
|
|
|
if (!QueryInst || isNonSimpleLoadOrStore(QueryInst) ||
|
|
|
|
isOtherMemAccess(QueryInst))
|
2014-08-19 00:18:14 +02:00
|
|
|
return MemDepResult::getClobber(SI);
|
2016-04-06 23:19:33 +02:00
|
|
|
if (SI->getOrdering() != AtomicOrdering::Monotonic)
|
2015-03-21 07:19:17 +01:00
|
|
|
return MemDepResult::getClobber(SI);
|
2014-08-19 00:18:11 +02:00
|
|
|
}
|
2011-08-15 22:54:19 +02:00
|
|
|
|
2014-08-19 00:18:14 +02:00
|
|
|
// FIXME: this is overly conservative.
|
|
|
|
// While volatile access cannot be eliminated, they do not have to clobber
|
|
|
|
// non-aliasing locations, as normal accesses can for example be reordered
|
|
|
|
// with volatile accesses.
|
|
|
|
if (SI->isVolatile())
|
2016-02-23 00:07:43 +01:00
|
|
|
if (!QueryInst || isNonSimpleLoadOrStore(QueryInst) ||
|
|
|
|
isOtherMemAccess(QueryInst))
|
|
|
|
return MemDepResult::getClobber(SI);
|
2014-08-19 00:18:14 +02:00
|
|
|
|
2009-05-25 23:28:56 +02: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.
|
2016-03-10 01:55:30 +01:00
|
|
|
if (AA.getModRefInfo(SI, MemLoc) == MRI_NoModRef)
|
2009-05-25 23:28:56 +02:00
|
|
|
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.
|
2015-06-17 09:18:54 +02:00
|
|
|
MemoryLocation StoreLoc = MemoryLocation::get(SI);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-05 22:04:20 +01:00
|
|
|
// If we found a pointer, check if it could be the same as our pointer.
|
2016-03-10 01:55:30 +01:00
|
|
|
AliasResult R = AA.alias(StoreLoc, MemLoc);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2015-06-22 04:16:51 +02:00
|
|
|
if (R == NoAlias)
|
2008-12-05 22:04:20 +01:00
|
|
|
continue;
|
2015-06-22 04:16:51 +02:00
|
|
|
if (R == MustAlias)
|
2010-12-13 23:47:57 +01:00
|
|
|
return MemDepResult::getDef(Inst);
|
2013-03-06 18:48:48 +01:00
|
|
|
if (isInvariantLoad)
|
2016-03-07 11:19:30 +01:00
|
|
|
continue;
|
2010-12-13 23:47:57 +01:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2008-11-29 10:09:48 +01:00
|
|
|
}
|
2008-11-30 02:39:32 +01:00
|
|
|
|
|
|
|
// If this is an allocation, and if we know that the accessed pointer is to
|
2008-12-05 22:04:20 +01:00
|
|
|
// the allocation, return Def. This means that there is no dependence and
|
2008-11-30 02:39:32 +01:00
|
|
|
// the access can be optimized based on that. For example, a load could
|
2016-03-10 00:19:56 +01:00
|
|
|
// turn into undef. Note that we can bypass the allocation itself when
|
|
|
|
// looking for a clobber in many cases; that's an alias property and is
|
|
|
|
// handled by BasicAA.
|
2016-03-10 01:55:30 +01:00
|
|
|
if (isa<AllocaInst>(Inst) || isNoAliasFn(Inst, &TLI)) {
|
2014-02-18 16:33:12 +01:00
|
|
|
const Value *AccessPtr = GetUnderlyingObject(MemLoc.Ptr, DL);
|
2016-03-10 01:55:30 +01:00
|
|
|
if (AccessPtr == Inst || AA.isMustAlias(Inst, AccessPtr))
|
2009-09-18 23:34:51 +02:00
|
|
|
return MemDepResult::getDef(Inst);
|
|
|
|
}
|
|
|
|
|
2015-03-25 00:54:54 +01:00
|
|
|
if (isInvariantLoad)
|
2016-03-07 11:19:30 +01:00
|
|
|
continue;
|
2015-03-25 00:54:54 +01:00
|
|
|
|
2016-03-25 23:40:35 +01:00
|
|
|
// A release fence requires that all stores complete before it, but does
|
|
|
|
// not prevent the reordering of following loads or stores 'before' the
|
|
|
|
// fence. As a result, we look past it when finding a dependency for
|
|
|
|
// loads. DSE uses this to find preceeding stores to delete and thus we
|
|
|
|
// can't bypass the fence if the query instruction is a store.
|
|
|
|
if (FenceInst *FI = dyn_cast<FenceInst>(Inst))
|
2016-04-06 23:19:33 +02:00
|
|
|
if (isLoad && FI->getOrdering() == AtomicOrdering::Release)
|
2016-03-25 23:40:35 +01:00
|
|
|
continue;
|
2016-04-06 23:19:33 +02:00
|
|
|
|
2008-12-05 22:04:20 +01:00
|
|
|
// See if this instruction (e.g. a call or vaarg) mod/ref's the pointer.
|
2016-03-10 01:55:30 +01:00
|
|
|
ModRefInfo MR = AA.getModRefInfo(Inst, MemLoc);
|
2012-05-14 22:35:04 +02:00
|
|
|
// If necessary, perform additional analysis.
|
2015-07-23 01:15:57 +02:00
|
|
|
if (MR == MRI_ModRef)
|
2016-03-11 14:46:00 +01:00
|
|
|
MR = AA.callCapturesBefore(Inst, MemLoc, &DT, &OBB);
|
2012-05-14 22:35:04 +02:00
|
|
|
switch (MR) {
|
2015-07-23 01:15:57 +02:00
|
|
|
case MRI_NoModRef:
|
2008-12-09 20:47:40 +01:00
|
|
|
// If the call has no effect on the queried pointer, just ignore it.
|
2008-11-29 09:51:16 +01:00
|
|
|
continue;
|
2015-07-23 01:15:57 +02:00
|
|
|
case MRI_Mod:
|
2009-10-28 07:30:52 +01:00
|
|
|
return MemDepResult::getClobber(Inst);
|
2015-07-23 01:15:57 +02:00
|
|
|
case MRI_Ref:
|
2008-12-09 20:47:40 +01:00
|
|
|
// 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-07 01:14:35 +02:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-06-15 02:47:34 +02:00
|
|
|
// No dependence found. If this is the entry block of the function, it is
|
|
|
|
// unknown, otherwise it is non-local.
|
2008-12-07 03:15:47 +01:00
|
|
|
if (BB != &BB->getParent()->getEntryBlock())
|
|
|
|
return MemDepResult::getNonLocal();
|
2011-10-14 00:14:57 +02:00
|
|
|
return MemDepResult::getNonFuncLocal();
|
2007-07-07 01:14:35 +02:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
MemDepResult MemoryDependenceResults::getDependency(Instruction *QueryInst) {
|
2008-11-29 04:47:00 +01:00
|
|
|
Instruction *ScanPos = QueryInst;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 04:47:00 +01:00
|
|
|
// Check for a cached result
|
2008-12-01 00:17:19 +01:00
|
|
|
MemDepResult &LocalCache = LocalDeps[QueryInst];
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 23:02:15 +01:00
|
|
|
// If the cached entry is non-dirty, just return it. Note that this depends
|
2008-12-01 00:17:19 +01:00
|
|
|
// on MemDepResult's default constructing to 'dirty'.
|
|
|
|
if (!LocalCache.isDirty())
|
|
|
|
return LocalCache;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 04:47:00 +01: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-12-01 00:17:19 +01:00
|
|
|
if (Instruction *Inst = LocalCache.getInst()) {
|
2008-11-29 04:47:00 +01:00
|
|
|
ScanPos = Inst;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 19:39:13 +01:00
|
|
|
RemoveFromReverseMap(ReverseLocalDeps, Inst, QueryInst);
|
2008-11-30 03:52:26 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 02:50:16 +01:00
|
|
|
BasicBlock *QueryParent = QueryInst->getParent();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 04:47:00 +01:00
|
|
|
// Do the scan.
|
2008-12-07 02:50:16 +01:00
|
|
|
if (BasicBlock::iterator(QueryInst) == QueryParent->begin()) {
|
2016-11-08 19:20:51 +01:00
|
|
|
// No dependence found. If this is the entry block of the function, it is
|
2011-06-15 02:47:34 +02:00
|
|
|
// unknown, otherwise it is non-local.
|
2008-12-07 03:15:47 +01:00
|
|
|
if (QueryParent != &QueryParent->getParent()->getEntryBlock())
|
|
|
|
LocalCache = MemDepResult::getNonLocal();
|
|
|
|
else
|
2011-10-14 00:14:57 +02:00
|
|
|
LocalCache = MemDepResult::getNonFuncLocal();
|
2010-11-10 22:51:35 +01:00
|
|
|
} else {
|
2015-06-17 09:18:54 +02:00
|
|
|
MemoryLocation MemLoc;
|
2016-03-10 01:55:30 +01:00
|
|
|
ModRefInfo MR = GetLocation(QueryInst, MemLoc, TLI);
|
2010-11-10 22:51:35 +01:00
|
|
|
if (MemLoc.Ptr) {
|
|
|
|
// If we can do a pointer scan, make it happen.
|
2015-07-23 01:15:57 +02:00
|
|
|
bool isLoad = !(MR & MRI_Mod);
|
2016-11-08 19:20:51 +01:00
|
|
|
if (auto *II = dyn_cast<IntrinsicInst>(QueryInst))
|
2011-05-17 02:05:49 +02:00
|
|
|
isLoad |= II->getIntrinsicID() == Intrinsic::lifetime_start;
|
2010-11-21 08:34:32 +01:00
|
|
|
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
LocalCache = getPointerDependencyFrom(
|
|
|
|
MemLoc, isLoad, ScanPos->getIterator(), QueryParent, QueryInst);
|
2010-11-10 22:51:35 +01:00
|
|
|
} else if (isa<CallInst>(QueryInst) || isa<InvokeInst>(QueryInst)) {
|
2010-07-28 00:02:00 +02:00
|
|
|
CallSite QueryCS(QueryInst);
|
2016-03-10 01:55:30 +01:00
|
|
|
bool isReadOnly = AA.onlyReadsMemory(QueryCS);
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
LocalCache = getCallSiteDependencyFrom(
|
|
|
|
QueryCS, isReadOnly, ScanPos->getIterator(), QueryParent);
|
2010-11-10 22:51:35 +01:00
|
|
|
} else
|
|
|
|
// Non-memory instruction.
|
2011-06-15 02:47:34 +02:00
|
|
|
LocalCache = MemDepResult::getUnknown();
|
2009-11-28 22:27:49 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 04:47:00 +01:00
|
|
|
// Remember the result!
|
2008-12-01 00:17:19 +01:00
|
|
|
if (Instruction *I = LocalCache.getInst())
|
2008-11-29 10:20:15 +01:00
|
|
|
ReverseLocalDeps[I].insert(QueryInst);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 00:17:19 +01:00
|
|
|
return LocalCache;
|
2008-11-29 04:47:00 +01:00
|
|
|
}
|
|
|
|
|
2009-01-22 08:04:01 +01:00
|
|
|
#ifndef NDEBUG
|
2016-03-07 13:30:06 +01:00
|
|
|
/// This method is used when -debug is specified to verify that cache arrays
|
|
|
|
/// are properly kept sorted.
|
2016-03-10 01:55:30 +01:00
|
|
|
static void AssertSorted(MemoryDependenceResults::NonLocalDepInfo &Cache,
|
2009-01-22 08:04:01 +01:00
|
|
|
int Count = -1) {
|
2016-03-07 11:19:30 +01:00
|
|
|
if (Count == -1)
|
|
|
|
Count = Cache.size();
|
2016-01-03 20:43:40 +01:00
|
|
|
assert(std::is_sorted(Cache.begin(), Cache.begin() + Count) &&
|
|
|
|
"Cache isn't sorted!");
|
2009-01-22 08:04:01 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
const MemoryDependenceResults::NonLocalDepInfo &
|
|
|
|
MemoryDependenceResults::getNonLocalCallDependency(CallSite QueryCS) {
|
2008-12-09 20:38:05 +01:00
|
|
|
assert(getDependency(QueryCS.getInstruction()).isNonLocal() &&
|
2016-03-07 11:19:30 +01:00
|
|
|
"getNonLocalCallDependency should only be used on calls with "
|
|
|
|
"non-local deps!");
|
2008-12-09 20:38:05 +01:00
|
|
|
PerInstNLInfo &CacheP = NonLocalDeps[QueryCS.getInstruction()];
|
2008-12-01 02:15:42 +01:00
|
|
|
NonLocalDepInfo &Cache = CacheP.first;
|
2008-11-30 02:18:27 +01:00
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
// 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.
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallVector<BasicBlock *, 32> DirtyBlocks;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:18:27 +01:00
|
|
|
if (!Cache.empty()) {
|
2008-12-01 02:15:42 +01:00
|
|
|
// Okay, we have a cache entry. If we know it is not dirty, just return it
|
|
|
|
// with no computation.
|
|
|
|
if (!CacheP.second) {
|
2010-06-22 17:08:57 +02:00
|
|
|
++NumCacheNonLocal;
|
2008-12-01 02:15:42 +01:00
|
|
|
return Cache;
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:18:27 +01:00
|
|
|
// If we already have a partially computed set of results, scan them to
|
2008-12-01 02:15:42 +01:00
|
|
|
// determine what is dirty, seeding our initial DirtyBlocks worklist.
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : Cache)
|
|
|
|
if (Entry.getResult().isDirty())
|
|
|
|
DirtyBlocks.push_back(Entry.getBB());
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
// Sort the cache so that we can do fast binary search lookups below.
|
|
|
|
std::sort(Cache.begin(), Cache.end());
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
++NumCacheDirtyNonLocal;
|
2016-03-07 11:19:30 +01:00
|
|
|
// cerr << "CACHED CASE: " << DirtyBlocks.size() << " dirty: "
|
2008-11-30 02:18:27 +01:00
|
|
|
// << Cache.size() << " cached: " << *QueryInst;
|
|
|
|
} else {
|
|
|
|
// Seed DirtyBlocks with each of the preds of QueryInst's block.
|
2008-12-09 20:38:05 +01:00
|
|
|
BasicBlock *QueryBB = QueryCS.getInstruction()->getParent();
|
2015-04-21 23:11:50 +02:00
|
|
|
for (BasicBlock *Pred : PredCache.get(QueryBB))
|
|
|
|
DirtyBlocks.push_back(Pred);
|
2010-06-22 17:08:57 +02:00
|
|
|
++NumUncacheNonLocal;
|
2008-11-30 02:18:27 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 22:19:42 +01:00
|
|
|
// isReadonlyCall - If this is a read-only call, we can be more aggressive.
|
2016-03-10 01:55:30 +01:00
|
|
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallPtrSet<BasicBlock *, 32> Visited;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
unsigned NumSortedEntries = Cache.size();
|
2009-01-22 08:04:01 +01:00
|
|
|
DEBUG(AssertSorted(Cache));
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:18:27 +01:00
|
|
|
// Iterate while we still have blocks to update.
|
|
|
|
while (!DirtyBlocks.empty()) {
|
|
|
|
BasicBlock *DirtyBB = DirtyBlocks.back();
|
|
|
|
DirtyBlocks.pop_back();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
// Already processed this block?
|
2014-11-19 08:49:26 +01:00
|
|
|
if (!Visited.insert(DirtyBB).second)
|
2008-12-01 02:15:42 +01:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
// 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 08:04:01 +01:00
|
|
|
DEBUG(AssertSorted(Cache, NumSortedEntries));
|
2013-03-20 22:47:51 +01:00
|
|
|
NonLocalDepInfo::iterator Entry =
|
2016-03-07 11:19:30 +01:00
|
|
|
std::upper_bound(Cache.begin(), Cache.begin() + NumSortedEntries,
|
|
|
|
NonLocalDepEntry(DirtyBB));
|
2014-03-02 13:27:27 +01:00
|
|
|
if (Entry != Cache.begin() && std::prev(Entry)->getBB() == DirtyBB)
|
2008-12-01 02:15:42 +01:00
|
|
|
--Entry;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-04-15 06:59:12 +02:00
|
|
|
NonLocalDepEntry *ExistingResult = nullptr;
|
2016-03-07 11:19:30 +01:00
|
|
|
if (Entry != Cache.begin() + NumSortedEntries &&
|
2009-12-09 08:08:01 +01:00
|
|
|
Entry->getBB() == DirtyBB) {
|
2008-12-01 02:15:42 +01:00
|
|
|
// If we already have an entry, and if it isn't already dirty, the block
|
|
|
|
// is done.
|
2009-12-09 08:08:01 +01:00
|
|
|
if (!Entry->getResult().isDirty())
|
2008-12-01 02:15:42 +01:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
// Otherwise, remember this slot so we can update the value.
|
2009-12-09 08:08:01 +01:00
|
|
|
ExistingResult = &*Entry;
|
2008-12-01 02:15:42 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:18:27 +01: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 02:15:42 +01:00
|
|
|
if (ExistingResult) {
|
2009-12-09 08:08:01 +01:00
|
|
|
if (Instruction *Inst = ExistingResult->getResult().getInst()) {
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
ScanPos = Inst->getIterator();
|
2008-12-01 02:15:42 +01:00
|
|
|
// We're removing QueryInst's use of Inst.
|
2008-12-09 20:38:05 +01:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalDeps, Inst,
|
|
|
|
QueryCS.getInstruction());
|
2008-12-01 02:15:42 +01:00
|
|
|
}
|
2008-11-30 03:28:25 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:26:32 +01:00
|
|
|
// Find out if this block has a local dependency for QueryInst.
|
2008-12-07 02:21:14 +01:00
|
|
|
MemDepResult Dep;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 20:38:05 +01:00
|
|
|
if (ScanPos != DirtyBB->begin()) {
|
2016-03-07 11:19:30 +01:00
|
|
|
Dep =
|
|
|
|
getCallSiteDependencyFrom(QueryCS, isReadonlyCall, ScanPos, DirtyBB);
|
2008-12-09 20:38:05 +01:00
|
|
|
} else if (DirtyBB != &DirtyBB->getParent()->getEntryBlock()) {
|
|
|
|
// No dependence found. If this is the entry block of the function, it is
|
2011-06-15 02:47:34 +02:00
|
|
|
// a clobber, otherwise it is unknown.
|
2008-12-09 20:38:05 +01:00
|
|
|
Dep = MemDepResult::getNonLocal();
|
2008-12-07 02:50:16 +01:00
|
|
|
} else {
|
2011-10-14 00:14:57 +02:00
|
|
|
Dep = MemDepResult::getNonFuncLocal();
|
2008-12-07 02:50:16 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
// If we had a dirty entry for the block, update it. Otherwise, just add
|
|
|
|
// a new entry.
|
|
|
|
if (ExistingResult)
|
2009-12-22 05:25:02 +01:00
|
|
|
ExistingResult->setResult(Dep);
|
2008-12-01 02:15:42 +01:00
|
|
|
else
|
2009-12-22 05:25:02 +01:00
|
|
|
Cache.push_back(NonLocalDepEntry(DirtyBB, Dep));
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:18:27 +01:00
|
|
|
// If the block has a dependency (i.e. it isn't completely transparent to
|
2008-12-01 02:15:42 +01:00
|
|
|
// the value), remember the association!
|
|
|
|
if (!Dep.isNonLocal()) {
|
2008-11-30 02:18:27 +01:00
|
|
|
// Keep the ReverseNonLocalDeps map up to date so we can efficiently
|
|
|
|
// update this when we remove instructions.
|
2008-12-01 02:15:42 +01:00
|
|
|
if (Instruction *Inst = Dep.getInst())
|
2008-12-09 20:38:05 +01:00
|
|
|
ReverseNonLocalDeps[Inst].insert(QueryCS.getInstruction());
|
2008-12-01 02:15:42 +01:00
|
|
|
} else {
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
// If the block *is* completely transparent to the load, we need to check
|
|
|
|
// the predecessors of this block. Add them to our worklist.
|
2015-04-21 23:11:50 +02:00
|
|
|
for (BasicBlock *Pred : PredCache.get(DirtyBB))
|
|
|
|
DirtyBlocks.push_back(Pred);
|
2008-12-01 02:15:42 +01:00
|
|
|
}
|
2008-11-30 02:18:27 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-01 02:15:42 +01:00
|
|
|
return Cache;
|
2008-11-30 02:18:27 +01:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
void MemoryDependenceResults::getNonLocalPointerDependency(
|
2016-03-07 11:19:30 +01:00
|
|
|
Instruction *QueryInst, SmallVectorImpl<NonLocalDepResult> &Result) {
|
2015-06-17 09:18:54 +02:00
|
|
|
const MemoryLocation Loc = MemoryLocation::get(QueryInst);
|
2015-01-09 01:04:22 +01:00
|
|
|
bool isLoad = isa<LoadInst>(QueryInst);
|
|
|
|
BasicBlock *FromBB = QueryInst->getParent();
|
|
|
|
assert(FromBB);
|
2015-01-09 01:26:45 +01:00
|
|
|
|
|
|
|
assert(Loc.Ptr->getType()->isPointerTy() &&
|
|
|
|
"Can't get pointer deps of a non-pointer!");
|
|
|
|
Result.clear();
|
2017-01-12 12:33:58 +01:00
|
|
|
{
|
|
|
|
// Check if there is cached Def with invariant.group. FIXME: cache might be
|
|
|
|
// invalid if cached instruction would be removed between call to
|
|
|
|
// getPointerDependencyFrom and this function.
|
|
|
|
auto NonLocalDefIt = NonLocalDefsCache.find(QueryInst);
|
|
|
|
if (NonLocalDefIt != NonLocalDefsCache.end()) {
|
|
|
|
Result.push_back(std::move(NonLocalDefIt->second));
|
|
|
|
NonLocalDefsCache.erase(NonLocalDefIt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-01-09 01:26:45 +01:00
|
|
|
// This routine does not expect to deal with volatile instructions.
|
|
|
|
// Doing so would require piping through the QueryInst all the way through.
|
2015-01-09 01:04:22 +01:00
|
|
|
// TODO: volatiles can't be elided, but they can be reordered with other
|
2015-01-09 01:26:45 +01:00
|
|
|
// non-volatile accesses.
|
2015-01-26 19:54:27 +01:00
|
|
|
|
2015-01-09 01:04:22 +01:00
|
|
|
// We currently give up on any instruction which is ordered, but we do handle
|
|
|
|
// atomic instructions which are unordered.
|
|
|
|
// TODO: Handle ordered instructions
|
|
|
|
auto isOrdered = [](Instruction *Inst) {
|
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
|
|
|
|
return !LI->isUnordered();
|
|
|
|
} else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
|
|
|
|
return !SI->isUnordered();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
};
|
2015-01-09 01:26:45 +01:00
|
|
|
if (isVolatile(QueryInst) || isOrdered(QueryInst)) {
|
2016-03-07 11:19:30 +01:00
|
|
|
Result.push_back(NonLocalDepResult(FromBB, MemDepResult::getUnknown(),
|
2015-01-09 01:26:45 +01:00
|
|
|
const_cast<Value *>(Loc.Ptr)));
|
|
|
|
return;
|
|
|
|
}
|
2015-03-10 03:37:25 +01:00
|
|
|
const DataLayout &DL = FromBB->getModule()->getDataLayout();
|
2016-12-19 09:22:17 +01:00
|
|
|
PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, &AC);
|
2013-03-20 22:47:51 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01: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.
|
2016-03-07 11:19:30 +01:00
|
|
|
DenseMap<BasicBlock *, Value *> Visited;
|
2016-03-07 13:45:07 +01:00
|
|
|
if (getNonLocalPointerDepFromBB(QueryInst, Address, Loc, 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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
Result, Visited, true))
|
|
|
|
return;
|
2008-12-15 05:58:29 +01:00
|
|
|
Result.clear();
|
2016-03-07 11:19:30 +01:00
|
|
|
Result.push_back(NonLocalDepResult(FromBB, MemDepResult::getUnknown(),
|
2010-09-22 23:41:02 +02:00
|
|
|
const_cast<Value *>(Loc.Ptr)));
|
2008-12-07 03:56:57 +01:00
|
|
|
}
|
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// 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.
|
2016-03-10 01:55:30 +01:00
|
|
|
MemDepResult MemoryDependenceResults::GetNonLocalInfoForBlock(
|
2015-06-17 09:18:54 +02:00
|
|
|
Instruction *QueryInst, const MemoryLocation &Loc, bool isLoad,
|
|
|
|
BasicBlock *BB, NonLocalDepInfo *Cache, unsigned NumSortedEntries) {
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// Do a binary search to see if we already have an entry for this block in
|
|
|
|
// the cache set. If so, find it.
|
2016-03-07 11:19:30 +01:00
|
|
|
NonLocalDepInfo::iterator Entry = std::upper_bound(
|
|
|
|
Cache->begin(), Cache->begin() + NumSortedEntries, NonLocalDepEntry(BB));
|
|
|
|
if (Entry != Cache->begin() && (Entry - 1)->getBB() == BB)
|
2008-12-09 08:47:11 +01:00
|
|
|
--Entry;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-04-15 06:59:12 +02:00
|
|
|
NonLocalDepEntry *ExistingResult = nullptr;
|
2016-03-07 11:19:30 +01:00
|
|
|
if (Entry != Cache->begin() + NumSortedEntries && Entry->getBB() == BB)
|
2009-12-09 08:08:01 +01:00
|
|
|
ExistingResult = &*Entry;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// If we have a cached entry, and it is non-dirty, use it as the value for
|
|
|
|
// this dependency.
|
2009-12-09 08:08:01 +01:00
|
|
|
if (ExistingResult && !ExistingResult->getResult().isDirty()) {
|
2008-12-09 08:47:11 +01:00
|
|
|
++NumCacheNonLocalPtr;
|
2009-12-09 08:08:01 +01:00
|
|
|
return ExistingResult->getResult();
|
2013-03-20 22:47:51 +01:00
|
|
|
}
|
|
|
|
|
2008-12-09 08:47:11 +01: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 08:08:01 +01:00
|
|
|
if (ExistingResult && ExistingResult->getResult().getInst()) {
|
|
|
|
assert(ExistingResult->getResult().getInst()->getParent() == BB &&
|
2008-12-09 08:47:11 +01:00
|
|
|
"Instruction invalidated?");
|
|
|
|
++NumCacheDirtyNonLocalPtr;
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
ScanPos = ExistingResult->getResult().getInst()->getIterator();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// Eliminating the dirty entry from 'Cache', so update the reverse info.
|
2010-09-22 23:41:02 +02:00
|
|
|
ValueIsLoadPair CacheKey(Loc.Ptr, isLoad);
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalPtrDeps, &*ScanPos, CacheKey);
|
2008-12-09 08:47:11 +01:00
|
|
|
} else {
|
|
|
|
++NumUncacheNonLocalPtr;
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// Scan the block for the dependency.
|
2016-03-07 11:19:30 +01:00
|
|
|
MemDepResult Dep =
|
|
|
|
getPointerDependencyFrom(Loc, isLoad, ScanPos, BB, QueryInst);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// If we had a dirty entry for the block, update it. Otherwise, just add
|
|
|
|
// a new entry.
|
|
|
|
if (ExistingResult)
|
2009-12-22 05:25:02 +01:00
|
|
|
ExistingResult->setResult(Dep);
|
2008-12-09 08:47:11 +01:00
|
|
|
else
|
2009-12-22 05:25:02 +01:00
|
|
|
Cache->push_back(NonLocalDepEntry(BB, Dep));
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01: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!
|
2011-10-14 00:14:57 +02:00
|
|
|
if (!Dep.isDef() && !Dep.isClobber())
|
2008-12-09 08:47:11 +01:00
|
|
|
return Dep;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// 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?");
|
2010-09-22 23:41:02 +02:00
|
|
|
ValueIsLoadPair CacheKey(Loc.Ptr, isLoad);
|
2009-03-29 01:24:04 +01:00
|
|
|
ReverseNonLocalPtrDeps[Inst].insert(CacheKey);
|
2008-12-09 08:47:11 +01:00
|
|
|
return Dep;
|
|
|
|
}
|
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// Sort the 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.
|
2013-03-20 22:47:51 +01:00
|
|
|
static void
|
2016-03-10 01:55:30 +01:00
|
|
|
SortNonLocalDepInfoCache(MemoryDependenceResults::NonLocalDepInfo &Cache,
|
2009-07-13 19:20:05 +02:00
|
|
|
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 08:08:01 +01:00
|
|
|
NonLocalDepEntry Val = Cache.back();
|
2009-07-13 19:20:05 +02:00
|
|
|
Cache.pop_back();
|
2016-03-10 01:55:30 +01:00
|
|
|
MemoryDependenceResults::NonLocalDepInfo::iterator Entry =
|
2016-03-07 11:19:30 +01:00
|
|
|
std::upper_bound(Cache.begin(), Cache.end() - 1, Val);
|
2009-07-13 19:20:05 +02:00
|
|
|
Cache.insert(Entry, Val);
|
2016-08-17 22:30:52 +02:00
|
|
|
LLVM_FALLTHROUGH;
|
2009-07-13 19:20:05 +02:00
|
|
|
}
|
|
|
|
case 1:
|
|
|
|
// One new entry, Just insert the new value at the appropriate position.
|
|
|
|
if (Cache.size() != 1) {
|
2009-12-09 08:08:01 +01:00
|
|
|
NonLocalDepEntry Val = Cache.back();
|
2009-07-13 19:20:05 +02:00
|
|
|
Cache.pop_back();
|
2016-03-10 01:55:30 +01:00
|
|
|
MemoryDependenceResults::NonLocalDepInfo::iterator Entry =
|
2016-03-07 11:19:30 +01:00
|
|
|
std::upper_bound(Cache.begin(), Cache.end(), Val);
|
2009-07-13 19:20:05 +02:00
|
|
|
Cache.insert(Entry, Val);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Added many values, do a full scale sort.
|
|
|
|
std::sort(Cache.begin(), Cache.end());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// 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'.
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
///
|
|
|
|
/// 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.
|
|
|
|
///
|
2016-03-07 13:45:07 +01:00
|
|
|
/// This function returns true on success, or false to indicate that it could
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
/// not compute dependence information for some reason. This should be treated
|
|
|
|
/// as a clobber dependence on the first instruction in the predecessor block.
|
2016-03-10 01:55:30 +01:00
|
|
|
bool MemoryDependenceResults::getNonLocalPointerDepFromBB(
|
2015-06-17 09:18:54 +02:00
|
|
|
Instruction *QueryInst, const PHITransAddr &Pointer,
|
|
|
|
const MemoryLocation &Loc, bool isLoad, BasicBlock *StartBB,
|
|
|
|
SmallVectorImpl<NonLocalDepResult> &Result,
|
|
|
|
DenseMap<BasicBlock *, Value *> &Visited, bool SkipFirstBlock) {
|
2008-12-07 09:50:20 +01:00
|
|
|
// Look up the cached info for Pointer.
|
2009-12-09 02:59:31 +01:00
|
|
|
ValueIsLoadPair CacheKey(Pointer.getAddr(), isLoad);
|
2010-09-22 23:41:02 +02:00
|
|
|
|
2010-11-10 21:37:15 +01:00
|
|
|
// Set up a temporary NLPI value. If the map doesn't yet have an entry for
|
|
|
|
// CacheKey, this value will be inserted as the associated value. Otherwise,
|
|
|
|
// it'll be ignored, and we'll have to check to see if the cached size and
|
2014-07-24 14:16:19 +02:00
|
|
|
// aa tags are consistent with the current query.
|
2010-11-10 21:37:15 +01:00
|
|
|
NonLocalPointerInfo InitialNLPI;
|
|
|
|
InitialNLPI.Size = Loc.Size;
|
2014-07-24 14:16:19 +02:00
|
|
|
InitialNLPI.AATags = Loc.AATags;
|
2010-11-10 21:37:15 +01:00
|
|
|
|
|
|
|
// Get the NLPI for CacheKey, inserting one into the map if it doesn't
|
|
|
|
// already have one.
|
2013-03-20 22:47:51 +01:00
|
|
|
std::pair<CachedNonLocalPointerInfo::iterator, bool> Pair =
|
2016-03-07 11:19:30 +01:00
|
|
|
NonLocalPointerDeps.insert(std::make_pair(CacheKey, InitialNLPI));
|
2010-11-10 21:37:15 +01:00
|
|
|
NonLocalPointerInfo *CacheInfo = &Pair.first->second;
|
|
|
|
|
2010-11-10 22:45:11 +01:00
|
|
|
// If we already have a cache entry for this CacheKey, we may need to do some
|
|
|
|
// work to reconcile the cache entry and the current query.
|
2010-11-10 21:37:15 +01:00
|
|
|
if (!Pair.second) {
|
2010-11-10 22:45:11 +01:00
|
|
|
if (CacheInfo->Size < Loc.Size) {
|
|
|
|
// The query's Size is greater than the cached one. Throw out the
|
2012-06-02 12:20:22 +02:00
|
|
|
// cached data and proceed with the query at the greater size.
|
2010-11-10 22:45:11 +01:00
|
|
|
CacheInfo->Pair = BBSkipFirstBlockPair();
|
|
|
|
CacheInfo->Size = Loc.Size;
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : CacheInfo->NonLocalDeps)
|
|
|
|
if (Instruction *Inst = Entry.getResult().getInst())
|
2010-11-10 23:35:02 +01:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalPtrDeps, Inst, CacheKey);
|
2010-11-10 22:45:11 +01:00
|
|
|
CacheInfo->NonLocalDeps.clear();
|
|
|
|
} else if (CacheInfo->Size > Loc.Size) {
|
|
|
|
// This query's Size is less than the cached one. Conservatively restart
|
|
|
|
// the query using the greater size.
|
2016-03-07 11:19:30 +01:00
|
|
|
return getNonLocalPointerDepFromBB(
|
|
|
|
QueryInst, Pointer, Loc.getWithNewSize(CacheInfo->Size), isLoad,
|
|
|
|
StartBB, Result, Visited, SkipFirstBlock);
|
2010-11-10 21:37:15 +01:00
|
|
|
}
|
|
|
|
|
2014-07-24 14:16:19 +02:00
|
|
|
// If the query's AATags are inconsistent with the cached one,
|
2010-11-10 22:45:11 +01:00
|
|
|
// conservatively throw out the cached data and restart the query with
|
|
|
|
// no tag if needed.
|
2014-07-24 14:16:19 +02:00
|
|
|
if (CacheInfo->AATags != Loc.AATags) {
|
|
|
|
if (CacheInfo->AATags) {
|
2010-11-10 22:45:11 +01:00
|
|
|
CacheInfo->Pair = BBSkipFirstBlockPair();
|
2014-07-24 14:16:19 +02:00
|
|
|
CacheInfo->AATags = AAMDNodes();
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : CacheInfo->NonLocalDeps)
|
|
|
|
if (Instruction *Inst = Entry.getResult().getInst())
|
2010-11-10 23:35:02 +01:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalPtrDeps, Inst, CacheKey);
|
2010-11-10 22:45:11 +01:00
|
|
|
CacheInfo->NonLocalDeps.clear();
|
|
|
|
}
|
2014-07-24 14:16:19 +02:00
|
|
|
if (Loc.AATags)
|
2016-03-07 11:19:30 +01:00
|
|
|
return getNonLocalPointerDepFromBB(
|
|
|
|
QueryInst, Pointer, Loc.getWithoutAATags(), isLoad, StartBB, Result,
|
|
|
|
Visited, SkipFirstBlock);
|
2010-11-10 21:37:15 +01:00
|
|
|
}
|
2010-09-22 23:41:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
NonLocalDepInfo *Cache = &CacheInfo->NonLocalDeps;
|
2008-12-08 08:31:50 +01:00
|
|
|
|
|
|
|
// If we have valid cached information for exactly the block we are
|
|
|
|
// investigating, just return it with no recomputation.
|
2010-09-22 23:41:02 +02:00
|
|
|
if (CacheInfo->Pair == BBSkipFirstBlockPair(StartBB, SkipFirstBlock)) {
|
2008-12-16 08:10:09 +01: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()) {
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : *Cache) {
|
|
|
|
DenseMap<BasicBlock *, Value *>::iterator VI =
|
|
|
|
Visited.find(Entry.getBB());
|
2009-12-09 02:59:31 +01:00
|
|
|
if (VI == Visited.end() || VI->second == Pointer.getAddr())
|
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 13:45:07 +01:00
|
|
|
// We have a pointer mismatch in a block. Just return false, saying
|
2008-12-16 08:10:09 +01:00
|
|
|
// that something was clobbered in this result. We could also do a
|
|
|
|
// non-fully cached query, but there is little point in doing this.
|
2016-03-07 13:45:07 +01:00
|
|
|
return false;
|
2008-12-16 08:10:09 +01:00
|
|
|
}
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-12-22 05:25:02 +01:00
|
|
|
Value *Addr = Pointer.getAddr();
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : *Cache) {
|
|
|
|
Visited.insert(std::make_pair(Entry.getBB(), Addr));
|
|
|
|
if (Entry.getResult().isNonLocal()) {
|
2013-05-06 04:07:24 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-03-11 14:46:00 +01:00
|
|
|
if (DT.isReachableFromEntry(Entry.getBB())) {
|
2016-03-07 16:12:57 +01:00
|
|
|
Result.push_back(
|
|
|
|
NonLocalDepResult(Entry.getBB(), Entry.getResult(), Addr));
|
2013-05-06 04:07:24 +02:00
|
|
|
}
|
2008-12-16 08:10:09 +01:00
|
|
|
}
|
2008-12-08 08:31:50 +01:00
|
|
|
++NumCacheCompleteNonLocalPtr;
|
2016-03-07 13:45:07 +01:00
|
|
|
return true;
|
2008-12-08 08:31:50 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-08 08:31:50 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
if (Cache->empty())
|
2010-09-22 23:41:02 +02:00
|
|
|
CacheInfo->Pair = BBSkipFirstBlockPair(StartBB, SkipFirstBlock);
|
2010-11-11 01:42:22 +01:00
|
|
|
else
|
2010-09-22 23:41:02 +02:00
|
|
|
CacheInfo->Pair = BBSkipFirstBlockPair();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallVector<BasicBlock *, 32> Worklist;
|
2008-12-08 08:31:50 +01:00
|
|
|
Worklist.push_back(StartBB);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-06-02 01:16:53 +02:00
|
|
|
// PredList used inside loop.
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallVector<std::pair<BasicBlock *, PHITransAddr>, 16> PredList;
|
2011-06-02 01:16:53 +02:00
|
|
|
|
2008-12-07 09:50:20 +01: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();
|
2016-02-20 12:24:44 +01:00
|
|
|
unsigned WorklistEntries = BlockNumberLimit;
|
|
|
|
bool GotWorklistLimit = false;
|
2009-01-22 08:04:01 +01:00
|
|
|
DEBUG(AssertSorted(*Cache));
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 03:15:47 +01:00
|
|
|
while (!Worklist.empty()) {
|
2008-12-07 03:56:57 +01:00
|
|
|
BasicBlock *BB = Worklist.pop_back_val();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-10-01 22:07:13 +02:00
|
|
|
// If we do process a large number of blocks it becomes very expensive and
|
|
|
|
// likely it isn't worth worrying about
|
|
|
|
if (Result.size() > NumResultsLimit) {
|
|
|
|
Worklist.clear();
|
|
|
|
// 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()) {
|
|
|
|
SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
|
|
|
|
}
|
|
|
|
// Since we bail out, 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->Pair = BBSkipFirstBlockPair();
|
2016-03-07 13:45:07 +01:00
|
|
|
return false;
|
2014-10-01 22:07:13 +02:00
|
|
|
}
|
|
|
|
|
2008-12-09 08:52:59 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
if (!SkipFirstBlock) {
|
2008-12-09 08:52:59 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
assert(Visited.count(BB) && "Should check 'visited' before adding to WL");
|
2008-12-07 09:50:20 +01:00
|
|
|
|
2008-12-09 08:52:59 +01: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 08:04:01 +01:00
|
|
|
DEBUG(AssertSorted(*Cache, NumSortedEntries));
|
2016-03-07 11:19:30 +01:00
|
|
|
MemDepResult Dep = GetNonLocalInfoForBlock(QueryInst, Loc, isLoad, BB,
|
|
|
|
Cache, NumSortedEntries);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-09 08:52:59 +01:00
|
|
|
// If we got a Def or Clobber, add this to the list of results.
|
2013-05-06 04:07:24 +02:00
|
|
|
if (!Dep.isNonLocal()) {
|
2016-03-11 14:46:00 +01:00
|
|
|
if (DT.isReachableFromEntry(BB)) {
|
2013-05-06 04:07:24 +02:00
|
|
|
Result.push_back(NonLocalDepResult(BB, Dep, Pointer.getAddr()));
|
|
|
|
continue;
|
|
|
|
}
|
2008-12-09 08:52:59 +01:00
|
|
|
}
|
2008-12-07 03:15:47 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01: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 02:59:31 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
SkipFirstBlock = false;
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallVector<BasicBlock *, 16> NewBlocks;
|
2015-04-21 23:11:50 +02:00
|
|
|
for (BasicBlock *Pred : PredCache.get(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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
// Verify that we haven't looked at this block yet.
|
2016-03-07 11:19:30 +01:00
|
|
|
std::pair<DenseMap<BasicBlock *, Value *>::iterator, bool> InsertRes =
|
|
|
|
Visited.insert(std::make_pair(Pred, 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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
if (InsertRes.second) {
|
|
|
|
// First time we've looked at *PI.
|
2015-04-21 23:11:50 +02:00
|
|
|
NewBlocks.push_back(Pred);
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
continue;
|
|
|
|
}
|
2013-03-20 22:47:51 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
// 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.
|
2011-06-02 01:16:53 +02:00
|
|
|
if (InsertRes.first->second != Pointer.getAddr()) {
|
|
|
|
// Make sure to clean up the Visited map before continuing on to
|
|
|
|
// PredTranslationFailure.
|
|
|
|
for (unsigned i = 0; i < NewBlocks.size(); i++)
|
|
|
|
Visited.erase(NewBlocks[i]);
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
goto PredTranslationFailure;
|
2011-06-02 01:16:53 +02: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
}
|
2016-02-20 12:24:44 +01:00
|
|
|
if (NewBlocks.size() > WorklistEntries) {
|
|
|
|
// Make sure to clean up the Visited map before continuing on to
|
|
|
|
// PredTranslationFailure.
|
|
|
|
for (unsigned i = 0; i < NewBlocks.size(); i++)
|
|
|
|
Visited.erase(NewBlocks[i]);
|
|
|
|
GotWorklistLimit = true;
|
|
|
|
goto PredTranslationFailure;
|
|
|
|
}
|
|
|
|
WorklistEntries -= NewBlocks.size();
|
2011-06-02 01:16:53 +02:00
|
|
|
Worklist.append(NewBlocks.begin(), NewBlocks.end());
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
continue;
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-12-09 02:59:31 +01: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;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-07-13 19:14:23 +02: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 19:20:05 +02:00
|
|
|
SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
|
2009-07-13 19:14:23 +02:00
|
|
|
NumSortedEntries = Cache->size();
|
|
|
|
}
|
2014-04-15 06:59:12 +02:00
|
|
|
Cache = nullptr;
|
2011-06-02 01:16:53 +02:00
|
|
|
|
|
|
|
PredList.clear();
|
2015-04-21 23:11:50 +02:00
|
|
|
for (BasicBlock *Pred : PredCache.get(BB)) {
|
2011-06-02 01:16:53 +02:00
|
|
|
PredList.push_back(std::make_pair(Pred, Pointer));
|
|
|
|
|
2009-12-09 02:59:31 +01:00
|
|
|
// Get the PHI translated pointer in this predecessor. This can fail if
|
|
|
|
// not translatable, in which case the getAddr() returns null.
|
2011-06-02 01:16:53 +02:00
|
|
|
PHITransAddr &PredPointer = PredList.back().second;
|
2016-03-11 14:46:00 +01:00
|
|
|
PredPointer.PHITranslateValue(BB, Pred, &DT, /*MustDominate=*/false);
|
2009-12-09 02:59:31 +01:00
|
|
|
Value *PredPtrVal = PredPointer.getAddr();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-11-27 09:37:22 +01: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.
|
2016-03-07 11:19:30 +01:00
|
|
|
std::pair<DenseMap<BasicBlock *, Value *>::iterator, bool> InsertRes =
|
|
|
|
Visited.insert(std::make_pair(Pred, PredPtrVal));
|
2009-01-22 08:04:01 +01:00
|
|
|
|
2009-11-27 09:37:22 +01:00
|
|
|
if (!InsertRes.second) {
|
2011-06-02 01:16:53 +02:00
|
|
|
// We found the pred; take it off the list of preds to visit.
|
|
|
|
PredList.pop_back();
|
|
|
|
|
2009-11-27 09:37:22 +01:00
|
|
|
// If the predecessor was visited with PredPtr, then we already did
|
|
|
|
// the analysis and can ignore it.
|
2009-12-09 02:59:31 +01:00
|
|
|
if (InsertRes.first->second == PredPtrVal)
|
2009-11-27 09:37:22 +01:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-11-27 09:37:22 +01: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.
|
2011-06-02 01:16:53 +02:00
|
|
|
|
|
|
|
// Make sure to clean up the Visited map before continuing on to
|
|
|
|
// PredTranslationFailure.
|
2013-03-29 19:48:42 +01:00
|
|
|
for (unsigned i = 0, n = PredList.size(); i < n; ++i)
|
2011-06-02 01:16:53 +02:00
|
|
|
Visited.erase(PredList[i].first);
|
|
|
|
|
2009-11-27 09:37:22 +01:00
|
|
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
}
|
2011-06-02 01:16:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Actually process results here; this need to be a separate loop to avoid
|
|
|
|
// calling getNonLocalPointerDepFromBB for blocks we don't want to return
|
2013-03-20 22:47:51 +01:00
|
|
|
// any results for. (getNonLocalPointerDepFromBB will modify our
|
2011-06-02 01:16:53 +02:00
|
|
|
// datastructures in ways the code after the PredTranslationFailure label
|
|
|
|
// doesn't expect.)
|
2013-03-29 19:48:42 +01:00
|
|
|
for (unsigned i = 0, n = PredList.size(); i < n; ++i) {
|
2011-06-02 01:16:53 +02:00
|
|
|
BasicBlock *Pred = PredList[i].first;
|
|
|
|
PHITransAddr &PredPointer = PredList[i].second;
|
|
|
|
Value *PredPtrVal = PredPointer.getAddr();
|
|
|
|
|
|
|
|
bool CanTranslate = true;
|
2009-11-27 23:05:15 +01: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.
|
2014-04-15 06:59:12 +02:00
|
|
|
if (!PredPtrVal)
|
2011-06-02 01:16:53 +02:00
|
|
|
CanTranslate = false;
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
// If getNonLocalPointerDepFromBB fails here, that means the cached
|
|
|
|
// result conflicted with the Visited list; we have to conservatively
|
2011-06-15 02:47:34 +02:00
|
|
|
// assume it is unknown, but this also does not block PRE of the load.
|
2011-06-02 01:16:53 +02:00
|
|
|
if (!CanTranslate ||
|
2016-03-07 13:45:07 +01:00
|
|
|
!getNonLocalPointerDepFromBB(QueryInst, PredPointer,
|
2016-03-07 11:19:30 +01:00
|
|
|
Loc.getWithNewPtr(PredPtrVal), isLoad,
|
|
|
|
Pred, Result, Visited)) {
|
2009-12-01 08:33:32 +01:00
|
|
|
// Add the entry to the Result list.
|
2011-06-15 02:47:34 +02:00
|
|
|
NonLocalDepResult Entry(Pred, MemDepResult::getUnknown(), PredPtrVal);
|
2009-12-01 08:33:32 +01:00
|
|
|
Result.push_back(Entry);
|
|
|
|
|
2009-12-19 22:29:22 +01: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.
|
2010-09-22 23:41:02 +02:00
|
|
|
NonLocalPointerInfo &NLPI = NonLocalPointerDeps[CacheKey];
|
|
|
|
NLPI.Pair = BBSkipFirstBlockPair();
|
2009-11-27 23:05:15 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-11-27 09:37:22 +01:00
|
|
|
// Refresh the CacheInfo/Cache pointer so that it isn't invalidated.
|
|
|
|
CacheInfo = &NonLocalPointerDeps[CacheKey];
|
2010-09-22 23:41:02 +02:00
|
|
|
Cache = &CacheInfo->NonLocalDeps;
|
2009-11-27 09:37:22 +01:00
|
|
|
NumSortedEntries = Cache->size();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-11-27 09:37:22 +01:00
|
|
|
// 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.
|
2010-09-22 23:41:02 +02:00
|
|
|
CacheInfo->Pair = BBSkipFirstBlockPair();
|
2009-11-27 09:37:22 +01:00
|
|
|
SkipFirstBlock = false;
|
|
|
|
continue;
|
2009-11-27 00:18:49 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
PredTranslationFailure:
|
2011-06-02 01:16:53 +02:00
|
|
|
// The following code is "failure"; we can't produce a sane translation
|
|
|
|
// for the given block. It assumes that we haven't modified any of
|
|
|
|
// our datastructures while processing the current block.
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-04-15 06:59:12 +02:00
|
|
|
if (!Cache) {
|
2009-01-23 08:12:16 +01:00
|
|
|
// Refresh the CacheInfo/Cache pointer if it got invalidated.
|
|
|
|
CacheInfo = &NonLocalPointerDeps[CacheKey];
|
2010-09-22 23:41:02 +02:00
|
|
|
Cache = &CacheInfo->NonLocalDeps;
|
2009-01-23 08:12:16 +01:00
|
|
|
NumSortedEntries = Cache->size();
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-12-19 22:29:22 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01: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 22:29:22 +01:00
|
|
|
// results from the set". Clear out the indicator for this.
|
2010-09-22 23:41:02 +02:00
|
|
|
CacheInfo->Pair = BBSkipFirstBlockPair();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2011-06-15 02:47:34 +02:00
|
|
|
// If *nothing* works, mark the pointer as unknown.
|
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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
//
|
|
|
|
// 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)
|
2016-03-07 13:45:07 +01:00
|
|
|
return false;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-02-20 12:24:44 +01:00
|
|
|
bool foundBlock = false;
|
2016-03-07 11:19:30 +01:00
|
|
|
for (NonLocalDepEntry &I : llvm::reverse(*Cache)) {
|
2016-02-20 12:24:44 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 11:19:30 +01:00
|
|
|
assert((GotWorklistLimit || I.getResult().isNonLocal() ||
|
2016-03-11 14:46:00 +01:00
|
|
|
!DT.isReachableFromEntry(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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
"Should only be here with transparent block");
|
2016-02-20 12:24:44 +01:00
|
|
|
foundBlock = true;
|
|
|
|
I.setResult(MemDepResult::getUnknown());
|
2016-03-07 11:19:30 +01: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.
llvm-svn: 61022
2008-12-15 04:35:32 +01:00
|
|
|
break;
|
2008-12-07 03:56:57 +01:00
|
|
|
}
|
2016-04-02 07:34:19 +02:00
|
|
|
(void)foundBlock; (void)GotWorklistLimit;
|
2016-02-20 12:24:44 +01:00
|
|
|
assert((foundBlock || GotWorklistLimit) && "Current block not in cache?");
|
2008-12-07 03:15:47 +01:00
|
|
|
}
|
2009-01-23 08:12:16 +01:00
|
|
|
|
2008-12-09 08:47:11 +01:00
|
|
|
// Okay, we're done now. If we added new values to the cache, re-sort it.
|
2009-07-13 19:20:05 +02:00
|
|
|
SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
|
2009-01-22 08:04:01 +01:00
|
|
|
DEBUG(AssertSorted(*Cache));
|
2016-03-07 13:45:07 +01:00
|
|
|
return true;
|
2008-12-07 09:50:20 +01:00
|
|
|
}
|
|
|
|
|
2016-03-07 13:30:06 +01:00
|
|
|
/// If P exists in CachedNonLocalPointerInfo, remove it.
|
2016-03-10 01:55:30 +01:00
|
|
|
void MemoryDependenceResults::RemoveCachedNonLocalPointerDependencies(
|
2016-03-07 11:19:30 +01:00
|
|
|
ValueIsLoadPair P) {
|
|
|
|
CachedNonLocalPointerInfo::iterator It = NonLocalPointerDeps.find(P);
|
|
|
|
if (It == NonLocalPointerDeps.end())
|
|
|
|
return;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// Remove all of the entries in the BB->val map. This involves removing
|
|
|
|
// instructions from the reverse map.
|
2010-09-22 23:41:02 +02:00
|
|
|
NonLocalDepInfo &PInfo = It->second.NonLocalDeps;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
for (unsigned i = 0, e = PInfo.size(); i != e; ++i) {
|
2009-12-09 08:08:01 +01:00
|
|
|
Instruction *Target = PInfo[i].getResult().getInst();
|
2016-03-07 11:19:30 +01:00
|
|
|
if (!Target)
|
|
|
|
continue; // Ignore non-local dep results.
|
2009-12-09 08:08:01 +01:00
|
|
|
assert(Target->getParent() == PInfo[i].getBB());
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// Eliminating the dirty entry from 'Cache', so update the reverse info.
|
2009-03-29 01:24:04 +01:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalPtrDeps, Target, P);
|
2008-12-07 09:50:20 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// Remove P from NonLocalPointerDeps (which deletes NonLocalDepInfo).
|
|
|
|
NonLocalPointerDeps.erase(It);
|
2008-12-07 03:15:47 +01:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
void MemoryDependenceResults::invalidateCachedPointerInfo(Value *Ptr) {
|
2008-12-09 23:06:23 +01:00
|
|
|
// If Ptr isn't really a pointer, just ignore it.
|
2016-03-07 11:19:30 +01:00
|
|
|
if (!Ptr->getType()->isPointerTy())
|
|
|
|
return;
|
2008-12-09 23:06:23 +01:00
|
|
|
// Flush store info for the pointer.
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, false));
|
|
|
|
// Flush load info for the pointer.
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, true));
|
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
void MemoryDependenceResults::invalidateCachedPredecessors() {
|
2015-04-21 23:11:50 +02:00
|
|
|
PredCache.clear();
|
2010-02-16 20:51:59 +01:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
void MemoryDependenceResults::removeInstruction(Instruction *RemInst) {
|
2008-11-28 23:04:47 +01:00
|
|
|
// Walk through the Non-local dependencies, removing this one as the value
|
|
|
|
// for any cached queries.
|
2008-11-30 03:28:25 +01:00
|
|
|
NonLocalDepMapType::iterator NLDI = NonLocalDeps.find(RemInst);
|
|
|
|
if (NLDI != NonLocalDeps.end()) {
|
2008-12-01 02:15:42 +01:00
|
|
|
NonLocalDepInfo &BlockMap = NLDI->second.first;
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : BlockMap)
|
|
|
|
if (Instruction *Inst = Entry.getResult().getInst())
|
2008-12-07 19:39:13 +01:00
|
|
|
RemoveFromReverseMap(ReverseNonLocalDeps, Inst, RemInst);
|
2008-11-30 03:28:25 +01:00
|
|
|
NonLocalDeps.erase(NLDI);
|
|
|
|
}
|
2007-07-31 22:01:27 +02:00
|
|
|
|
2008-11-28 23:04:47 +01:00
|
|
|
// If we have a cached local dependence query for this instruction, remove it.
|
2008-11-28 23:28:27 +01:00
|
|
|
//
|
2008-11-29 02:43:36 +01:00
|
|
|
LocalDepMapType::iterator LocalDepEntry = LocalDeps.find(RemInst);
|
|
|
|
if (LocalDepEntry != LocalDeps.end()) {
|
2008-11-28 23:28:27 +01:00
|
|
|
// Remove us from DepInst's reverse set now that the local dep info is gone.
|
2008-12-07 19:39:13 +01:00
|
|
|
if (Instruction *Inst = LocalDepEntry->second.getInst())
|
|
|
|
RemoveFromReverseMap(ReverseLocalDeps, Inst, RemInst);
|
2008-11-30 02:09:30 +01:00
|
|
|
|
|
|
|
// Remove this local dependency info.
|
|
|
|
LocalDeps.erase(LocalDepEntry);
|
2008-12-07 09:50:20 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01: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.
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// 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.
|
2010-02-16 12:11:14 +01:00
|
|
|
if (RemInst->getType()->isPointerTy()) {
|
2008-12-07 09:50:20 +01:00
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, false));
|
|
|
|
RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, true));
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-28 23:51:08 +01:00
|
|
|
// Loop over all of the things that depend on the instruction we're removing.
|
2013-03-20 22:47:51 +01:00
|
|
|
//
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallVector<std::pair<Instruction *, Instruction *>, 8> ReverseDepsToAdd;
|
2008-12-07 19:42:51 +01: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())
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 02:53:03 +02:00
|
|
|
NewDirtyVal = MemDepResult::getDirty(&*++RemInst->getIterator());
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 10:20:15 +01:00
|
|
|
ReverseDepMapType::iterator ReverseDepIt = ReverseLocalDeps.find(RemInst);
|
|
|
|
if (ReverseDepIt != ReverseLocalDeps.end()) {
|
2008-12-07 09:50:20 +01:00
|
|
|
// RemInst can't be the terminator if it has local stuff depending on it.
|
2014-08-25 01:23:06 +02:00
|
|
|
assert(!ReverseDepIt->second.empty() && !isa<TerminatorInst>(RemInst) &&
|
2008-11-30 02:09:30 +01:00
|
|
|
"Nothing can locally depend on a terminator");
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-08-25 01:23:06 +02:00
|
|
|
for (Instruction *InstDependingOnRemInst : ReverseDepIt->second) {
|
2008-11-30 03:28:25 +01:00
|
|
|
assert(InstDependingOnRemInst != RemInst &&
|
|
|
|
"Already removed our local dep info");
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 19:42:51 +01:00
|
|
|
LocalDeps[InstDependingOnRemInst] = NewDirtyVal;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 02:09:30 +01:00
|
|
|
// Make sure to remember that new things depend on NewDepInst.
|
2016-03-07 11:19:30 +01:00
|
|
|
assert(NewDirtyVal.getInst() &&
|
|
|
|
"There is no way something else can have "
|
2008-12-07 19:42:51 +01:00
|
|
|
"a local dep on this if it is a terminator!");
|
2016-03-07 11:19:30 +01:00
|
|
|
ReverseDepsToAdd.push_back(
|
|
|
|
std::make_pair(NewDirtyVal.getInst(), InstDependingOnRemInst));
|
2008-11-30 00:30:39 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 00:30:39 +01:00
|
|
|
ReverseLocalDeps.erase(ReverseDepIt);
|
|
|
|
|
|
|
|
// Add new reverse deps after scanning the set, to avoid invalidating the
|
|
|
|
// 'ReverseDeps' reference.
|
|
|
|
while (!ReverseDepsToAdd.empty()) {
|
2016-03-07 11:19:30 +01:00
|
|
|
ReverseLocalDeps[ReverseDepsToAdd.back().first].insert(
|
|
|
|
ReverseDepsToAdd.back().second);
|
2008-11-30 00:30:39 +01:00
|
|
|
ReverseDepsToAdd.pop_back();
|
2008-11-28 23:51:08 +01:00
|
|
|
}
|
2007-07-07 01:14:35 +02:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-29 10:20:15 +01:00
|
|
|
ReverseDepIt = ReverseNonLocalDeps.find(RemInst);
|
|
|
|
if (ReverseDepIt != ReverseNonLocalDeps.end()) {
|
2014-08-25 01:23:06 +02:00
|
|
|
for (Instruction *I : ReverseDepIt->second) {
|
|
|
|
assert(I != RemInst && "Already removed NonLocalDep info for RemInst");
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-08-25 01:23:06 +02:00
|
|
|
PerInstNLInfo &INLD = NonLocalDeps[I];
|
2008-11-30 03:52:26 +01:00
|
|
|
// The information is now dirty!
|
2008-12-01 02:15:42 +01:00
|
|
|
INLD.second = true;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : INLD.first) {
|
|
|
|
if (Entry.getResult().getInst() != RemInst)
|
2016-03-07 11:19:30 +01:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 03:28:25 +01:00
|
|
|
// Convert to a dirty entry for the subsequent instruction.
|
2016-03-07 16:12:57 +01:00
|
|
|
Entry.setResult(NewDirtyVal);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 19:42:51 +01:00
|
|
|
if (Instruction *NextI = NewDirtyVal.getInst())
|
2014-08-25 01:23:06 +02:00
|
|
|
ReverseDepsToAdd.push_back(std::make_pair(NextI, I));
|
2008-11-30 03:28:25 +01:00
|
|
|
}
|
|
|
|
}
|
2008-11-30 00:30:39 +01:00
|
|
|
|
|
|
|
ReverseNonLocalDeps.erase(ReverseDepIt);
|
|
|
|
|
2008-11-29 23:02:15 +01:00
|
|
|
// Add new reverse deps after scanning the set, to avoid invalidating 'Set'
|
|
|
|
while (!ReverseDepsToAdd.empty()) {
|
2016-03-07 11:19:30 +01:00
|
|
|
ReverseNonLocalDeps[ReverseDepsToAdd.back().first].insert(
|
|
|
|
ReverseDepsToAdd.back().second);
|
2008-11-29 23:02:15 +01:00
|
|
|
ReverseDepsToAdd.pop_back();
|
|
|
|
}
|
2007-08-16 23:27:05 +02:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// If the instruction is in ReverseNonLocalPtrDeps then it appears as a
|
|
|
|
// value in the NonLocalPointerDeps info.
|
|
|
|
ReverseNonLocalPtrDepTy::iterator ReversePtrDepIt =
|
2016-03-07 11:19:30 +01:00
|
|
|
ReverseNonLocalPtrDeps.find(RemInst);
|
2008-12-07 09:50:20 +01:00
|
|
|
if (ReversePtrDepIt != ReverseNonLocalPtrDeps.end()) {
|
2016-03-07 11:19:30 +01:00
|
|
|
SmallVector<std::pair<Instruction *, ValueIsLoadPair>, 8>
|
|
|
|
ReversePtrDepsToAdd;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2014-08-25 01:23:06 +02:00
|
|
|
for (ValueIsLoadPair P : ReversePtrDepIt->second) {
|
2008-12-07 09:50:20 +01:00
|
|
|
assert(P.getPointer() != RemInst &&
|
|
|
|
"Already removed NonLocalPointerDeps info for RemInst");
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2010-09-22 23:41:02 +02:00
|
|
|
NonLocalDepInfo &NLPDI = NonLocalPointerDeps[P].NonLocalDeps;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-08 08:31:50 +01:00
|
|
|
// The cache is not valid for any specific block anymore.
|
2010-09-22 23:41:02 +02:00
|
|
|
NonLocalPointerDeps[P].Pair = BBSkipFirstBlockPair();
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// Update any entries for RemInst to use the instruction after it.
|
2016-03-07 16:12:57 +01:00
|
|
|
for (auto &Entry : NLPDI) {
|
|
|
|
if (Entry.getResult().getInst() != RemInst)
|
2016-03-07 11:19:30 +01:00
|
|
|
continue;
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
// Convert to a dirty entry for the subsequent instruction.
|
2016-03-07 16:12:57 +01:00
|
|
|
Entry.setResult(NewDirtyVal);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
if (Instruction *NewDirtyInst = NewDirtyVal.getInst())
|
|
|
|
ReversePtrDepsToAdd.push_back(std::make_pair(NewDirtyInst, P));
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2009-01-23 08:12:16 +01: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 09:50:20 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
ReverseNonLocalPtrDeps.erase(ReversePtrDepIt);
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-12-07 09:50:20 +01:00
|
|
|
while (!ReversePtrDepsToAdd.empty()) {
|
2016-03-07 11:19:30 +01:00
|
|
|
ReverseNonLocalPtrDeps[ReversePtrDepsToAdd.back().first].insert(
|
|
|
|
ReversePtrDepsToAdd.back().second);
|
2008-12-07 09:50:20 +01:00
|
|
|
ReversePtrDepsToAdd.pop_back();
|
|
|
|
}
|
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2008-11-30 03:28:25 +01:00
|
|
|
assert(!NonLocalDeps.count(RemInst) && "RemInst got reinserted?");
|
2011-01-11 05:05:39 +01:00
|
|
|
DEBUG(verifyRemoved(RemInst));
|
2007-07-07 01:14:35 +02:00
|
|
|
}
|
2016-03-07 13:30:06 +01:00
|
|
|
|
|
|
|
/// Verify that the specified instruction does not occur in our internal data
|
|
|
|
/// structures.
|
|
|
|
///
|
|
|
|
/// This function verifies by asserting in debug builds.
|
2016-03-10 01:55:30 +01:00
|
|
|
void MemoryDependenceResults::verifyRemoved(Instruction *D) const {
|
2014-08-25 01:23:06 +02:00
|
|
|
#ifndef NDEBUG
|
2016-03-07 16:12:57 +01:00
|
|
|
for (const auto &DepKV : LocalDeps) {
|
|
|
|
assert(DepKV.first != D && "Inst occurs in data structures");
|
|
|
|
assert(DepKV.second.getInst() != D && "Inst occurs in data structures");
|
2008-11-29 22:25:10 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (const auto &DepKV : NonLocalPointerDeps) {
|
|
|
|
assert(DepKV.first.getPointer() != D && "Inst occurs in NLPD map key");
|
|
|
|
for (const auto &Entry : DepKV.second.NonLocalDeps)
|
|
|
|
assert(Entry.getResult().getInst() != D && "Inst occurs as NLPD value");
|
2008-12-07 09:50:20 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (const auto &DepKV : NonLocalDeps) {
|
|
|
|
assert(DepKV.first != D && "Inst occurs in data structures");
|
|
|
|
const PerInstNLInfo &INLD = DepKV.second;
|
|
|
|
for (const auto &Entry : INLD.first)
|
|
|
|
assert(Entry.getResult().getInst() != D &&
|
2016-03-07 11:19:30 +01:00
|
|
|
"Inst occurs in data structures");
|
2008-11-29 22:25:10 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (const auto &DepKV : ReverseLocalDeps) {
|
|
|
|
assert(DepKV.first != D && "Inst occurs in data structures");
|
|
|
|
for (Instruction *Inst : DepKV.second)
|
2014-08-25 01:23:06 +02:00
|
|
|
assert(Inst != D && "Inst occurs in data structures");
|
2008-11-30 03:28:25 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (const auto &DepKV : ReverseNonLocalDeps) {
|
|
|
|
assert(DepKV.first != D && "Inst occurs in data structures");
|
|
|
|
for (Instruction *Inst : DepKV.second)
|
2014-08-25 01:23:06 +02:00
|
|
|
assert(Inst != D && "Inst occurs in data structures");
|
2008-11-30 03:28:25 +01:00
|
|
|
}
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (const auto &DepKV : ReverseNonLocalPtrDeps) {
|
|
|
|
assert(DepKV.first != D && "Inst occurs in rev NLPD map");
|
2013-03-20 22:47:51 +01:00
|
|
|
|
2016-03-07 16:12:57 +01:00
|
|
|
for (ValueIsLoadPair P : DepKV.second)
|
2016-03-07 11:19:30 +01:00
|
|
|
assert(P != ValueIsLoadPair(D, false) && P != ValueIsLoadPair(D, true) &&
|
2008-12-07 09:50:20 +01:00
|
|
|
"Inst occurs in ReverseNonLocalPtrDeps map");
|
|
|
|
}
|
2014-08-25 01:23:06 +02:00
|
|
|
#endif
|
2008-11-29 22:25:10 +01:00
|
|
|
}
|
2016-03-10 01:55:30 +01:00
|
|
|
|
2016-11-23 18:53:26 +01:00
|
|
|
AnalysisKey MemoryDependenceAnalysis::Key;
|
2016-03-11 11:22:49 +01:00
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
MemoryDependenceResults
|
2016-08-09 02:28:15 +02:00
|
|
|
MemoryDependenceAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
|
2016-03-11 12:05:24 +01:00
|
|
|
auto &AA = AM.getResult<AAManager>(F);
|
2016-12-19 09:22:17 +01:00
|
|
|
auto &AC = AM.getResult<AssumptionAnalysis>(F);
|
2016-03-11 12:05:24 +01:00
|
|
|
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
|
2016-03-11 14:46:00 +01:00
|
|
|
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
|
2016-12-19 09:22:17 +01:00
|
|
|
return MemoryDependenceResults(AA, AC, TLI, DT);
|
2016-03-10 01:55:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char MemoryDependenceWrapperPass::ID = 0;
|
|
|
|
|
|
|
|
INITIALIZE_PASS_BEGIN(MemoryDependenceWrapperPass, "memdep",
|
|
|
|
"Memory Dependence Analysis", false, true)
|
2016-12-19 09:22:17 +01:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
2016-03-10 01:55:30 +01:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
|
2016-03-11 14:46:00 +01:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
|
2016-03-10 01:55:30 +01:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
|
|
|
|
INITIALIZE_PASS_END(MemoryDependenceWrapperPass, "memdep",
|
|
|
|
"Memory Dependence Analysis", false, true)
|
|
|
|
|
|
|
|
MemoryDependenceWrapperPass::MemoryDependenceWrapperPass() : FunctionPass(ID) {
|
|
|
|
initializeMemoryDependenceWrapperPassPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2016-08-25 02:45:04 +02:00
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
MemoryDependenceWrapperPass::~MemoryDependenceWrapperPass() {}
|
|
|
|
|
|
|
|
void MemoryDependenceWrapperPass::releaseMemory() {
|
|
|
|
MemDep.reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MemoryDependenceWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
2016-12-19 09:22:17 +01:00
|
|
|
AU.addRequired<AssumptionCacheTracker>();
|
2016-03-11 14:46:00 +01:00
|
|
|
AU.addRequired<DominatorTreeWrapperPass>();
|
2016-03-10 01:55:30 +01:00
|
|
|
AU.addRequiredTransitive<AAResultsWrapperPass>();
|
|
|
|
AU.addRequiredTransitive<TargetLibraryInfoWrapperPass>();
|
|
|
|
}
|
|
|
|
|
2016-12-27 20:33:04 +01:00
|
|
|
bool MemoryDependenceResults::invalidate(Function &F, const PreservedAnalyses &PA,
|
|
|
|
FunctionAnalysisManager::Invalidator &Inv) {
|
|
|
|
// Check whether our analysis is preserved.
|
|
|
|
auto PAC = PA.getChecker<MemoryDependenceAnalysis>();
|
|
|
|
if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Function>>())
|
|
|
|
// If not, give up now.
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Check whether the analyses we depend on became invalid for any reason.
|
|
|
|
if (Inv.invalidate<AAManager>(F, PA) ||
|
|
|
|
Inv.invalidate<AssumptionAnalysis>(F, PA) ||
|
|
|
|
Inv.invalidate<DominatorTreeAnalysis>(F, PA))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise this analysis result remains valid.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
limit the number of instructions per block examined by dead store elimination
Summary: Dead store elimination gets very expensive when large numbers of instructions need to be analyzed. This patch limits the number of instructions analyzed per store to the value of the memdep-block-scan-limit parameter (which defaults to 100). This resulted in no observed difference in performance of the generated code, and no change in the statistics for the dead store elimination pass, but improved compilation time on some files by more than an order of magnitude.
Reviewers: dexonsmith, bruno, george.burgess.iv, dberlin, reames, davidxl
Subscribers: davide, chandlerc, dberlin, davidxl, eraman, tejohnson, mbodart, llvm-commits
Differential Revision: https://reviews.llvm.org/D15537
llvm-svn: 279833
2016-08-26 18:34:27 +02:00
|
|
|
unsigned MemoryDependenceResults::getDefaultBlockScanLimit() const {
|
|
|
|
return BlockScanLimit;
|
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:30 +01:00
|
|
|
bool MemoryDependenceWrapperPass::runOnFunction(Function &F) {
|
|
|
|
auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
|
2016-12-19 09:22:17 +01:00
|
|
|
auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
|
2016-03-10 01:55:30 +01:00
|
|
|
auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
|
2016-03-11 14:46:00 +01:00
|
|
|
auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
|
2016-12-19 09:22:17 +01:00
|
|
|
MemDep.emplace(AA, AC, TLI, DT);
|
2016-03-10 01:55:30 +01:00
|
|
|
return false;
|
|
|
|
}
|