Robust/src/Analysis/OwnershipAnalysis/MethodEffects.java

   1 package Analysis.OwnershipAnalysis;
   2
   3 import java.util.HashSet;
   4 import java.util.Iterator;
   5 import java.util.Set;
   6
   7 import IR.FieldDescriptor;
   8 import IR.Flat.FlatCall;
   9 import IR.Flat.TempDescriptor;
  10
  11 public class MethodEffects {
  12
  13         private EffectsSet effectsSet;
  14
  15         public MethodEffects() {
  16                 effectsSet = new EffectsSet();
  17         }
  18
  19         public EffectsSet getEffects() {
  20                 return effectsSet;
  21         }
  22
  23         public void analyzeFlatFieldNode(OwnershipGraph og, TempDescriptor srcDesc,
  24                         FieldDescriptor fieldDesc) {
  25
  26                 LabelNode ln = getLabelNodeFromTemp(og, srcDesc);
  27                 if (ln != null) {
  28                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
  29
  30                         while (heapRegionsItr.hasNext()) {
  31                                 ReferenceEdge edge = heapRegionsItr.next();
  32                                 HeapRegionNode hrn = edge.getDst();
  33
  34                                 if (hrn.isParameter()) {
  35                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
  36                                                         .getID());
  37
  38                                         if (paramSet != null) {
  39                                                 Iterator<Integer> paramIter = paramSet.iterator();
  40                                                 while (paramIter.hasNext()) {
  41                                                         Integer paramID = paramIter.next();
  42                                                         effectsSet.addReadingVar(paramID, new EffectsKey(
  43                                                                         fieldDesc.getSymbol(), srcDesc.getType(),hrn.getID()));
  44
  45                                                 }
  46                                         }
  47
  48                                         // check weather this heap region is parameter
  49                                         // reachable...
  50
  51                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
  52                                         if (paramSet != null) {
  53                                                 Iterator<Integer> paramIter = paramSet.iterator();
  54
  55                                                 while (paramIter.hasNext()) {
  56                                                         Integer paramID = paramIter.next();
  57                                                         effectsSet.addReadingVar(paramID, new EffectsKey(
  58                                                                         fieldDesc.getSymbol(), srcDesc.getType(),hrn.getID()));
  59
  60                                                 }
  61                                         }
  62
  63                                 }
  64                         }
  65                 }
  66
  67         }
  68
  69         public void analyzeFlatSetFieldNode(OwnershipGraph og,
  70                         TempDescriptor dstDesc, FieldDescriptor fieldDesc) {
  71
  72                 LabelNode ln = getLabelNodeFromTemp(og, dstDesc);
  73                 if (ln != null) {
  74                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
  75
  76                         while (heapRegionsItr.hasNext()) {
  77                                 ReferenceEdge edge = heapRegionsItr.next();
  78                                 HeapRegionNode hrn = edge.getDst();
  79
  80                                 if (hrn.isParameter()) {
  81
  82                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
  83                                                         .getID());
  84
  85                                         if (paramSet != null) {
  86                                                 Iterator<Integer> paramIter = paramSet.iterator();
  87                                                 while (paramIter.hasNext()) {
  88                                                         Integer paramID = paramIter.next();
  89                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
  90                                                                         fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID()));
  91
  92                                                 }
  93                                         }
  94
  95                                         // check weather this heap region is parameter
  96                                         // reachable...
  97
  98                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
  99                                         if (paramSet != null) {
 100                                                 Iterator<Integer> paramIter = paramSet.iterator();
 101
 102                                                 while (paramIter.hasNext()) {
 103                                                         Integer paramID = paramIter.next();
 104                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 105                                                                         fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID()));
 106
 107                                                 }
 108                                         }
 109
 110                                 }
 111                         }
 112                 }
 113
 114         }
 115
 116         private Set<Integer> getReachableParamIndexSet(OwnershipGraph og,
 117                         TempDescriptor paramDesc) {
 118
 119                 HashSet<Integer> resultSet = new HashSet<Integer>();
 120
 121                 LabelNode ln = getLabelNodeFromTemp(og, paramDesc);
 122                 if (ln != null) {
 123
 124                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
 125
 126                         while (heapRegionsItr.hasNext()) {
 127                                 ReferenceEdge edge = heapRegionsItr.next();
 128                                 HeapRegionNode hrn = edge.getDst();
 129
 130                                 if (hrn.isParameter()) {
 131
 132                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
 133                                                         .getID());
 134
 135                                         if (paramSet != null) {
 136                                                 Iterator<Integer> paramIter = paramSet.iterator();
 137                                                 while (paramIter.hasNext()) {
 138                                                         Integer paramID = paramIter.next();
 139
 140                                                         resultSet.add(paramID);
 141
 142                                                 }
 143                                         }
 144
 145                                         // check weather this heap region is parameter
 146                                         // reachable...
 147
 148                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
 149                                         if (paramSet != null) {
 150                                                 Iterator<Integer> paramIter = paramSet.iterator();
 151
 152                                                 while (paramIter.hasNext()) {
 153                                                         Integer paramID = paramIter.next();
 154
 155                                                         resultSet.add(paramID);
 156
 157                                                 }
 158                                         }
 159
 160                                 }
 161                         }
 162
 163                 }
 164
 165                 return resultSet;
 166
 167         }
 168
 169         public void analyzeFlatCall(OwnershipGraph og, FlatCall fc,
 170                         MethodContext mc, MethodEffects callee) {
 171
 172                 TempDescriptor[] tdArray = fc.readsTemps();
 173
 174                 for (int calleeParamIdx = 0; calleeParamIdx < tdArray.length; calleeParamIdx++) {
 175                         TempDescriptor paramDesc = tdArray[calleeParamIdx];
 176
 177                         Set<Integer> paramIDs = getReachableParamIndexSet(og, paramDesc);
 178
 179                         // handle read effects
 180                         Iterator<Integer> paramIter = paramIDs.iterator();
 181                         while (paramIter.hasNext()) {
 182                                 Integer paramIdx = paramIter.next();
 183                                 HashSet<EffectsKey> newSet = callee.getEffects().getReadTable()
 184                                                 .get(calleeParamIdx);
 185                                 effectsSet.addReadingEffectsSet(paramIdx, newSet);
 186                         }
 187
 188                         // handle write effects
 189                         paramIter = paramIDs.iterator();
 190                         while (paramIter.hasNext()) {
 191                                 Integer paramIdx = paramIter.next();
 192                                 HashSet<EffectsKey> newSet = callee.getEffects()
 193                                                 .getWriteTable().get(calleeParamIdx);
 194                                 effectsSet.addWritingEffectsSet(paramIdx, newSet);
 195                         }
 196
 197                 }
 198
 199         }
 200
 201         protected LabelNode getLabelNodeFromTemp(OwnershipGraph og,
 202                         TempDescriptor td) {
 203                 assert td != null;
 204
 205                 if (!og.td2ln.containsKey(td)) {
 206                         og.td2ln.put(td, new LabelNode(td));
 207                 }
 208
 209                 return og.td2ln.get(td);
 210         }
 211
 212         public boolean equals(Object o) {
 213                 if (o == null) {
 214                         return false;
 215                 }
 216
 217                 if (!(o instanceof MethodEffects)) {
 218                         return false;
 219                 }
 220
 221                 MethodEffects in = (MethodEffects) o;
 222
 223                 if (getEffects().equals(in.getEffects())) {
 224                         return true;
 225                 } else {
 226                         return false;
 227                 }
 228
 229         }
 230
 231         public int hashCode() {
 232                 int hash = 1;
 233
 234                 hash += getEffects().hashCode() * 37;
 235
 236                 return hash;
 237         }
 238
 239 }