6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-15 04:30:12 +00:00
Code Issues Projects Releases Wiki Activity

Use consistent terminology for loop exit/exiting blocks. Name change only.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@136677 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Andrew Trick 2011-08-02 04:23:35 +00:00
parent 7a3824b923
commit fcb4356dee
2 changed files with 16 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/llvm/Analysis/ScalarEvolution.h
View File

@ -264,11 +264,11 @@ namespace llvm {
/// ExitNotTakenInfo - Information about the number of times a particular
/// loop exit may be reached before exiting the loop.
struct ExitNotTakenInfo {
BasicBlock *ExitBlock;
BasicBlock *ExitingBlock;
const SCEV *ExactNotTaken;
PointerIntPair<ExitNotTakenInfo*, 1> NextExit;
ExitNotTakenInfo() : ExitBlock(0), ExactNotTaken(0) {}
ExitNotTakenInfo() : ExitingBlock(0), ExactNotTaken(0) {}
/// isCompleteList - Return true if all loop exits are computable.
bool isCompleteList() const {
@ -309,7 +309,7 @@ namespace llvm {
/// computed information, or whether it's all SCEVCouldNotCompute
/// values.
bool hasAnyInfo() const {
return ExitNotTaken.ExitBlock || !isa<SCEVCouldNotCompute>(Max);
return ExitNotTaken.ExitingBlock || !isa<SCEVCouldNotCompute>(Max);
}
/// getExact - Return an expression indicating the exact backedge-taken
@ -321,7 +321,7 @@ namespace llvm {
/// getExact - Return the number of times this loop exit may fall through
/// to the back edge. The loop is guaranteed not to exit via this block
/// before this number of iterations, but may exit via another block.
const SCEV *getExact(BasicBlock *ExitBlock, ScalarEvolution *SE) const;
const SCEV *getExact(BasicBlock *ExitingBlock, ScalarEvolution *SE) const;
/// getMax - Get the max backedge taken count for the loop.
const SCEV *getMax(ScalarEvolution *SE) const;
@ -711,9 +711,9 @@ namespace llvm {
const SCEV *LHS, const SCEV *RHS);
// getExitCount - Get the expression for the number of loop iterations for
// which this loop is guaranteed not to exit via ExitBlock. Otherwise return
// SCEVCouldNotCompute.
const SCEV *getExitCount(Loop *L, BasicBlock *ExitBlock);
// which this loop is guaranteed not to exit via ExitingBlock. Otherwise
// return SCEVCouldNotCompute.
const SCEV *getExitCount(Loop *L, BasicBlock *ExitingBlock);
/// getBackedgeTakenCount - If the specified loop has a predictable
/// backedge-taken count, return it, otherwise return a SCEVCouldNotCompute

18
lib/Analysis/ScalarEvolution.cpp
View File

@ -3814,10 +3814,10 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
//
// getExitCount - Get the expression for the number of loop iterations for which
// this loop is guaranteed not to exit via ExitBlock. Otherwise return
// this loop is guaranteed not to exit via ExitintBlock. Otherwise return
// SCEVCouldNotCompute.
const SCEV *ScalarEvolution::getExitCount(Loop *L, BasicBlock *ExitBlock) {
return getBackedgeTakenInfo(L).getExact(ExitBlock, this);
const SCEV *ScalarEvolution::getExitCount(Loop *L, BasicBlock *ExitingBlock) {
return getBackedgeTakenInfo(L).getExact(ExitingBlock, this);
}
/// getBackedgeTakenCount - If the specified loop has a predictable
@ -4002,7 +4002,7 @@ ScalarEvolution::BackedgeTakenInfo::getExact(ScalarEvolution *SE) const {
if (!ExitNotTaken.isCompleteList()) return SE->getCouldNotCompute();
// We need at least one computable exit.
if (!ExitNotTaken.ExitBlock) return SE->getCouldNotCompute();
if (!ExitNotTaken.ExitingBlock) return SE->getCouldNotCompute();
assert(ExitNotTaken.ExactNotTaken && "uninitialized not-taken info");
const SCEV *BECount = 0;
@ -4021,12 +4021,12 @@ ScalarEvolution::BackedgeTakenInfo::getExact(ScalarEvolution *SE) const {
/// getExact - Get the exact not taken count for this loop exit.
const SCEV *
ScalarEvolution::BackedgeTakenInfo::getExact(BasicBlock *ExitBlock,
ScalarEvolution::BackedgeTakenInfo::getExact(BasicBlock *ExitingBlock,
ScalarEvolution *SE) const {
for (const ExitNotTakenInfo *ENT = &ExitNotTaken;
ENT != 0; ENT = ENT->getNextExit()) {
if (ENT->ExitBlock == ExitBlock)
if (ENT->ExitingBlock == ExitingBlock)
return ENT->ExactNotTaken;
}
return SE->getCouldNotCompute();
@ -4050,7 +4050,7 @@ ScalarEvolution::BackedgeTakenInfo::BackedgeTakenInfo(
unsigned NumExits = ExitCounts.size();
if (NumExits == 0) return;
ExitNotTaken.ExitBlock = ExitCounts[0].first;
ExitNotTaken.ExitingBlock = ExitCounts[0].first;
ExitNotTaken.ExactNotTaken = ExitCounts[0].second;
if (NumExits == 1) return;
@ -4060,14 +4060,14 @@ ScalarEvolution::BackedgeTakenInfo::BackedgeTakenInfo(
ExitNotTakenInfo *PrevENT = &ExitNotTaken;
for (unsigned i = 1; i < NumExits; ++i, PrevENT = ENT, ++ENT) {
PrevENT->setNextExit(ENT);
ENT->ExitBlock = ExitCounts[i].first;
ENT->ExitingBlock = ExitCounts[i].first;
ENT->ExactNotTaken = ExitCounts[i].second;
}
}
/// clear - Invalidate this result and free the ExitNotTakenInfo array.
void ScalarEvolution::BackedgeTakenInfo::clear() {
ExitNotTaken.ExitBlock = 0;
ExitNotTaken.ExitingBlock = 0;
ExitNotTaken.ExactNotTaken = 0;
delete[] ExitNotTaken.getNextExit();
}