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       for(Edge e:entry.getValue())
  23         if (e.src!=node)
  24           throw new Error(e.src+" is not equal to "+node);
  25     }
  26     return this;
  27   }
  28
  29
  30   boolean init;
  31   PPoint block;
  32   boolean callStart;
  33
  34   /* Init is set for false for delta propagations inside of one basic block.
  35    */
  36
  37   public Delta(PPoint block, boolean init) {
  38     this.init=init;
  39     this.baseheapedge=new HashMap<AllocNode, MySet<Edge>>();
  40     this.basevaredge=new HashMap<TempDescriptor, MySet<Edge>>();
  41     this.heapedgeadd=new HashMap<AllocNode, MySet<Edge>>();
  42     this.heapedgeremove=new HashMap<AllocNode, MySet<Edge>>();
  43     this.varedgeadd=new HashMap<TempDescriptor, MySet<Edge>>();
  44     this.varedgeremove=new HashMap<TempDescriptor, MySet<Edge>>();
  45     this.baseNodeAges=new HashSet<AllocNode>();
  46     this.addNodeAges=new HashSet<AllocNode>();
  47     this.baseOldNodes=new HashMap<AllocNode, Boolean>();
  48     this.addOldNodes=new HashMap<AllocNode, Boolean>();
  49     this.block=block;
  50   }
  51
  52   private Delta() {
  53   }
  54
  55   public PPoint getBlock() {
  56     return block;
  57   }
  58
  59   public void setBlock(PPoint block) {
  60     this.block=block;
  61   }
  62
  63   public Delta changeParams(HashMap<TempDescriptor, TempDescriptor> tmpMap, PPoint bblock) {
  64     Delta newdelta=new Delta();
  65     newdelta.baseheapedge=baseheapedge;
  66     newdelta.basevaredge=basevaredge;
  67     newdelta.heapedgeadd=heapedgeadd;
  68     newdelta.heapedgeremove=heapedgeremove;
  69     //Update variable edge mappings
  70     newdelta.varedgeadd=new HashMap<TempDescriptor, MySet<Edge>>();
  71     for(Map.Entry<TempDescriptor, MySet<Edge>> entry:varedgeadd.entrySet()) {
  72       varedgeadd.put(tmpMap.get(entry.getKey()), entry.getValue());
  73     }
  74     newdelta.varedgeremove=varedgeremove;
  75     newdelta.addNodeAges=addNodeAges;
  76     newdelta.baseNodeAges=baseNodeAges;
  77     newdelta.addOldNodes=addOldNodes;
  78     newdelta.baseOldNodes=baseOldNodes;
  79     newdelta.block=bblock;
  80     return newdelta;
  81   }
  82
  83   public Delta buildBase(MySet<Edge> edges) {
  84     Delta newdelta=new Delta();
  85     newdelta.baseheapedge=baseheapedge;
  86     newdelta.basevaredge=basevaredge;
  87     newdelta.heapedgeadd=heapedgeadd;
  88     newdelta.heapedgeremove=heapedgeremove;
  89     newdelta.varedgeadd=varedgeadd;
  90     newdelta.addNodeAges=addNodeAges;
  91     newdelta.baseNodeAges=baseNodeAges;
  92     newdelta.addOldNodes=addOldNodes;
  93     newdelta.baseOldNodes=baseOldNodes;
  94     for(Edge e:edges) {
  95       if (e.srcvar!=null) {
  96         if (!newdelta.varedgeadd.containsKey(e.srcvar)) {
  97           newdelta.varedgeadd.put(e.srcvar, new MySet<Edge>());
  98         }
  99         newdelta.varedgeadd.get(e.srcvar).add(e);
 100       } else {
 101         if (!newdelta.heapedgeadd.containsKey(e.src)) {
 102           newdelta.heapedgeadd.put(e.src, new MySet<Edge>());
 103         }
 104         newdelta.heapedgeadd.get(e.src).add(e);
 105       }
 106     }
 107     return newdelta;
 108   }
 109
 110   public Delta diffBlock(PPoint bblock) {
 111     Delta newdelta=new Delta();
 112     newdelta.baseheapedge=baseheapedge;
 113     newdelta.basevaredge=basevaredge;
 114     newdelta.heapedgeadd=heapedgeadd;
 115     newdelta.heapedgeremove=heapedgeremove;
 116     newdelta.varedgeadd=varedgeadd;
 117     newdelta.varedgeremove=varedgeremove;
 118     newdelta.block=bblock;
 119     newdelta.addNodeAges=addNodeAges;
 120     newdelta.baseNodeAges=baseNodeAges;
 121     newdelta.addOldNodes=addOldNodes;
 122     newdelta.baseOldNodes=baseOldNodes;
 123     return newdelta;
 124   }
 125
 126   public boolean getInit() {
 127     return init;
 128   }
 129
 130   public void addEdge(Edge e) {
 131     if (e.src!=null) {
 132       addHeapEdge(e);
 133     } else {
 134       addVarEdge(e);
 135     }
 136   }
 137
 138   public void addHeapEdge(Edge e) {
 139     if (!heapedgeadd.containsKey(e.src))
 140       heapedgeadd.put(e.src, new MySet<Edge>(e));
 141     else
 142       heapedgeadd.get(e.src).add(e);
 143   }
 144
 145   public void addVarEdge(Edge e) {
 146     if (!varedgeadd.containsKey(e.srcvar))
 147       varedgeadd.put(e.srcvar, new MySet<Edge>(e));
 148     else
 149       varedgeadd.get(e.srcvar).add(e);
 150   }
 151
 152   public void removeEdge(Edge e) {
 153     if (e.src!=null) {
 154       removeHeapEdge(e);
 155     } else {
 156       removeVarEdge(e);
 157     }
 158   }
 159
 160   public void removeHeapEdge(Edge e) {
 161     if (heapedgeadd.containsKey(e.src)&&heapedgeadd.get(e.src).contains(e))
 162       heapedgeadd.get(e.src).remove(e);
 163     if (!heapedgeremove.containsKey(e.src))
 164       heapedgeremove.put(e.src, new MySet<Edge>(e));
 165     else
 166       heapedgeremove.get(e.src).add(e);
 167
 168   }
 169
 170   public void removeVarEdge(Edge e) {
 171     if (varedgeadd.containsKey(e.src)&&varedgeadd.get(e.src).contains(e))
 172       varedgeadd.get(e.src).remove(e);
 173     if (!varedgeremove.containsKey(e.srcvar))
 174       varedgeremove.put(e.srcvar, new MySet<Edge>(e));
 175     else
 176       varedgeremove.get(e.srcvar).add(e);
 177   }
 178
 179   public void setInit(boolean init) {
 180     this.init=init;
 181   }
 182 }