Use SmallVector.

[oota-llvm.git] / lib / Analysis / LoadValueNumbering.cpp

diff --git a/lib/Analysis/LoadValueNumbering.cpp b/lib/Analysis/LoadValueNumbering.cpp
index 3fbf23806ce60fcb17796f87e06d5de1534ec089..f1ade951f34b79e5f9e93dd276a340ef9a12a357 100644 (file)
--- a/lib/Analysis/LoadValueNumbering.cpp
+++ b/lib/Analysis/LoadValueNumbering.cpp
@@ -31,6 +31,7 @@
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Target/TargetData.h"
 #include <set>
 #include <algorithm>
@@ -38,7 +39,9 @@ using namespace llvm;
 
 namespace {
   // FIXME: This should not be a FunctionPass.
-  struct LoadVN : public FunctionPass, public ValueNumbering {
+  struct VISIBILITY_HIDDEN LoadVN : public FunctionPass, public ValueNumbering {
+    static char ID; // Class identification, replacement for typeinfo
+    LoadVN() : FunctionPass((intptr_t)&ID) {}
 
     /// Pass Implementation stuff.  This doesn't do any analysis.
     ///
@@ -80,6 +83,7 @@ namespace {
                                  std::vector<Value*> &RetVals) const;
   };
 
+  char LoadVN::ID = 0;
   // Register this pass...
   RegisterPass<LoadVN> X("load-vn", "Load Value Numbering");
 
@@ -97,7 +101,7 @@ void LoadVN::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequiredTransitive<AliasAnalysis>();
   AU.addRequired<ValueNumbering>();
-  AU.addRequiredTransitive<DominatorSet>();
+  AU.addRequiredTransitive<DominatorTree>();
   AU.addRequiredTransitive<TargetData>();
 }
 
@@ -197,20 +201,20 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI,
   // ANY memory.
   //
   if (MRB == AliasAnalysis::OnlyReadsMemory) {
-    DominatorSet &DomSetInfo = getAnalysis<DominatorSet>();
+    DominatorTree &DT = getAnalysis<DominatorTree>();
     BasicBlock *CIBB = CI->getParent();
     for (unsigned i = 0; i != IdenticalCalls.size(); ++i) {
       CallInst *C = IdenticalCalls[i];
       bool CantEqual = false;
 
-      if (DomSetInfo.dominates(CIBB, C->getParent())) {
+      if (DT.dominates(CIBB, C->getParent())) {
         // FIXME: we currently only handle the case where both calls are in the
         // same basic block.
         if (CIBB != C->getParent()) {
           CantEqual = true;
         } else {
           Instruction *First = CI, *Second = C;
-          if (!DomSetInfo.dominates(CI, C))
+          if (!DT.dominates(CI, C))
             std::swap(First, Second);
 
           // Scan the instructions between the calls, checking for stores or
@@ -235,7 +239,7 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI,
           }
         }
 
-      } else if (DomSetInfo.dominates(C->getParent(), CIBB)) {
+      } else if (DT.dominates(C->getParent(), CIBB)) {
         // FIXME: We could implement this, but we don't for now.
         CantEqual = true;
       } else {
@@ -335,15 +339,18 @@ void LoadVN::getEqualNumberNodes(Value *V,
   // we see any candidate loads, then we know they have the same value # as LI.
   //
   bool LoadInvalidatedInBBAfter = false;
-  for (BasicBlock::iterator I = LI->getNext(); I != LoadBB->end(); ++I) {
-    // If this instruction is a load, then this instruction returns the same
-    // value as LI.
-    if (isa<LoadInst>(I) && cast<LoadInst>(I)->getOperand(0) == LoadPtr)
-      RetVals.push_back(I);
+  {
+    BasicBlock::iterator I = LI;
+    for (++I; I != LoadBB->end(); ++I) {
+      // If this instruction is a load, then this instruction returns the same
+      // value as LI.
+      if (isa<LoadInst>(I) && cast<LoadInst>(I)->getOperand(0) == LoadPtr)
+        RetVals.push_back(I);
 
-    if (AA.getModRefInfo(I, LoadPtr, LoadSize) & AliasAnalysis::Mod) {
-      LoadInvalidatedInBBAfter = true;
-      break;
+      if (AA.getModRefInfo(I, LoadPtr, LoadSize) & AliasAnalysis::Mod) {
+        LoadInvalidatedInBBAfter = true;
+        break;
+      }
     }
   }
 
@@ -373,7 +380,7 @@ void LoadVN::getEqualNumberNodes(Value *V,
     }
 
   // Get dominators.
-  DominatorSet &DomSetInfo = getAnalysis<DominatorSet>();
+  DominatorTree &DT = getAnalysis<DominatorTree>();
 
   // TransparentBlocks - For each basic block the load/store is alive across,
   // figure out if the pointer is invalidated or not.  If it is invalidated, the
@@ -392,12 +399,12 @@ void LoadVN::getEqualNumberNodes(Value *V,
     // Right now we only can handle cases where one load dominates the other.
     // FIXME: generalize this!
     BasicBlock *BB1 = I->first, *BB2 = LoadBB;
-    if (DomSetInfo.dominates(BB1, BB2)) {
+    if (DT.dominates(BB1, BB2)) {
       // The other load dominates LI.  If the loaded value is killed entering
       // the LoadBB block, we know the load is not live.
       if (LoadInvalidatedInBBBefore)
         CantEqual = true;
-    } else if (DomSetInfo.dominates(BB2, BB1)) {
+    } else if (DT.dominates(BB2, BB1)) {
       std::swap(BB1, BB2);          // Canonicalize
       // LI dominates the other load.  If the loaded value is killed exiting
       // the LoadBB block, we know the load is not live.
@@ -479,7 +486,7 @@ void LoadVN::getEqualNumberNodes(Value *V,
 
   for (std::set<BasicBlock*>::iterator I = CandidateStores.begin(),
          E = CandidateStores.end(); I != E; ++I)
-    if (DomSetInfo.dominates(*I, LoadBB)) {
+    if (DT.dominates(*I, LoadBB)) {
       BasicBlock *StoreBB = *I;
 
       // Check to see if the path from the store to the load is transparent