loop analysis stuff

[IRC.git] / Robust / src / Analysis / Loops / DomTree.java

diff --git a/Robust/src/Analysis/Loops/DomTree.java b/Robust/src/Analysis/Loops/DomTree.java
index aef079de624ea5d56a31e02170d128e5b9d7f1c5..758876ac7504993efadb28194bbafbe1c032cafe 100644 (file)
--- a/Robust/src/Analysis/Loops/DomTree.java
+++ b/Robust/src/Analysis/Loops/DomTree.java
@@ -1,10 +1,12 @@
 package Analysis.Loops;
+import java.util.Iterator;
 import java.util.Set;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Vector;
 import java.util.Stack;
 import IR.Flat.FlatNode;
+import IR.Flat.FlatMethod;
 
 public class DomTree {
   Hashtable<FlatNode, FlatNode> domtable;
@@ -12,8 +14,8 @@ public class DomTree {
   Hashtable<FlatNode,Integer> vecindex;
   Hashtable<FlatNode, Set<FlatNode>> childtree;
 
-  public DomTree(FlatMethod fm) {
-    analyze(fm);
+  public DomTree(FlatMethod fm, boolean postdominator) {
+    analyze(fm, postdominator);
   }
 
   public FlatNode idom(FlatNode fn) {
@@ -21,16 +23,35 @@ public class DomTree {
   }
 
   public Set<FlatNode> children(FlatNode fn) {
-    return childtree(fn);
+    return childtree.get(fn);
   }
 
-  public void analyze(FlatMethod fm) {
-    DFS(fm);
+  public void analyze(FlatMethod fm, boolean postdominator) {
     domtable=new Hashtable<FlatNode, FlatNode>();
-    domtable.put(fm,fm);
-    HashSet<FlatNode> set=new HashSet<FlatNode> ();
-    set.add(fm);
-    childtree.put(fm,set);
+    if (postdominator) {
+      Set<FlatNode> fnodes=fm.getNodeSet();
+      Vector<FlatNode> v=new Vector<FlatNode>();
+      for(Iterator<FlatNode> fit=fnodes.iterator();fit.hasNext();) {
+       FlatNode fn=fit.next();
+       if (fn.numNext()==0)
+         v.add(fn);
+      }
+      FlatNode[] fnarray=new FlatNode[v.size()];
+      for(int i=0;i<v.size();i++) {
+       fnarray[i]=v.elementAt(i);
+       domtable.put(fnarray[i],fnarray[i]);
+       HashSet<FlatNode> set=new HashSet<FlatNode> ();
+       set.add(fnarray[i]);
+       childtree.put(fnarray[i],set);
+      }
+      DFS(fnarray, postdominator);
+    } else {
+      DFS(new FlatNode[] {fm}, postdominator);
+      HashSet<FlatNode> set=new HashSet<FlatNode> ();
+      domtable.put(fm,fm);
+      set.add(fm);
+      childtree.put(fm,set);
+    }
 
     boolean changed=true;
     while(changed) {
@@ -38,13 +59,13 @@ public class DomTree {
       for(int i=vec.size()-2;i>=0;i--) {
        FlatNode fn=vec.elementAt(i);
        FlatNode dom=null;
-       for(int j=0;j<fn.numPrev();j++) {
-         FlatNode ndom=domtable.get(fn.getPrev(i));
+       for(int j=0;j<(postdominator?fn.numNext():fn.numPrev());j++) {
+         FlatNode ndom=domtable.get(postdominator?fn.getNext(i):fn.getPrev(i));
          dom=intersect(dom,ndom);
        }
        if (!domtable.containsKey(fn)||
-           !domtable.get(fn).equals(ndom)) {
-         domtree.put(fn,dom);
+           !domtable.get(fn).equals(dom)) {
+         domtable.put(fn,dom);
          if (!childtree.containsKey(dom))
            childtree.put(dom, new HashSet<FlatNode>());
          childtree.get(dom).add(fn);
@@ -71,18 +92,20 @@ public class DomTree {
   }
 
 
-  public void DFS(FlatMethod fm) {
+  public void DFS(FlatNode[] fm, boolean postdominator) {
     vec=new Vector<FlatNode>();
     vecindex=new Hashtable<FlatNode,Integer>();
     HashSet visited=new HashSet();
     Stack<FlatNode> stack=new Stack<FlatNode>();
-    stack.push(fm);
-    visited.add(next);
+    for(int i=0;i<fm.length;i++) {
+      stack.push(fm[i]);
+      visited.add(fm[i]);
+    }
     mainloop:
     while(!stack.isEmpty()) {
       FlatNode fn=stack.peek();
-      for(int i=0;i<fn.numNext();i++) {
-       FlatNode next=fn.getNext(i);
+      for(int i=0;i<(postdominator?fn.numPrev():fn.numNext());i++) {
+       FlatNode next=postdominator?fn.getPrev(i):fn.getNext(i);
        if (!visited.contains(next)) {
          visited.add(next);
          stack.push(next);
@@ -95,6 +118,4 @@ public class DomTree {
       stack.pop();
     }
   }
-
-
 }
\ No newline at end of file