changes for 64bit gcc

[oota-llvm.git] / lib / VMCore / Dominators.cpp

diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index a1260835799363a444e03af6655931071ce4a3b8..caff1f1db3048f5b7b04d678a3b6fe0210585e94 100644 (file)
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -6,8 +6,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/Dominators.h"
-#include "llvm/Transforms/UnifyFunctionExitNodes.h"
-#include "llvm/Function.h"
+#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
 #include "llvm/Support/CFG.h"
 #include "Support/DepthFirstIterator.h"
 #include "Support/STLExtras.h"
@@ -19,10 +18,10 @@ using std::set;
 //  DominatorSet Implementation
 //===----------------------------------------------------------------------===//
 
-AnalysisID cfg::DominatorSet::ID(AnalysisID::create<cfg::DominatorSet>());
-AnalysisID cfg::DominatorSet::PostDomID(AnalysisID::create<cfg::DominatorSet>());
+AnalysisID DominatorSet::ID(AnalysisID::create<DominatorSet>(), true);
+AnalysisID DominatorSet::PostDomID(AnalysisID::create<DominatorSet>(), true);
 
-bool cfg::DominatorSet::runOnFunction(Function *F) {
+bool DominatorSet::runOnFunction(Function &F) {
   Doms.clear();   // Reset from the last time we were run...
 
   if (isPostDominator())
@@ -32,12 +31,26 @@ bool cfg::DominatorSet::runOnFunction(Function *F) {
   return false;
 }
 
+// dominates - Return true if A dominates B.  This performs the special checks
+// neccesary if A and B are in the same basic block.
+//
+bool DominatorSet::dominates(Instruction *A, Instruction *B) const {
+  BasicBlock *BBA = A->getParent(), *BBB = B->getParent();
+  if (BBA != BBB) return dominates(BBA, BBB);
+  
+  // Loop through the basic block until we find A or B.
+  BasicBlock::iterator I = BBA->begin();
+  for (; &*I != A && &*I != B; ++I) /*empty*/;
+  
+  // A dominates B if it is found first in the basic block...
+  return &*I == A;
+}
 
 // calcForwardDominatorSet - This method calculates the forward dominator sets
 // for the specified function.
 //
-void cfg::DominatorSet::calcForwardDominatorSet(Function *M) {
-  Root = M->getEntryNode();
+void DominatorSet::calcForwardDominatorSet(Function &F) {
+  Root = &F.getEntryNode();
   assert(pred_begin(Root) == pred_end(Root) &&
         "Root node has predecessors in function!");
 
@@ -46,7 +59,7 @@ void cfg::DominatorSet::calcForwardDominatorSet(Function *M) {
     Changed = false;
 
     DomSetType WorkingSet;
-    df_iterator<Function*> It = df_begin(M), End = df_end(M);
+    df_iterator<Function*> It = df_begin(&F), End = df_end(&F);
     for ( ; It != End; ++It) {
       BasicBlock *BB = *It;
       pred_iterator PI = pred_begin(BB), PEnd = pred_end(BB);
@@ -80,7 +93,7 @@ void cfg::DominatorSet::calcForwardDominatorSet(Function *M) {
 // only have a single exit node (return stmt), then calculates the post
 // dominance sets for the function.
 //
-void cfg::DominatorSet::calcPostDominatorSet(Function *F) {
+void DominatorSet::calcPostDominatorSet(Function &F) {
   // Since we require that the unify all exit nodes pass has been run, we know
   // that there can be at most one return instruction in the function left.
   // Get it.
@@ -88,8 +101,8 @@ void cfg::DominatorSet::calcPostDominatorSet(Function *F) {
   Root = getAnalysis<UnifyFunctionExitNodes>().getExitNode();
 
   if (Root == 0) {  // No exit node for the function?  Postdomsets are all empty
-    for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
-      Doms[*FI] = DomSetType();
+    for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI)
+      Doms[FI] = DomSetType();
     return;
   }
 
@@ -132,7 +145,7 @@ void cfg::DominatorSet::calcPostDominatorSet(Function *F) {
 // getAnalysisUsage - This obviously provides a dominator set, but it also
 // uses the UnifyFunctionExitNodes pass if building post-dominators
 //
-void cfg::DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const {
+void DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   if (isPostDominator()) {
     AU.addProvided(PostDomID);
@@ -147,12 +160,12 @@ void cfg::DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const {
 //  ImmediateDominators Implementation
 //===----------------------------------------------------------------------===//
 
-AnalysisID cfg::ImmediateDominators::ID(AnalysisID::create<cfg::ImmediateDominators>());
-AnalysisID cfg::ImmediateDominators::PostDomID(AnalysisID::create<cfg::ImmediateDominators>());
+AnalysisID ImmediateDominators::ID(AnalysisID::create<ImmediateDominators>(), true);
+AnalysisID ImmediateDominators::PostDomID(AnalysisID::create<ImmediateDominators>(), true);
 
 // calcIDoms - Calculate the immediate dominator mapping, given a set of
 // dominators for every basic block.
-void cfg::ImmediateDominators::calcIDoms(const DominatorSet &DS) {
+void ImmediateDominators::calcIDoms(const DominatorSet &DS) {
   // Loop over all of the nodes that have dominators... figuring out the IDOM
   // for each node...
   //
@@ -191,12 +204,12 @@ void cfg::ImmediateDominators::calcIDoms(const DominatorSet &DS) {
 //  DominatorTree Implementation
 //===----------------------------------------------------------------------===//
 
-AnalysisID cfg::DominatorTree::ID(AnalysisID::create<cfg::DominatorTree>());
-AnalysisID cfg::DominatorTree::PostDomID(AnalysisID::create<cfg::DominatorTree>());
+AnalysisID DominatorTree::ID(AnalysisID::create<DominatorTree>(), true);
+AnalysisID DominatorTree::PostDomID(AnalysisID::create<DominatorTree>(), true);
 
 // DominatorTree::reset - Free all of the tree node memory.
 //
-void cfg::DominatorTree::reset() { 
+void DominatorTree::reset() { 
   for (NodeMapType::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I)
     delete I->second;
   Nodes.clear();
@@ -205,7 +218,7 @@ void cfg::DominatorTree::reset() {
 
 #if 0
 // Given immediate dominators, we can also calculate the dominator tree
-cfg::DominatorTree::DominatorTree(const ImmediateDominators &IDoms) 
+DominatorTree::DominatorTree(const ImmediateDominators &IDoms) 
   : DominatorBase(IDoms.getRoot()) {
   const Function *M = Root->getParent();
 
@@ -230,7 +243,7 @@ cfg::DominatorTree::DominatorTree(const ImmediateDominators &IDoms)
 }
 #endif
 
-void cfg::DominatorTree::calculate(const DominatorSet &DS) {
+void DominatorTree::calculate(const DominatorSet &DS) {
   Nodes[Root] = new Node(Root, 0);   // Add a node for the root...
 
   if (!isPostDominator()) {
@@ -325,12 +338,12 @@ void cfg::DominatorTree::calculate(const DominatorSet &DS) {
 //  DominanceFrontier Implementation
 //===----------------------------------------------------------------------===//
 
-AnalysisID cfg::DominanceFrontier::ID(AnalysisID::create<cfg::DominanceFrontier>());
-AnalysisID cfg::DominanceFrontier::PostDomID(AnalysisID::create<cfg::DominanceFrontier>());
+AnalysisID DominanceFrontier::ID(AnalysisID::create<DominanceFrontier>(), true);
+AnalysisID DominanceFrontier::PostDomID(AnalysisID::create<DominanceFrontier>(), true);
 
-const cfg::DominanceFrontier::DomSetType &
-cfg::DominanceFrontier::calcDomFrontier(const DominatorTree &DT, 
-                                       const DominatorTree::Node *Node) {
+const DominanceFrontier::DomSetType &
+DominanceFrontier::calcDomFrontier(const DominatorTree &DT, 
+                                   const DominatorTree::Node *Node) {
   // Loop over CFG successors to calculate DFlocal[Node]
   BasicBlock *BB = Node->getNode();
   DomSetType &S = Frontiers[BB];       // The new set to fill in...
@@ -361,9 +374,9 @@ cfg::DominanceFrontier::calcDomFrontier(const DominatorTree &DT,
   return S;
 }
 
-const cfg::DominanceFrontier::DomSetType &
-cfg::DominanceFrontier::calcPostDomFrontier(const DominatorTree &DT, 
-                                           const DominatorTree::Node *Node) {
+const DominanceFrontier::DomSetType &
+DominanceFrontier::calcPostDomFrontier(const DominatorTree &DT, 
+                                       const DominatorTree::Node *Node) {
   // Loop over CFG successors to calculate DFlocal[Node]
   BasicBlock *BB = Node->getNode();
   DomSetType &S = Frontiers[BB];       // The new set to fill in...