Robust/src/Analysis/Pointer/Delta.java

   1 package Analysis.Pointer;
   2 import java.util.*;
   3 import Analysis.Pointer.AllocFactory.AllocNode;
   4 import Analysis.Pointer.BasicBlock.BBlock;
   5 import IR.Flat.*;
   6
   7 public class Delta {
   8   HashMap<AllocNode, MySet<Edge>> heapedgeremove;
   9   HashMap<AllocNode, MySet<Edge>> heapedgeadd;
  10   HashMap<TempDescriptor, MySet<Edge>> varedgeadd;
  11   HashMap<TempDescriptor, MySet<Edge>> varedgeremove;
  12   HashMap<AllocNode, MySet<Edge>> baseheapedge;
  13   HashMap<TempDescriptor, MySet<Edge>> basevaredge;
  14   HashSet<AllocNode> baseNodeAges;
  15   HashSet<AllocNode> addNodeAges;
  16   HashMap<AllocNode, Boolean> baseOldNodes;
  17   HashMap<AllocNode, Boolean> addOldNodes;
  18
  19   public Delta check() {
  20     for(Map.Entry<AllocNode, MySet<Edge>> entry : heapedgeadd.entrySet()) {
  21       AllocNode node=entry.getKey();
  22       if (node==null)
  23         throw new Error("null node key");
  24       for(Edge e : entry.getValue())
  25         if (e.src!=node)
  26           throw new Error(e.src+" is not equal to "+node);
  27     }
  28
  29     for(Map.Entry<TempDescriptor, MySet<Edge>> entry : varedgeadd.entrySet()) {
  30       TempDescriptor tmp=entry.getKey();
  31       if (tmp==null)
  32         throw new Error("null temp key");
  33       for(Edge e : entry.getValue())
  34         if (e.srcvar!=tmp)
  35           throw new Error(e.srcvar+" is not equal to "+tmp);
  36     }
  37     return this;
  38   }
  39
  40   boolean init;
  41   PPoint block;
  42   boolean callStart;
  43
  44   /* Init is set for false for delta propagations inside of one basic block.
  45    */
  46
  47   public Delta(PPoint block, boolean init) {
  48     this.init=init;
  49     this.baseheapedge=new HashMap<AllocNode, MySet<Edge>>();
  50     this.basevaredge=new HashMap<TempDescriptor, MySet<Edge>>();
  51     this.heapedgeadd=new HashMap<AllocNode, MySet<Edge>>();
  52     this.heapedgeremove=new HashMap<AllocNode, MySet<Edge>>();
  53     this.varedgeadd=new HashMap<TempDescriptor, MySet<Edge>>();
  54     this.varedgeremove=new HashMap<TempDescriptor, MySet<Edge>>();
  55     this.baseNodeAges=new HashSet<AllocNode>();
  56     this.addNodeAges=new HashSet<AllocNode>();
  57     this.baseOldNodes=new HashMap<AllocNode, Boolean>();
  58     this.addOldNodes=new HashMap<AllocNode, Boolean>();
  59     this.block=block;
  60   }
  61
  62   public boolean isEmpty() {
  63     return baseheapedge.isEmpty()&&basevaredge.isEmpty()&&heapedgeadd.isEmpty()&&heapedgeremove.isEmpty()&&varedgeadd.isEmpty()&&(varedgeremove==null||varedgeremove.isEmpty())&&baseNodeAges.isEmpty()&&addNodeAges.isEmpty()&&baseOldNodes.isEmpty()&&addOldNodes.isEmpty();
  64   }
  65
  66   public void print() {
  67     System.out.println("----------------------------------------------");
  68     System.out.println("init:"+init);
  69     System.out.println("baseheapedge:"+baseheapedge);
  70     System.out.println("basevaredge:"+basevaredge);
  71     System.out.println("heapedgeadd:"+heapedgeadd);
  72     System.out.println("heapedgeremove:"+heapedgeremove);
  73     System.out.println("varedgeadd:"+varedgeadd);
  74     if (varedgeremove==null)
  75       System.out.println("varedgeremove: null");
  76     else
  77       System.out.println("varedgeremove:"+varedgeremove);
  78     System.out.println("baseNodeAges:"+baseNodeAges);
  79     System.out.println("addNodeAges:"+addNodeAges);
  80     System.out.println("baseOldNodes:"+baseOldNodes);
  81     System.out.println("addOldNodes:"+addOldNodes);
  82   }
  83
  84   private Delta() {
  85   }
  86
  87   public PPoint getBlock() {
  88     return block;
  89   }
  90
  91   public void setBlock(PPoint block) {
  92     this.block=block;
  93   }
  94
  95   public Delta changeParams(HashMap<TempDescriptor, TempDescriptor> tmpMap, PPoint bblock) {
  96     Delta newdelta=new Delta();
  97     newdelta.baseheapedge=baseheapedge;
  98     newdelta.basevaredge=basevaredge;
  99     newdelta.heapedgeadd=heapedgeadd;
 100     newdelta.heapedgeremove=heapedgeremove;
 101     //Update variable edge mappings
 102     newdelta.varedgeadd=new HashMap<TempDescriptor, MySet<Edge>>();
 103     for(Map.Entry<TempDescriptor, MySet<Edge>> entry : varedgeadd.entrySet()) {
 104       TempDescriptor origTmp=entry.getKey();
 105       TempDescriptor newTmp=tmpMap.get(entry.getKey());
 106       MySet<Edge> edgeset=entry.getValue();
 107       if (!edgeset.isEmpty()) {
 108         newdelta.varedgeadd.put(newTmp, new MySet<Edge>());
 109         for(Edge e : edgeset) {
 110           newdelta.varedgeadd.get(newTmp).add(e.rewrite(origTmp, newTmp));
 111         }
 112       }
 113     }
 114     newdelta.varedgeremove=varedgeremove;
 115     newdelta.addNodeAges=addNodeAges;
 116     newdelta.baseNodeAges=baseNodeAges;
 117     newdelta.addOldNodes=addOldNodes;
 118     newdelta.baseOldNodes=baseOldNodes;
 119     newdelta.block=bblock;
 120     return newdelta;
 121   }
 122
 123   public Delta buildBase(MySet<Edge> edges) {
 124     Delta newdelta=new Delta();
 125     newdelta.baseheapedge=baseheapedge;
 126     newdelta.basevaredge=basevaredge;
 127     newdelta.heapedgeremove=heapedgeremove;
 128     newdelta.heapedgeadd=new HashMap<AllocNode, MySet<Edge>>();
 129     newdelta.varedgeadd=new HashMap<TempDescriptor, MySet<Edge>>();
 130     newdelta.addNodeAges=addNodeAges;
 131     newdelta.baseNodeAges=baseNodeAges;
 132     newdelta.addOldNodes=addOldNodes;
 133     newdelta.baseOldNodes=baseOldNodes;
 134
 135     for (Map.Entry<AllocNode, MySet<Edge>> entry : heapedgeadd.entrySet()) {
 136       newdelta.heapedgeadd.put(entry.getKey(), new MySet<Edge>(entry.getValue()));
 137     }
 138
 139     for (Map.Entry<TempDescriptor, MySet<Edge>> entry : varedgeadd.entrySet()) {
 140       newdelta.varedgeadd.put(entry.getKey(), new MySet<Edge>(entry.getValue()));
 141     }
 142
 143
 144     for(Edge e : edges) {
 145       if (e.srcvar!=null) {
 146         if (!newdelta.varedgeadd.containsKey(e.srcvar)) {
 147           newdelta.varedgeadd.put(e.srcvar, new MySet<Edge>());
 148         }
 149         newdelta.varedgeadd.get(e.srcvar).add(e);
 150       } else {
 151         if (!newdelta.heapedgeadd.containsKey(e.src)) {
 152           newdelta.heapedgeadd.put(e.src, new MySet<Edge>());
 153         }
 154         newdelta.heapedgeadd.get(e.src).add(e.makeOld());
 155       }
 156     }
 157     return newdelta;
 158   }
 159
 160   public Delta diffBlock(PPoint bblock) {
 161     Delta newdelta=new Delta();
 162     newdelta.baseheapedge=baseheapedge;
 163     newdelta.basevaredge=basevaredge;
 164     newdelta.heapedgeadd=heapedgeadd;
 165     newdelta.heapedgeremove=heapedgeremove;
 166     newdelta.varedgeadd=varedgeadd;
 167     newdelta.varedgeremove=varedgeremove;
 168     newdelta.block=bblock;
 169     newdelta.addNodeAges=addNodeAges;
 170     newdelta.baseNodeAges=baseNodeAges;
 171     newdelta.addOldNodes=addOldNodes;
 172     newdelta.baseOldNodes=baseOldNodes;
 173     return newdelta;
 174   }
 175
 176   public boolean getInit() {
 177     return init;
 178   }
 179
 180   public void addEdge(Edge e) {
 181     if (e.src!=null) {
 182       addHeapEdge(e);
 183     } else {
 184       addVarEdge(e);
 185     }
 186   }
 187
 188   public void addHeapEdge(Edge e) {
 189     if (!heapedgeadd.containsKey(e.src))
 190       heapedgeadd.put(e.src, new MySet<Edge>(e));
 191     else
 192       Edge.mergeEdgeInto(heapedgeadd.get(e.src), e);
 193   }
 194
 195   public void addVarEdge(Edge e) {
 196     if (!varedgeadd.containsKey(e.srcvar)) {
 197       varedgeadd.put(e.srcvar, new MySet<Edge>(e));
 198     } else
 199       Edge.mergeEdgeInto(varedgeadd.get(e.srcvar), e);
 200   }
 201
 202
 203   public void addEdgeClear(Edge e) {
 204     if (e.src!=null) {
 205       addHeapEdgeClear(e);
 206     } else {
 207       addVarEdgeClear(e);
 208     }
 209   }
 210
 211   public void addHeapEdgeClear(Edge e) {
 212     if (heapedgeremove.containsKey(e.src))
 213       heapedgeremove.get(e.src).remove(e);
 214   }
 215
 216   public void addVarEdgeClear(Edge e) {
 217     if (varedgeremove.containsKey(e.srcvar))
 218       varedgeremove.get(e.srcvar).remove(e);
 219   }
 220
 221   public void removeEdges(MySet<Edge> eset) {
 222     for(Edge e : eset) {
 223       removeEdge(e);
 224     }
 225   }
 226
 227   public void removeEdge(Edge e) {
 228     if (e.src!=null) {
 229       removeHeapEdge(e);
 230     } else {
 231       removeVarEdge(e);
 232     }
 233   }
 234
 235   public void removeHeapEdge(Edge e) {
 236     if (heapedgeadd.containsKey(e.src)&&heapedgeadd.get(e.src).contains(e))
 237       heapedgeadd.get(e.src).remove(e);
 238     if (!heapedgeremove.containsKey(e.src))
 239       heapedgeremove.put(e.src, new MySet<Edge>(e));
 240     else
 241       heapedgeremove.get(e.src).add(e);
 242
 243   }
 244
 245   public void removeVarEdge(Edge e) {
 246     if (varedgeadd.containsKey(e.srcvar)&&varedgeadd.get(e.srcvar).contains(e))
 247       varedgeadd.get(e.srcvar).remove(e);
 248     if (!varedgeremove.containsKey(e.srcvar))
 249       varedgeremove.put(e.srcvar, new MySet<Edge>(e));
 250     else
 251       varedgeremove.get(e.srcvar).add(e);
 252   }
 253
 254   public void setInit(boolean init) {
 255     this.init=init;
 256   }
 257 }