From: bdemsky Date: Thu, 10 Mar 2011 02:10:12 +0000 (+0000) Subject: bug fixes X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=a1e5bc4b65830a36a31ff856e049d90106a5835b;p=IRC.git bug fixes --- diff --git a/Robust/src/Analysis/Pointer/Delta.java b/Robust/src/Analysis/Pointer/Delta.java index a910c2f1..9419412b 100644 --- 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(e)); - else - heapedgeremove.get(e.src).add(e); - } + if (!heapedgeremove.containsKey(e.src)) + heapedgeremove.put(e.src, new MySet(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(e)); - else - varedgeremove.get(e.srcvar).add(e); - } + if (!varedgeremove.containsKey(e.srcvar)) + varedgeremove.put(e.srcvar, new MySet(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 c4175afc..fe62bb57 100644 --- 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 5c98abf2..55ecd9af 100644 --- 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 edges=varMap.get(old.srcvar); + if (edges==null) + edges=parent.varMap.get(old.srcvar); return edges.get(old); } else { MySet edges=nodeMap.get(old.src); + if (edges==null) + edges=parent.nodeMap.get(old.src); return edges.get(old); } } + + public MySet getEdges(TempDescriptor tmp) { if (varMap.containsKey(tmp)) @@ -75,8 +81,8 @@ public class Graph { public static MySet emptySet=new MySet(); - 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 32b1bef4..7e1400b9 100644 --- a/Robust/src/Analysis/Pointer/MySet.java +++ b/Robust/src/Analysis/Pointer/MySet.java @@ -14,7 +14,8 @@ public class MySet extends AbstractSet { public MySet(MySet base) { map=new HashMap(); - 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 e7b4bede..4afeae91 100644 --- 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 blockMap; @@ -84,6 +85,34 @@ public class Pointer { } generateFinalDelta(bblock, delta, nodeGraph); } + + //DEBUG + int debugindex=0; + for(Map.Entry 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 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 newheapedge=(MySet) delta.baseheapedge.get(node).clone(); /* Remove the remove set */ - newheapedge.removeAll(delta.heapedgeremove.get(node)); + MySet removeset=delta.heapedgeremove.get(node); + + if (removeset!=null) + newheapedge.removeAll(removeset); + /* Add in the add set */ - newheapedge.addAll(delta.heapedgeadd.get(node)); + MySet settoadd=delta.heapedgeadd.get(node); + if (settoadd!=null) + newheapedge.addAll(settoadd); newDelta.heapedgeadd.put(node, newheapedge); - /* Also need to subtract off some edges */ - MySet 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 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 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)graph.parent.nodeMap.get(node).clone()); + if (graph.parent.nodeMap.containsKey(node)) + graph.nodeMap.put(node, (MySet)graph.parent.nodeMap.get(node).clone()); + else + graph.nodeMap.put(node, new MySet()); } 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 parentedges=graph.parent.varMap.get(tmp); MySet newedgeset=Util.setSubtract(parentedges, edgestoremove); @@ -801,9 +854,9 @@ public class Pointer { HashSet dstNodes=GraphManip.getNodes(graph, delta, dst); MySet edgesToAdd=GraphManip.genEdges(srcNodes, fd, dstNodes); MySet 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 edgesToAdd=new MySet(); HashSet newSrcNodes=GraphManip.getDiffNodes(delta, src); - HashSet dstNodes=GraphManip.getDiffNodes(delta, dst); - edgesToAdd.addAll(GraphManip.genEdges(newSrcNodes, fd, dstNodes)); + HashSet srcNodes=GraphManip.getNodes(graph, delta, src); + HashSet dstNodes=GraphManip.getNodes(graph, delta, dst); HashSet newDstNodes=GraphManip.getDiffNodes(delta, dst); + + MySet 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 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 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 edgestoAdd, MySet edgestoRemove) { - for(Edge e: edgestoRemove) { - AllocNode src=e.src; - MySet edgeAdd=delta.heapedgeadd.get(src); - MySet 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 edgeRemove=delta.heapedgeremove.get(src); - edgeRemove.add(e); - } - } - for(Edge e: edgestoAdd) { - AllocNode src=e.src; - MySet edgeRemove=delta.heapedgeremove.get(src); - MySet 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 edgeAdd=delta.heapedgeadd.get(src); - edgeAdd.add(e); + MySet 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 edgeRemove=delta.heapedgeremove.get(src); + MySet 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) {