[llvm-commits] CVS: llvm/lib/Analysis/AliasAnalysisCounter.cpp BasicAliasAnalysis.cpp Expressions.cpp LoadValueNumbering.cpp
John Criswell
criswell at choi.cs.uiuc.edu
Thu Jun 26 16:39:38 PDT 2003
Changes in directory llvm/lib/Analysis:
AliasAnalysisCounter.cpp updated: 1.3 -> 1.3.2.1
BasicAliasAnalysis.cpp updated: 1.10 -> 1.10.2.1
Expressions.cpp updated: 1.31 -> 1.31.2.1
LoadValueNumbering.cpp updated: 1.2 -> 1.2.2.1
---
Log message:
Merged with mainline on Thursday, June 26, 2003.
---
Diffs of the changes:
Index: llvm/lib/Analysis/AliasAnalysisCounter.cpp
diff -u llvm/lib/Analysis/AliasAnalysisCounter.cpp:1.3 llvm/lib/Analysis/AliasAnalysisCounter.cpp:1.3.2.1
--- llvm/lib/Analysis/AliasAnalysisCounter.cpp:1.3 Wed Feb 26 13:27:05 2003
+++ llvm/lib/Analysis/AliasAnalysisCounter.cpp Thu Jun 26 16:35:05 2003
@@ -32,23 +32,27 @@
<< "\n===== Alias Analysis Counter Report =====\n"
<< " Analysis counted: " << Name << "\n"
<< " " << AASum << " Total Alias Queries Performed\n";
- printLine("no alias", No, AASum);
- printLine("may alias", May, AASum);
- printLine("must alias", Must, AASum);
- std::cerr
- << " Alias Analysis Counter Summary: " << No*100/AASum << "%/"
- << May*100/AASum << "%/" << Must*100/AASum<<"%\n\n";
+ if (AASum) {
+ printLine("no alias", No, AASum);
+ printLine("may alias", May, AASum);
+ printLine("must alias", Must, AASum);
+ std::cerr
+ << " Alias Analysis Counter Summary: " << No*100/AASum << "%/"
+ << May*100/AASum << "%/" << Must*100/AASum<<"%\n\n";
+ }
std::cerr
<< " " << MRSum << " Total Mod/Ref Queries Performed\n";
- printLine("no mod/ref", NoMR, MRSum);
- printLine("ref", JustRef, MRSum);
- printLine("mod", JustMod, MRSum);
- printLine("mod/ref", MR, MRSum);
- std::cerr
- << " Mod/Ref Analysis Counter Summary: " << NoMR*100/MRSum<< "%/"
- << JustRef*100/MRSum << "%/" << JustMod*100/MRSum << "%/"
- << MR*100/MRSum <<"%\n\n";
+ if (MRSum) {
+ printLine("no mod/ref", NoMR, MRSum);
+ printLine("ref", JustRef, MRSum);
+ printLine("mod", JustMod, MRSum);
+ printLine("mod/ref", MR, MRSum);
+ std::cerr
+ << " Mod/Ref Analysis Counter Summary: " << NoMR*100/MRSum<< "%/"
+ << JustRef*100/MRSum << "%/" << JustMod*100/MRSum << "%/"
+ << MR*100/MRSum <<"%\n\n";
+ }
}
}
Index: llvm/lib/Analysis/BasicAliasAnalysis.cpp
diff -u llvm/lib/Analysis/BasicAliasAnalysis.cpp:1.10 llvm/lib/Analysis/BasicAliasAnalysis.cpp:1.10.2.1
--- llvm/lib/Analysis/BasicAliasAnalysis.cpp:1.10 Mon Jun 2 00:42:39 2003
+++ llvm/lib/Analysis/BasicAliasAnalysis.cpp Thu Jun 26 16:35:05 2003
@@ -69,6 +69,12 @@
if (const Instruction *I = dyn_cast<Instruction>(V)) {
if (isa<CastInst>(I) || isa<GetElementPtrInst>(I))
return getUnderlyingObject(I->getOperand(0));
+ } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
+ if (CE->getOpcode() == Instruction::Cast ||
+ CE->getOpcode() == Instruction::GetElementPtr)
+ return getUnderlyingObject(CE->getOperand(0));
+ } else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V)) {
+ return CPR->getValue();
}
return 0;
}
Index: llvm/lib/Analysis/Expressions.cpp
diff -u llvm/lib/Analysis/Expressions.cpp:1.31 llvm/lib/Analysis/Expressions.cpp:1.31.2.1
--- llvm/lib/Analysis/Expressions.cpp:1.31 Tue May 20 13:45:29 2003
+++ llvm/lib/Analysis/Expressions.cpp Thu Jun 26 16:35:05 2003
@@ -317,12 +317,10 @@
if (isa<PointerType>(DestTy))
DestTy = Type::ULongTy; // Pointer types are represented as ulong
- /*
if (!Src.getExprType(0)->isLosslesslyConvertibleTo(DestTy)) {
if (Src.ExprTy != ExprType::Constant)
return I; // Converting cast, and not a constant value...
}
- */
const ConstantInt *Offset = Src.Offset;
const ConstantInt *Scale = Src.Scale;
Index: llvm/lib/Analysis/LoadValueNumbering.cpp
diff -u llvm/lib/Analysis/LoadValueNumbering.cpp:1.2 llvm/lib/Analysis/LoadValueNumbering.cpp:1.2.2.1
--- llvm/lib/Analysis/LoadValueNumbering.cpp:1.2 Wed Feb 26 13:27:35 2003
+++ llvm/lib/Analysis/LoadValueNumbering.cpp Thu Jun 26 16:35:06 2003
@@ -24,7 +24,7 @@
#include <set>
namespace {
- // FIXME: This should not be a functionpass.
+ // FIXME: This should not be a FunctionPass.
struct LoadVN : public FunctionPass, public ValueNumbering {
/// Pass Implementation stuff. This doesn't do any analysis.
@@ -51,6 +51,8 @@
///
bool haveEqualValueNumber(LoadInst *LI, LoadInst *LI2, AliasAnalysis &AA,
DominatorSet &DomSetInfo) const;
+ bool haveEqualValueNumber(LoadInst *LI, StoreInst *SI, AliasAnalysis &AA,
+ DominatorSet &DomSetInfo) const;
};
// Register this pass...
@@ -83,13 +85,13 @@
std::vector<Value*> &RetVals) const {
if (LoadInst *LI = dyn_cast<LoadInst>(V)) {
- // If we have a load instruction, find all of the load instructions that use
- // the same source operand. We implement this recursively, because there
- // could be a load of a load of a load that are all identical. We are
- // guaranteed that this cannot be an infinite recursion because load
- // instructions would have to pass through a PHI node in order for there to
- // be a cycle. The PHI node would be handled by the else case here,
- // breaking the infinite recursion.
+ // If we have a load instruction, find all of the load and store
+ // instructions that use the same source operand. We implement this
+ // recursively, because there could be a load of a load of a load that are
+ // all identical. We are guaranteed that this cannot be an infinite
+ // recursion because load instructions would have to pass through a PHI node
+ // in order for there to be a cycle. The PHI node would be handled by the
+ // else case here, breaking the infinite recursion.
//
std::vector<Value*> PointerSources;
getEqualNumberNodes(LI->getOperand(0), PointerSources);
@@ -98,30 +100,40 @@
Function *F = LI->getParent()->getParent();
// Now that we know the set of equivalent source pointers for the load
- // instruction, look to see if there are any load candiates that are
- // identical.
+ // instruction, look to see if there are any load or store candiates that
+ // are identical.
//
std::vector<LoadInst*> CandidateLoads;
+ std::vector<StoreInst*> CandidateStores;
+
while (!PointerSources.empty()) {
Value *Source = PointerSources.back();
PointerSources.pop_back(); // Get a source pointer...
for (Value::use_iterator UI = Source->use_begin(), UE = Source->use_end();
UI != UE; ++UI)
- if (LoadInst *Cand = dyn_cast<LoadInst>(*UI)) // Is a load of source?
+ if (LoadInst *Cand = dyn_cast<LoadInst>(*UI)) {// Is a load of source?
if (Cand->getParent()->getParent() == F && // In the same function?
Cand != LI) // Not LI itself?
CandidateLoads.push_back(Cand); // Got one...
+ } else if (StoreInst *Cand = dyn_cast<StoreInst>(*UI)) {
+ if (Cand->getParent()->getParent() == F &&
+ Cand->getOperand(1) == Source) // It's a store THROUGH the ptr...
+ CandidateStores.push_back(Cand);
+ }
}
// Remove duplicates from the CandidateLoads list because alias analysis
// processing may be somewhat expensive and we don't want to do more work
// than neccesary.
//
+ unsigned OldSize = CandidateLoads.size();
std::sort(CandidateLoads.begin(), CandidateLoads.end());
CandidateLoads.erase(std::unique(CandidateLoads.begin(),
CandidateLoads.end()),
CandidateLoads.end());
+ // FIXME: REMOVE THIS SORTING AND UNIQUING IF IT CAN'T HAPPEN
+ assert(CandidateLoads.size() == OldSize && "Shrunk the candloads list?");
// Get Alias Analysis...
AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
@@ -133,9 +145,11 @@
for (unsigned i = 0, e = CandidateLoads.size(); i != e; ++i)
if (haveEqualValueNumber(LI, CandidateLoads[i], AA, DomSetInfo))
RetVals.push_back(CandidateLoads[i]);
-
+ for (unsigned i = 0, e = CandidateStores.size(); i != e; ++i)
+ if (haveEqualValueNumber(LI, CandidateStores[i], AA, DomSetInfo))
+ RetVals.push_back(CandidateStores[i]->getOperand(0));
+
} else {
- // Make sure passmanager doesn't try to fulfill our request with ourself!
assert(&getAnalysis<ValueNumbering>() != (ValueNumbering*)this &&
"getAnalysis() returned this!");
@@ -215,7 +229,7 @@
return true;
} else {
// Make sure that there are no store instructions between L1 and the end of
- // it's basic block...
+ // its basic block...
//
if (AA.canInstructionRangeModify(*L1, *BB1->getTerminator(), LoadAddress,
LoadSize))
@@ -225,6 +239,74 @@
// and the second load instruction...
//
if (AA.canInstructionRangeModify(BB2->front(), *L2, LoadAddress, LoadSize))
+ return false; // Cannot eliminate load
+
+ // Do a depth first traversal of the inverse CFG starting at L2's block,
+ // looking for L1's block. The inverse CFG is made up of the predecessor
+ // nodes of a block... so all of the edges in the graph are "backward".
+ //
+ std::set<BasicBlock*> VisitedSet;
+ for (pred_iterator PI = pred_begin(BB2), PE = pred_end(BB2); PI != PE; ++PI)
+ if (CheckForInvalidatingInst(*PI, BB1, LoadAddress, LoadSize, AA,
+ VisitedSet))
+ return false;
+
+ // If we passed all of these checks then we are sure that the two loads
+ // produce the same value.
+ return true;
+ }
+}
+
+
+/// haveEqualValueNumber - Given a load instruction and a store instruction,
+/// determine if the stored value reaches the loaded value unambiguously on
+/// every execution of the program. This uses the AliasAnalysis implementation
+/// to invalidate the stored value when stores or function calls occur that
+/// could modify the value produced by the load.
+///
+bool LoadVN::haveEqualValueNumber(LoadInst *Load, StoreInst *Store,
+ AliasAnalysis &AA,
+ DominatorSet &DomSetInfo) const {
+ // If the store does not dominate the load, we cannot do anything...
+ if (!DomSetInfo.dominates(Store, Load))
+ return false;
+
+ BasicBlock *BB1 = Store->getParent(), *BB2 = Load->getParent();
+ Value *LoadAddress = Load->getOperand(0);
+
+ assert(LoadAddress->getType() == Store->getOperand(1)->getType() &&
+ "How could the same source pointer return different types?");
+
+ // Find out how many bytes of memory are loaded by the load instruction...
+ unsigned LoadSize = getAnalysis<TargetData>().getTypeSize(Load->getType());
+
+ // Compute a basic block iterator pointing to the instruction after the store.
+ BasicBlock::iterator StoreIt = Store; ++StoreIt;
+
+ // Check to see if the intervening instructions between the two store and load
+ // include a store or call...
+ //
+ if (BB1 == BB2) { // In same basic block?
+ // In this degenerate case, no checking of global basic blocks has to occur
+ // just check the instructions BETWEEN Store & Load...
+ //
+ if (AA.canInstructionRangeModify(*StoreIt, *Load, LoadAddress, LoadSize))
+ return false; // Cannot eliminate load
+
+ // No instructions invalidate the stored value, they produce the same value!
+ return true;
+ } else {
+ // Make sure that there are no store instructions between the Store and the
+ // end of its basic block...
+ //
+ if (AA.canInstructionRangeModify(*StoreIt, *BB1->getTerminator(),
+ LoadAddress, LoadSize))
+ return false; // Cannot eliminate load
+
+ // Make sure that there are no store instructions between the start of BB2
+ // and the second load instruction...
+ //
+ if (AA.canInstructionRangeModify(BB2->front(), *Load, LoadAddress,LoadSize))
return false; // Cannot eliminate load
// Do a depth first traversal of the inverse CFG starting at L2's block,
More information about the llvm-commits
mailing list