more changes...do node-based taints...taint edges...change taintset...

diff --git a/Robust/src/Analysis/Disjoint/Taint.java b/Robust/src/Analysis/Disjoint/Taint.java
index a6a38e9adbbdc9ae64ffa7bf8e76ce40d717ec49..44abdb4d9884fe1c77b096f100ebdd75e5eb3c9d 100644 (file)
--- a/Robust/src/Analysis/Disjoint/Taint.java
+++ b/Robust/src/Analysis/Disjoint/Taint.java
@@ -55,7 +55,11 @@ public class Taint extends Canonical {
   // callee to that context
   protected ExistPredSet preds;
 
-
+  public Taint reTaint(FlatNode fn) {
+    Taint out=new Taint(sese, stallSite, var, allocSite, fn, preds);
+    out = (Taint) Canonical.makeCanonical( out );
+    return out;
+  }
 
   public static Taint factory( FlatSESEEnterNode sese,
                                TempDescriptor    insetVar,

diff --git a/Robust/src/Analysis/Disjoint/TaintSet.java b/Robust/src/Analysis/Disjoint/TaintSet.java
index 697ae815aca2022b05414bfaed8000cca8e896af..b0750343e20e4c5499bb04c0cb7c4bc5d1933471 100644 (file)
--- a/Robust/src/Analysis/Disjoint/TaintSet.java
+++ b/Robust/src/Analysis/Disjoint/TaintSet.java
@@ -32,6 +32,26 @@ public class TaintSet extends Canonical {
 
   protected HashSet<Taint> taints;
 
+  public static TaintSet factory(HashSet<Taint> taints) {
+    TaintSet out = new TaintSet(taints);
+    out = (TaintSet) Canonical.makeCanonical( out );
+    return out;
+  }
+
+  public TaintSet reTaint(FlatNode fn) {
+    HashSet<Taint> taintset=new HashSet<Taint>();
+    for(Taint t:taints) {
+      if (t.getWhereDefined()!=fn) {
+       t=t.reTaint(fn);
+      }
+      taintset.add(t);
+    }
+    
+    TaintSet out=new TaintSet(taintset);
+    out = (TaintSet) Canonical.makeCanonical( out );
+    return out;
+  }
+
   public static TaintSet factory() {
     TaintSet out = new TaintSet();
     out = (TaintSet) Canonical.makeCanonical( out );
@@ -88,6 +108,10 @@ public class TaintSet extends Canonical {
     taints = new HashSet<Taint>();
   }
 
+  protected TaintSet(HashSet<Taint> taints) {
+    this.taints = taints;
+  }
+
   public Set<Taint> getTaints() {
     return taints;
   }

diff --git a/Robust/src/Analysis/Pointer/Delta.java b/Robust/src/Analysis/Pointer/Delta.java
index c02cc6c566f807f873564b1e21ac409a380e613c..283161cc247cc5fb7f66aad89ac60859bbcedcac 100644 (file)
--- a/Robust/src/Analysis/Pointer/Delta.java
+++ b/Robust/src/Analysis/Pointer/Delta.java
@@ -189,14 +189,14 @@ public class Delta {
     if (!heapedgeadd.containsKey(e.src))
       heapedgeadd.put(e.src, new MySet<Edge>(e));
     else
-      heapedgeadd.get(e.src).add(e);
+      Edge.mergeEdgeInto(heapedgeadd.get(e.src), e);
   }
 
   public void addVarEdge(Edge e) {
     if (!varedgeadd.containsKey(e.srcvar))
       varedgeadd.put(e.srcvar, new MySet<Edge>(e));
     else
-      varedgeadd.get(e.srcvar).add(e);
+      Edge.mergeEdgeInto(varedgeadd.get(e.srcvar), e);
   }
 
   public void removeEdges(MySet<Edge> eset) {

diff --git a/Robust/src/Analysis/Pointer/Edge.java b/Robust/src/Analysis/Pointer/Edge.java
index 35b7187effdb7f54a1da67489939a1b37af56250..ee5bba80cae6a3296c3dc40902bb17ab8984a3b5 100644 (file)
--- a/Robust/src/Analysis/Pointer/Edge.java
+++ b/Robust/src/Analysis/Pointer/Edge.java
@@ -103,12 +103,27 @@ public class Edge {
     return false;
   }
 
-  public Edge changeSrcVar(TempDescriptor tmp) {
+  public Edge changeSrcVar(TempDescriptor tmp, TaintSet taintset) {
     Edge e=new Edge();
     e.fd=fd;
     e.srcvar=srcvar;
     e.dst=dst;
     e.statuspredicate=NEW;
+    if (taints==null)
+      e.taints=taintset;
+    else if (taintset==null)
+      e.taints=taints;
+    else
+      e.taints=taints.merge(taintset);
+    return e;
+  }
+
+  public Edge changeSrc(FieldDescriptor newfd, AllocNode srcnode) {
+    Edge e=new Edge();
+    e.fd=newfd;
+    e.src=srcnode;
+    e.dst=dst;
+    e.statuspredicate=NEW;
     if (taints!=null)
       e.taints=taints;
     return e;
@@ -202,4 +217,12 @@ public class Edge {
       orig.add(e);
     }
   }
+
+  public static void mergeEdgeInto(MySet<Edge> orig, Edge e) {
+    if (orig.contains(e)) {
+      Edge old=orig.get(e);
+      e=e.merge(old);
+    }
+    orig.add(e);
+  }
 }
\ No newline at end of file

diff --git a/Robust/src/Analysis/Pointer/GraphManip.java b/Robust/src/Analysis/Pointer/GraphManip.java
index 9ee46a88ce88bc9f3d97f452c6dc9a422a35afb5..f025061df51605882a3e73cd77e817e58fbc9a0a 100644 (file)
--- a/Robust/src/Analysis/Pointer/GraphManip.java
+++ b/Robust/src/Analysis/Pointer/GraphManip.java
@@ -3,6 +3,7 @@ import IR.Flat.*;
 import IR.*;
 import Analysis.Pointer.AllocFactory.AllocNode;
 import java.util.*;
+import Analysis.Disjoint.TaintSet;
 
 public class GraphManip {
   static MySet<Edge> genEdges(TempDescriptor tmp, HashSet<AllocNode> dstSet) {
@@ -16,7 +17,7 @@ public class GraphManip {
   static MySet<Edge> genEdges(TempDescriptor tmp, MySet<Edge> dstSet) {
     MySet<Edge> edgeset=new MySet<Edge>();
     for(Edge e:dstSet) {
-      edgeset.add(e.changeSrcVar(tmp));
+      edgeset.add(e.changeSrcVar(tmp, null));
     }
     return edgeset;
   }
@@ -31,6 +32,16 @@ public class GraphManip {
     return edgeset;
   }
 
+  static MySet<Edge> genEdges(HashSet<AllocNode> srcSet, FieldDescriptor fd, MySet<Edge> dstSet) {
+    MySet<Edge> edgeset=new MySet<Edge>();
+    for(AllocNode srcnode:srcSet) {
+      for(Edge dstedge:dstSet) {
+       edgeset.add(dstedge.changeSrc(fd, srcnode));
+      }
+    }
+    return edgeset;
+  }
+
   static MySet<Edge> getDiffEdges(Delta delta, TempDescriptor tmp) {
     MySet<Edge> edges=new MySet<Edge>();
     MySet<Edge> removeedges=delta.varedgeremove.get(tmp);
@@ -208,13 +219,16 @@ public class GraphManip {
     return edgeset;
   }
 
-  static MySet<Edge> dereference(Graph graph, Delta delta, TempDescriptor dst, MySet<Edge> srcEdges, FieldDescriptor fd) {
+  static MySet<Edge> dereference(Graph graph, Delta delta, TempDescriptor dst, MySet<Edge> srcEdges, FieldDescriptor fd, FlatNode fn) {
     MySet<Edge> edgeset=new MySet<Edge>();
     for(Edge edge:srcEdges) {
+      TaintSet ts=edge.getTaints();
+      if (ts!=null)
+         ts=ts.reTaint(fn);
       MySet<Edge> removeedges=delta.heapedgeremove.get(edge.dst);
       for(Edge e:graph.getEdges(edge.dst)) {
        if (e.fd==fd&&(removeedges==null||!removeedges.contains(e))) {
-         e=e.changeSrcVar(dst);
+         e=e.changeSrcVar(dst, ts);
          if (!edgeset.contains(e))
            edgeset.add(e);
          else {
@@ -227,7 +241,7 @@ public class GraphManip {
       if (delta.heapedgeadd.containsKey(edge.dst))
        for(Edge e:delta.heapedgeadd.get(edge.dst)) {
          if (e.fd==fd) {
-           e=e.changeSrcVar(dst);
+           e=e.changeSrcVar(dst, ts);
            if (!edgeset.contains(e))
              edgeset.add(e);
            else {
@@ -241,14 +255,17 @@ public class GraphManip {
     return edgeset;
   }
 
-  static MySet<Edge> diffDereference(Delta delta, TempDescriptor dst, MySet<Edge> srcEdges, FieldDescriptor fd) {
+  static MySet<Edge> diffDereference(Delta delta, TempDescriptor dst, MySet<Edge> srcEdges, FieldDescriptor fd, FlatNode fn) {
     MySet<Edge> edgeset=new MySet<Edge>();
     for(Edge edge:srcEdges) {
+      TaintSet ts=edge.getTaints();
+      if (ts!=null)
+         ts=ts.reTaint(fn);
       MySet<Edge> removeedges=delta.heapedgeremove.get(edge.dst);
       if (delta.baseheapedge.containsKey(edge.dst)) {
        for(Edge e:delta.baseheapedge.get(edge.dst)) {
          if (e.fd==fd&&(removeedges==null||!removeedges.contains(e))) {
-           e=e.changeSrcVar(dst);
+           e=e.changeSrcVar(dst, ts);
            if (!edgeset.contains(e))
              edgeset.add(e);
            else {
@@ -262,7 +279,7 @@ public class GraphManip {
       if (delta.heapedgeadd.containsKey(edge.dst))
        for(Edge e:delta.heapedgeadd.get(edge.dst)) {
          if (e.fd==fd) {
-           e=e.changeSrcVar(dst);
+           e=e.changeSrcVar(dst, ts);
            if (!edgeset.contains(e))
              edgeset.add(e);
            else {

diff --git a/Robust/src/Analysis/Pointer/Pointer.java b/Robust/src/Analysis/Pointer/Pointer.java
index cca1f9781a51853c3ebd1ac57fde6f182067cba5..03d4825c257206384712f3d3d3543473dc066200 100644 (file)
--- a/Robust/src/Analysis/Pointer/Pointer.java
+++ b/Robust/src/Analysis/Pointer/Pointer.java
@@ -1185,7 +1185,7 @@ public class Pointer {
        else
          graph.nodeMap.put(node, new MySet<Edge>());
       }
-      graph.nodeMap.get(node).addAll(edgestoadd);
+      Edge.mergeEdgesInto(graph.nodeMap.get(node),edgestoadd);
       if (genbackwards) {
        for(Edge eadd:edgestoadd) {
          if (!graph.backMap.containsKey(eadd.dst))
@@ -1216,7 +1216,7 @@ public class Pointer {
       TempDescriptor tmp=e.getKey();
       MySet<Edge> edgestoadd=e.getValue();
       if (graph.varMap.containsKey(tmp)) {
-       graph.varMap.get(tmp).addAll(edgestoadd);
+       Edge.mergeEdgesInto(graph.varMap.get(tmp), edgestoadd);
       } else 
        graph.varMap.put(tmp, (MySet<Edge>) edgestoadd.clone());
       if (genbackwards) {
@@ -1260,9 +1260,9 @@ public class Pointer {
       return delta;
 
     if (delta.getInit()) {
-      HashSet<AllocNode> srcNodes=GraphManip.getNodes(graph, delta, src);
+      MySet<Edge> srcEdges=GraphManip.getEdges(graph, delta, src);
       HashSet<AllocNode> dstNodes=GraphManip.getNodes(graph, delta, dst);
-      MySet<Edge> edgesToAdd=GraphManip.genEdges(dstNodes, fd, srcNodes);
+      MySet<Edge> edgesToAdd=GraphManip.genEdges(dstNodes, fd, srcEdges);
       MySet<Edge> edgesToRemove=null;
       if (dstNodes.size()==1&&!dstNodes.iterator().next().isSummary()&&fd!=null) {
        /* Can do a strong update */
@@ -1276,8 +1276,8 @@ public class Pointer {
     } else {
       /* First look at new sources */
       MySet<Edge> edgesToAdd=new MySet<Edge>();
-      HashSet<AllocNode> newSrcNodes=GraphManip.getDiffNodes(delta, src);
-      HashSet<AllocNode> srcNodes=GraphManip.getNodes(graph, delta, src);
+      MySet<Edge> newSrcEdges=GraphManip.getDiffEdges(delta, src);
+      MySet<Edge> srcEdges=GraphManip.getEdges(graph, delta, src);
       HashSet<AllocNode> dstNodes=GraphManip.getNodes(graph, delta, dst);
       HashSet<AllocNode> newDstNodes=GraphManip.getDiffNodes(delta, dst);
 
@@ -1294,7 +1294,7 @@ public class Pointer {
          edgesToRemove=GraphManip.getEdges(graph, delta, dstNodes, fd);
          graph.strongUpdateSet.addAll(edgesToRemove);
        }
-       edgesToAdd.addAll(GraphManip.genEdges(newDstNodes, fd, srcNodes));
+       Edge.mergeEdgesInto(edgesToAdd, GraphManip.genEdges(newDstNodes, fd, srcEdges));
       }
 
       //Kill new edges
@@ -1308,7 +1308,7 @@ public class Pointer {
       }
 
       //Next look at new destinations
-      edgesToAdd.addAll(GraphManip.genEdges(dstNodes, fd, newSrcNodes));
+      Edge.mergeEdgesInto(edgesToAdd, GraphManip.genEdges(dstNodes, fd, newSrcEdges));
 
       /* Update diff */
       updateHeapDelta(graph, delta, edgesToAdd, edgesToRemove);
@@ -1381,17 +1381,17 @@ public class Pointer {
       return delta;
     if (delta.getInit()) {
       MySet<Edge> srcedges=GraphManip.getEdges(graph, delta, src);
-      MySet<Edge> edgesToAdd=GraphManip.dereference(graph, delta, dst, srcedges, fd);
+      MySet<Edge> edgesToAdd=GraphManip.dereference(graph, delta, dst, srcedges, fd, node);
       MySet<Edge> edgesToRemove=GraphManip.getEdges(graph, delta, dst);
       updateVarDelta(graph, delta, dst, edgesToAdd, edgesToRemove);
       applyDiffs(graph, delta);
     } else {
       /* First compute new objects we read fields of */
       MySet<Edge> allsrcedges=GraphManip.getEdges(graph, delta, src);
-      MySet<Edge> edgesToAdd=GraphManip.diffDereference(delta, dst, allsrcedges, fd);     
+      MySet<Edge> edgesToAdd=GraphManip.diffDereference(delta, dst, allsrcedges, fd, node);
       /* Next compute new targets of fields */
       MySet<Edge> newsrcedges=GraphManip.getDiffEdges(delta, src);
-      MySet<Edge> newfdedges=GraphManip.dereference(graph, delta, dst, newsrcedges, fd);
+      MySet<Edge> newfdedges=GraphManip.dereference(graph, delta, dst, newsrcedges, fd, node);
 
       /* Compute the union, and then the set of edges */
       Edge.mergeEdgesInto(edgesToAdd, newfdedges);
@@ -1759,6 +1759,13 @@ public class Pointer {
            //We have a new edge
            diffedges.add(e);
            dstedges.add(e);
+         } else {
+           Edge origedge=dstedges.get(e);
+           if (!origedge.subsumes(e)) {
+             Edge mergededge=origedge.merge(e);
+             diffedges.add(mergededge);
+             dstedges.add(mergededge);
+           }
          }
        }
        //Done with edge set...