RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00
Code Issues Projects Releases Wiki Activity

Extract FindAvailablePtrLoadStore out of FindAvailableLoadedValue. NFCI

Browse Source 
Summary:
Extract FindAvailablePtrLoadStore out of FindAvailableLoadedValue.
Prepare for upcoming change which will do phi-translation for load on
phi pointer in jump threading SimplifyPartiallyRedundantLoad.

This is in preparation for https://reviews.llvm.org/D30543

Reviewers: efriedma, sanjoy, davide, dberlin

Reviewed By: davide

Subscribers: junbuml, davide, llvm-commits

Differential Revision: https://reviews.llvm.org/D30524

llvm-svn: 298216
This commit is contained in:
Xin Tong 2017-03-19 15:27:52 +00:00
parent 164ab9b4a4
commit 7ed0553795
2 changed files with 46 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/llvm/Analysis/Loads.h
View File

@ -88,6 +88,34 @@ Value *FindAvailableLoadedValue(LoadInst *Load,
bool *IsLoadCSE = nullptr, bool *IsLoadCSE = nullptr,
unsigned *NumScanedInst = nullptr); unsigned *NumScanedInst = nullptr);
/// Scan backwards to see if we have the value of the given pointer available
/// locally within a small number of instructions.
///
/// You can use this function to scan across multiple blocks: after you call
/// this function, if ScanFrom points at the beginning of the block, it's safe
/// to continue scanning the predecessors.
///
/// \param Ptr The pointer we want the load and store to originate from.
/// \param AccessTy The access type of the pointer.
/// \param AtLeastAtomic Are we looking for at-least an atomic load/store ? In
/// case it is false, we can return an atomic or non-atomic load or store. In
/// case it is true, we need to return an atomic load or store.
/// \param ScanBB The basic block to scan.
/// \param [in,out] ScanFrom The location to start scanning from. When this
/// function returns, it points at the last instruction scanned.
/// \param MaxInstsToScan The maximum number of instructions to scan. If this
/// is zero, the whole block will be scanned.
/// \param AA Optional pointer to alias analysis, to make the scan more
/// precise.
/// \param [out] IsLoad Whether the returned value is a load from the same
/// location in memory, as opposed to the value operand of a store.
///
/// \returns The found value, or nullptr if no value is found.
Value *FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy, bool AtLeastAtomic,
BasicBlock *ScanBB,
BasicBlock::iterator &ScanFrom,
unsigned MaxInstsToScan, AliasAnalysis *AA,
bool *IsLoad, unsigned *NumScanedInst);
} }
#endif #endif

32
lib/Analysis/Loads.cpp
View File

@ -312,22 +312,26 @@ Value *llvm::FindAvailableLoadedValue(LoadInst *Load,
BasicBlock *ScanBB, BasicBlock *ScanBB,
BasicBlock::iterator &ScanFrom, BasicBlock::iterator &ScanFrom,
unsigned MaxInstsToScan, unsigned MaxInstsToScan,
AliasAnalysis *AA, bool *IsLoadCSE, AliasAnalysis *AA, bool *IsLoad,
unsigned *NumScanedInst) { unsigned *NumScanedInst) {
if (MaxInstsToScan == 0) // Don't CSE load that is volatile or anything stronger than unordered.
MaxInstsToScan = ~0U;
Value *Ptr = Load->getPointerOperand();
Type *AccessTy = Load->getType();
// We can never remove a volatile load
if (Load->isVolatile())
return nullptr;
// Anything stronger than unordered is currently unimplemented.
if (!Load->isUnordered()) if (!Load->isUnordered())
return nullptr; return nullptr;
return FindAvailablePtrLoadStore(
Load->getPointerOperand(), Load->getType(), Load->isAtomic(), ScanBB,
ScanFrom, MaxInstsToScan, AA, IsLoad, NumScanedInst);
}
Value *llvm::FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy,
bool AtLeastAtomic, BasicBlock *ScanBB,
BasicBlock::iterator &ScanFrom,
unsigned MaxInstsToScan,
AliasAnalysis *AA, bool *IsLoadCSE,
unsigned *NumScanedInst) {
if (MaxInstsToScan == 0)
MaxInstsToScan = ~0U;
const DataLayout &DL = ScanBB->getModule()->getDataLayout(); const DataLayout &DL = ScanBB->getModule()->getDataLayout();
// Try to get the store size for the type. // Try to get the store size for the type.
@ -363,7 +367,7 @@ Value *llvm::FindAvailableLoadedValue(LoadInst *Load,
// We can value forward from an atomic to a non-atomic, but not the // We can value forward from an atomic to a non-atomic, but not the
// other way around. // other way around.
if (LI->isAtomic() < Load->isAtomic()) if (LI->isAtomic() < AtLeastAtomic)
return nullptr; return nullptr;
if (IsLoadCSE) if (IsLoadCSE)
@ -382,7 +386,7 @@ Value *llvm::FindAvailableLoadedValue(LoadInst *Load,
// We can value forward from an atomic to a non-atomic, but not the // We can value forward from an atomic to a non-atomic, but not the
// other way around. // other way around.
if (SI->isAtomic() < Load->isAtomic()) if (SI->isAtomic() < AtLeastAtomic)
return nullptr; return nullptr;
if (IsLoadCSE) if (IsLoadCSE)