intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-02-06 15:18:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

ScopInfo: Check for the existance of a single memory accesses

Browse Source 
Instead of counting all array memory accesses associated with a load
instruction, we now explicitly check that the single array access that could
(potentially) be associated with a load instruction does not exist. This helps
to document the current behavior of Polly where load instructions can indeed
have at most one associated array access. In the unlikely case this changes
in the future, we add an assert for the case where two load accesses would
prevent us to return a single memory access, but we still should communicate
that not all array memory accesses have been removed.

This addresses post-commit comments from Johannes Doerfert for commit 255776.

llvm-svn: 256136
This commit is contained in:
Tobias Grosser
2015-12-21 07:10:39 +00:00
parent dfe29ae5db
commit 949e8c6ac6
2 changed files with 15 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
polly/include/polly/ScopInfo.h
View File

@@ -958,14 +958,15 @@ public:
/// @brief Return true if this statement does not contain any accesses.
bool isEmpty() const { return MemAccs.empty(); }
/// @brief Return the only array access for @p Inst.
/// @brief Return the only array access for @p Inst, if existing.
///
/// @param Inst The instruction for which to look up the access.
/// @returns The unique array memory access related to Inst.
MemoryAccess &getArrayAccessFor(const Instruction *Inst) const {
/// @returns The unique array memory access related to Inst or nullptr if
/// no array access exists
MemoryAccess *getArrayAccessOrNULLFor(const Instruction *Inst) const {
auto It = InstructionToAccess.find(Inst);
assert(It != InstructionToAccess.end() &&
"No memory accesses found for instruction");
if (It == InstructionToAccess.end())
return nullptr;
MemoryAccess *ArrayAccess = nullptr;
@@ -978,26 +979,18 @@ public:
ArrayAccess = Access;
}
assert(ArrayAccess && "No array access found for instruction!");
return *ArrayAccess;
return ArrayAccess;
}
/// @brief Get the number of array accesses associated with an instruction.
/// @brief Return the only array access for @p Inst.
///
/// @param Inst The instruction for which to obtain the access count.
/// @returns The number of array accesses associated with this instruction.
size_t getNumberOfArrayAccessesFor(const Instruction *Inst) const {
size_t NumAccesses = 0;
auto It = InstructionToAccess.find(Inst);
if (It == InstructionToAccess.end())
return 0;
/// @param Inst The instruction for which to look up the access.
/// @returns The unique array memory access related to Inst.
MemoryAccess &getArrayAccessFor(const Instruction *Inst) const {
MemoryAccess *ArrayAccess = getArrayAccessOrNULLFor(Inst);
for (auto Access : It->getSecond()) {
if (Access->isArrayKind())
NumAccesses++;
}
return NumAccesses;
assert(ArrayAccess && "No array access found for instruction!");
return *ArrayAccess;
}
void setBasicBlock(BasicBlock *Block) {

2
polly/lib/Analysis/ScopInfo.cpp
View File

@@ -2928,7 +2928,7 @@ void Scop::verifyInvariantLoads() {
for (LoadInst *LI : RIL) {
assert(LI && getRegion().contains(LI));
ScopStmt *Stmt = getStmtForBasicBlock(LI->getParent());
if (Stmt && Stmt->getNumberOfArrayAccessesFor(LI) > 0) {
if (Stmt && Stmt->getArrayAccessOrNULLFor(LI)) {
invalidate(INVARIANTLOAD, LI->getDebugLoc());
return;
}