bug fixes

diff --git a/Robust/src/Analysis/Pointer/Delta.java b/Robust/src/Analysis/Pointer/Delta.java
index a910c2f1e463de7b430f405b25e59160a641e83a..9419412b60ae0047a07dc053414b7862b696a253 100644 (file)
--- a/Robust/src/Analysis/Pointer/Delta.java
+++ b/Robust/src/Analysis/Pointer/Delta.java
@@ -62,6 +62,10 @@ public class Delta {
       varedgeadd.put(tmpMap.get(entry.getKey()), entry.getValue());
     }
     newdelta.varedgeremove=varedgeremove;
+    newdelta.addNodeAges=addNodeAges;
+    newdelta.baseNodeAges=baseNodeAges;
+    newdelta.addOldNodes=addOldNodes;
+    newdelta.baseOldNodes=baseOldNodes;
     newdelta.block=bblock;
     return newdelta;
   }
@@ -73,6 +77,10 @@ public class Delta {
     newdelta.heapedgeadd=heapedgeadd;
     newdelta.heapedgeremove=heapedgeremove;
     newdelta.varedgeadd=varedgeadd;
+    newdelta.addNodeAges=addNodeAges;
+    newdelta.baseNodeAges=baseNodeAges;
+    newdelta.addOldNodes=addOldNodes;
+    newdelta.baseOldNodes=baseOldNodes;
     for(Edge e:edges) {
       if (e.srcvar!=null) {
        if (!newdelta.varedgeadd.containsKey(e.srcvar)) {
@@ -98,6 +106,10 @@ public class Delta {
     newdelta.varedgeadd=varedgeadd;
     newdelta.varedgeremove=varedgeremove;
     newdelta.block=bblock;
+    newdelta.addNodeAges=addNodeAges;
+    newdelta.baseNodeAges=baseNodeAges;
+    newdelta.addOldNodes=addOldNodes;
+    newdelta.baseOldNodes=baseOldNodes;
     return newdelta;
   }
 
@@ -138,23 +150,20 @@ public class Delta {
   public void removeHeapEdge(Edge e) {
     if (heapedgeadd.containsKey(e.src)&&heapedgeadd.get(e.src).contains(e))
       heapedgeadd.get(e.src).remove(e);
-    else {
-      if (!heapedgeremove.containsKey(e.src))
-       heapedgeremove.put(e.src, new MySet<Edge>(e));
-      else
-       heapedgeremove.get(e.src).add(e);
-    }
+    if (!heapedgeremove.containsKey(e.src))
+      heapedgeremove.put(e.src, new MySet<Edge>(e));
+    else
+      heapedgeremove.get(e.src).add(e);
+
   }
 
   public void removeVarEdge(Edge e) {
     if (varedgeadd.containsKey(e.src)&&varedgeadd.get(e.src).contains(e))
       varedgeadd.get(e.src).remove(e);
-    else {
-      if (!varedgeremove.containsKey(e.srcvar))
-       varedgeremove.put(e.srcvar, new MySet<Edge>(e));
-      else
-       varedgeremove.get(e.srcvar).add(e);
-    }
+    if (!varedgeremove.containsKey(e.srcvar))
+      varedgeremove.put(e.srcvar, new MySet<Edge>(e));
+    else
+      varedgeremove.get(e.srcvar).add(e);
   }
 
   public void setInit(boolean init) {

diff --git a/Robust/src/Analysis/Pointer/Edge.java b/Robust/src/Analysis/Pointer/Edge.java
index c4175afcc598bd9537359691633c4bf73aa52f76..fe62bb571fa5962116a6ff2bc7fbbb8bd40e227b 100644 (file)
--- a/Robust/src/Analysis/Pointer/Edge.java
+++ b/Robust/src/Analysis/Pointer/Edge.java
@@ -20,6 +20,10 @@ public class Edge {
     return ((status&NEW)==NEW)?NEW:status;
   }
 
+  public boolean isNew() {
+    return (statuspredicate&NEW)==NEW;
+  }
+
   private Edge() {
   }
 

diff --git a/Robust/src/Analysis/Pointer/Graph.java b/Robust/src/Analysis/Pointer/Graph.java
index 5c98abf2dc91d0812fc212f71f313a274d7bd1e6..55ecd9afd59db416d34b61f21b3eead3aab8963d 100644 (file)
--- a/Robust/src/Analysis/Pointer/Graph.java
+++ b/Robust/src/Analysis/Pointer/Graph.java
@@ -50,12 +50,18 @@ public class Graph {
   public Edge getMatch(Edge old) {
     if (old.srcvar!=null) {
       MySet<Edge> edges=varMap.get(old.srcvar);
+      if (edges==null)
+       edges=parent.varMap.get(old.srcvar);
       return edges.get(old);
     } else {
       MySet<Edge> edges=nodeMap.get(old.src);
+      if (edges==null)
+       edges=parent.nodeMap.get(old.src);
       return edges.get(old);
     }
   }
+  
+  
 
   public MySet<Edge> getEdges(TempDescriptor tmp) {
     if (varMap.containsKey(tmp))
@@ -75,8 +81,8 @@ public class Graph {
 
   public static MySet<Edge> emptySet=new MySet<Edge>();
 
-  public void printGraph(PrintWriter output) {
-    output.println("digraph graph {");
+  public void printGraph(PrintWriter output, String name) {
+    output.println("digraph \""+name+"\" {");
     output.println("\tnode [fontsize=10,height=\"0.1\", width=\"0.1\"];");
     output.println("\tedge [fontsize=6];");
     outputTempEdges(output, varMap, null);
@@ -109,7 +115,10 @@ public class Graph {
        continue;
       for(Edge e:entry.getValue()) {
        AllocNode n=e.dst;
-       output.println("\t"+node.getID()+"->"+n.getID()+"[label=\""+e.fd.getSymbol()+"\";");
+       String src=node.getID();
+       String dst=n.getID();
+       String field=e.fd!=null?e.fd.getSymbol():"[]";
+       output.println("\t"+src+"->"+dst+"[label=\""+field+"\"];");
       }
     }
   }

diff --git a/Robust/src/Analysis/Pointer/MySet.java b/Robust/src/Analysis/Pointer/MySet.java
index 32b1bef40fe241499b12d5368964278ef682e197..7e1400b9b5dfde0e85dc8581f4ae75f2f14680c0 100644 (file)
--- a/Robust/src/Analysis/Pointer/MySet.java
+++ b/Robust/src/Analysis/Pointer/MySet.java
@@ -14,7 +14,8 @@ public class MySet<T> extends AbstractSet<T> {
 
   public MySet(MySet base) {
     map=new HashMap<T,T>();
-    addAll(base);
+    if (base!=null)
+      addAll(base);
   }
 
   public int size() {

diff --git a/Robust/src/Analysis/Pointer/Pointer.java b/Robust/src/Analysis/Pointer/Pointer.java
index e7b4bede27401dfd61f6085e65b65ab4dde2a4f8..4afeae91e9b977f58265ef40d07775caedb85c88 100644 (file)
--- a/Robust/src/Analysis/Pointer/Pointer.java
+++ b/Robust/src/Analysis/Pointer/Pointer.java
@@ -4,6 +4,7 @@ import IR.Flat.*;
 import IR.*;
 import Analysis.Pointer.BasicBlock.BBlock;
 import Analysis.Pointer.AllocFactory.AllocNode;
+import java.io.*;
 
 public class Pointer {
   HashMap<FlatMethod, BasicBlock> blockMap;
@@ -84,6 +85,34 @@ public class Pointer {
       }
       generateFinalDelta(bblock, delta, nodeGraph);
     }
+
+    //DEBUG
+    int debugindex=0;
+    for(Map.Entry<BBlock, Graph> e:bbgraphMap.entrySet()) {
+      Graph g=e.getValue();
+      try {
+       PrintWriter pw=new PrintWriter(new FileWriter("BB"+debugindex+".dot"));
+       g.printGraph(pw, "BB");
+       pw.close();
+      } catch (Exception ex) {
+       ex.printStackTrace();
+      }
+      debugindex++;
+    }
+
+    for(Map.Entry<FlatNode, Graph> e:graphMap.entrySet()) {
+      FlatNode fn=e.getKey();
+      Graph g=e.getValue();
+      try {
+       PrintWriter pw=new PrintWriter(new FileWriter("FN"+fn.toString().replace(' ','_')+".dot"));
+       g.printGraph(pw, fn.toString());
+       pw.close();
+      } catch (Exception ex) {
+       ex.printStackTrace();
+      }
+      debugindex++;
+    }
+
   }
 
   /* This function builds the last delta for a basic block.  It
@@ -170,17 +199,22 @@ public class Pointer {
        /* Start with the new incoming edges */
        MySet<Edge> newheapedge=(MySet<Edge>) delta.baseheapedge.get(node).clone();
        /* Remove the remove set */
-       newheapedge.removeAll(delta.heapedgeremove.get(node));
+       MySet<Edge> removeset=delta.heapedgeremove.get(node);
+
+       if (removeset!=null)
+         newheapedge.removeAll(removeset);
+
        /* Add in the add set */
-       newheapedge.addAll(delta.heapedgeadd.get(node));
+       MySet<Edge> settoadd=delta.heapedgeadd.get(node);
+       if (settoadd!=null)
+         newheapedge.addAll(settoadd);
        newDelta.heapedgeadd.put(node, newheapedge);
 
-       /* Also need to subtract off some edges */
-       MySet<Edge> removeset=delta.heapedgeremove.get(node);
-
        /* Remove the newly created edges..no need to propagate a diff for those */
-       removeset.removeAll(delta.baseheapedge.get(node));
-       newDelta.heapedgeremove.put(node, removeset);
+       if (removeset!=null) {
+         removeset.removeAll(delta.baseheapedge.get(node));
+         newDelta.heapedgeremove.put(node, removeset);
+       }
       }
 
       /* Compute new ages */
@@ -572,7 +606,7 @@ public class Pointer {
       bbgraphMap.get(bblock):
       graphMap.get(nodes.get(ppoint.getIndex()-1));
     
-    //Age outside edges if necessary
+    //Age outside nodes if necessary
     for(Iterator<AllocNode> nodeit=delta.addNodeAges.iterator();nodeit.hasNext();) {
       AllocNode node=nodeit.next();
       if (!graph.callNodeAges.contains(node)) {
@@ -603,14 +637,7 @@ public class Pointer {
            edgetoadd=origEdgeKey;
          }
        }
-       if (edgetoadd!=null) {
-         Edge match=graph.getMatch(edgetoadd);
-         if (match==null||!match.subsumes(edgetoadd)) {
-           Edge mergededge=edgetoadd.merge(match);
-           //XXXXXXXXXXXXX;
-           newDelta.addHeapEdge(mergededge);
-         }
-       }
+       mergeEdge(graph, newDelta, edgetoadd);
       }
     }
 
@@ -627,19 +654,42 @@ public class Pointer {
        if (graph.callOldNodes.contains(e.dst)) {
          //Need two edges
          Edge copy=newedge.copy();
-         newDelta.addEdge(copy);
+         mergeEdge(graph, newDelta, copy);
        }
        //Now add summarized node
        newedge.dst=allocFactory.getAllocNode(newedge.dst, true);
-       newDelta.addEdge(newedge);
+       mergeEdge(graph, newDelta, newedge);
       } else {
        //Add edge to single node
-       newDelta.addEdge(newedge);
+       mergeEdge(graph, newDelta, newedge);
+      }
+    }
+    //Add edge for return value
+    if (fcall.getReturnTemp()!=null) {
+      MySet<Edge> returnedge=newDelta.varedgeadd.get(returntmp);
+      for(Edge e:returnedge) {
+       Edge newedge=e.copy();
+       newedge.srcvar=fcall.getReturnTemp();
+       if (graph.getEdges(fcall.getReturnTemp())==null||!graph.getEdges(fcall.getReturnTemp()).contains(newedge))
+         newDelta.addEdge(newedge);
       }
     }
 
+    applyDiffs(graph, newDelta);
     return newDelta;
   }
+  
+  public void mergeEdge(Graph graph, Delta newDelta, Edge edgetoadd) {
+    if (edgetoadd!=null) {
+      Edge match=graph.getMatch(edgetoadd);
+
+      if (match==null||!match.subsumes(edgetoadd)) {
+       Edge mergededge=edgetoadd.merge(match);
+       newDelta.addHeapEdge(mergededge);
+      }
+    }
+  }
+
 
   /* Summarizes out of context nodes in graph */
   void summarizeInGraph(Graph graph, Delta newDelta, AllocNode singleNode) {
@@ -652,7 +702,7 @@ public class Pointer {
       Edge rewrite=e.rewrite(singleNode, summaryNode);
       //Remove old edge
       newDelta.removeHeapEdge(e);
-      newDelta.addHeapEdge(rewrite);
+      mergeEdge(graph, newDelta, rewrite);
     }
     
     //Handle incoming edges
@@ -663,7 +713,7 @@ public class Pointer {
        Edge match=graph.getMatch(e);
        Edge rewrite=match.rewrite(singleNode, summaryNode);
        newDelta.removeEdge(match);
-       newDelta.addEdge(rewrite);
+       mergeEdge(graph, newDelta, rewrite);
       }
     }
   }
@@ -727,7 +777,10 @@ public class Pointer {
       //If we have not done a subtract, then 
       if (!graph.nodeMap.containsKey(node)) {
        //Copy the parent entry
-       graph.nodeMap.put(node, (MySet<Edge>)graph.parent.nodeMap.get(node).clone());
+       if (graph.parent.nodeMap.containsKey(node))
+         graph.nodeMap.put(node, (MySet<Edge>)graph.parent.nodeMap.get(node).clone());
+       else
+         graph.nodeMap.put(node, new MySet<Edge>());
       }
       graph.nodeMap.get(node).addAll(edgestoadd);
       if (genbackwards) {
@@ -747,7 +800,7 @@ public class Pointer {
       if (graph.varMap.containsKey(tmp)) {
        //Just apply diff to current map
        graph.varMap.get(tmp).removeAll(edgestoremove);
-      } else {
+      } else if (graph.parent.varMap.containsKey(tmp)) {
        //Generate diff from parent graph
        MySet<Edge> parentedges=graph.parent.varMap.get(tmp);
        MySet<Edge> newedgeset=Util.setSubtract(parentedges, edgestoremove);
@@ -801,9 +854,9 @@ public class Pointer {
       HashSet<AllocNode> dstNodes=GraphManip.getNodes(graph, delta, dst);
       MySet<Edge> edgesToAdd=GraphManip.genEdges(srcNodes, fd, dstNodes);
       MySet<Edge> edgesToRemove=null;
-      if (dstNodes.size()==1&&!dstNodes.iterator().next().isSummary()) {
+      if (srcNodes.size()==1&&!srcNodes.iterator().next().isSummary()) {
        /* Can do a strong update */
-       edgesToRemove=GraphManip.getEdges(graph, delta, dstNodes, fd);
+       edgesToRemove=GraphManip.getEdges(graph, delta, srcNodes, fd);
       }
       /* Update diff */
       updateHeapDelta(graph, delta, edgesToAdd, edgesToRemove);
@@ -812,23 +865,28 @@ public class Pointer {
       /* First look at new sources */
       MySet<Edge> edgesToAdd=new MySet<Edge>();
       HashSet<AllocNode> newSrcNodes=GraphManip.getDiffNodes(delta, src);
-      HashSet<AllocNode> dstNodes=GraphManip.getDiffNodes(delta, dst);
-      edgesToAdd.addAll(GraphManip.genEdges(newSrcNodes, fd, dstNodes));
+      HashSet<AllocNode> srcNodes=GraphManip.getNodes(graph, delta, src);
+      HashSet<AllocNode> dstNodes=GraphManip.getNodes(graph, delta, dst);
       HashSet<AllocNode> newDstNodes=GraphManip.getDiffNodes(delta, dst);
+
+
       MySet<Edge> edgesToRemove=null;
-      if (newDstNodes.size()!=0) {
-       if (dstNodes.size()==1&&!dstNodes.iterator().next().isSummary()) {
+      if (newSrcNodes.size()!=0) {
+       if (srcNodes.size()==1&&!srcNodes.iterator().next().isSummary()) {
          /* Need to undo strong update */
          if (graph.strongUpdateSet!=null) {
            edgesToAdd.addAll(graph.strongUpdateSet);
            graph.strongUpdateSet.clear();
          }
-       } else if (dstNodes.size()==0&&newDstNodes.size()==1&&!newDstNodes.iterator().next().isSummary()&&graph.strongUpdateSet==null) {
-         edgesToRemove=GraphManip.getEdges(graph, delta, dstNodes, fd);
+       } else if (srcNodes.size()==0&&newSrcNodes.size()==1&&!newSrcNodes.iterator().next().isSummary()&&graph.strongUpdateSet==null) {
+         edgesToRemove=GraphManip.getEdges(graph, delta, srcNodes, fd);
        }
-       HashSet<AllocNode> srcNodes=GraphManip.getDiffNodes(delta, src);
-       edgesToAdd.addAll(GraphManip.genEdges(srcNodes, fd, newDstNodes));
+       edgesToAdd.addAll(GraphManip.genEdges(newSrcNodes, fd, dstNodes));
       }
+
+      //Next look at new destinations
+      edgesToAdd.addAll(GraphManip.genEdges(srcNodes, fd, newDstNodes));
+
       /* Update diff */
       updateHeapDelta(graph, delta, edgesToAdd, edgesToRemove);
       applyDiffs(graph, delta);
@@ -847,6 +905,11 @@ public class Pointer {
       FlatReturnNode frn=(FlatReturnNode)node;
       src=frn.getReturnTemp();
       dst=returntmp;
+      if (src==null) {
+       //This is a NOP
+       applyDiffs(graph, delta);
+       return delta;
+      }
     } else {
       FlatCastNode fcn=(FlatCastNode) node;
       src=fcn.getSrc();
@@ -926,45 +989,48 @@ public class Pointer {
     MySet<Edge> existingEdges=graph.getEdges(tmp);
     for(Edge e: edgestoRemove) {
       //remove edge from delta
-      edgeAdd.remove(e);
+      if (edgeAdd!=null)
+       edgeAdd.remove(e);
       //if the edge is already in the graph, add an explicit remove to the delta
       if (existingEdges.contains(e))
-       edgeRemove.add(e);
+       delta.removeVarEdge(e);
     }
     for(Edge e: edgestoAdd) {
       //Remove the edge from the remove set
-      edgeRemove.remove(e);
+      if (edgeRemove!=null)
+       edgeRemove.remove(e);
       //Explicitly add it to the add set unless it is already in the graph
       if (!existingEdges.contains(e))
-       edgeAdd.add(e);
+       delta.addVarEdge(e);
     }
   }
 
   static void updateHeapDelta(Graph graph, Delta delta, MySet<Edge> edgestoAdd, MySet<Edge> edgestoRemove) {
-    for(Edge e: edgestoRemove) {
-      AllocNode src=e.src;
-      MySet<Edge> edgeAdd=delta.heapedgeadd.get(src);
-      MySet<Edge> existingEdges=graph.getEdges(src);
-      //remove edge from delta
-      edgeAdd.remove(e);
-      //if the edge is already in the graph, add an explicit remove to the delta
-      if (existingEdges.contains(e)) {
-       MySet<Edge> edgeRemove=delta.heapedgeremove.get(src);
-       edgeRemove.add(e);
-      }
-    }
-    for(Edge e: edgestoAdd) {
-      AllocNode src=e.src;
-      MySet<Edge> edgeRemove=delta.heapedgeremove.get(src);
-      MySet<Edge> existingEdges=graph.getEdges(src);
-      //Remove the edge from the remove set
-      edgeRemove.remove(e);
-      //Explicitly add it to the add set unless it is already in the graph
-      if (!existingEdges.contains(e)) {
+    if (edgestoRemove!=null)
+      for(Edge e: edgestoRemove) {
+       AllocNode src=e.src;
        MySet<Edge> edgeAdd=delta.heapedgeadd.get(src);
-       edgeAdd.add(e);
+       MySet<Edge> existingEdges=graph.getEdges(src);
+       //remove edge from delta
+       edgeAdd.remove(e);
+       //if the edge is already in the graph, add an explicit remove to the delta
+       if (existingEdges.contains(e)) {
+         delta.removeHeapEdge(e);
+       }
+      }
+    if (edgestoAdd!=null)
+      for(Edge e: edgestoAdd) {
+       AllocNode src=e.src;
+       MySet<Edge> edgeRemove=delta.heapedgeremove.get(src);
+       MySet<Edge> existingEdges=graph.getEdges(src);
+       //Remove the edge from the remove set
+       if (edgeRemove!=null)
+         edgeRemove.remove(e);
+       //Explicitly add it to the add set unless it is already in the graph
+       if (!existingEdges.contains(e)||!existingEdges.get(e).isNew()) {
+         delta.addHeapEdge(e);
+       }
       }
-    }
   }
 
   Delta processFlatNop(FlatNode node, Delta delta, Graph graph) {