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                         /// check possible strong updates
  75                             boolean strongUpdate = false;
  76                             if( !fieldDesc.getType().isImmutable() || fieldDesc.getType().isArray() ) {
  77                                  Iterator<ReferenceEdge> itrXhrn = ln.iteratorToReferencees();
  78                                             while( itrXhrn.hasNext() ) {
  79                                               ReferenceEdge edgeX = itrXhrn.next();
  80                                               HeapRegionNode hrnX = edgeX.getDst();
  81
  82                                               if( fieldDesc != null &&
  83                                                           fieldDesc != OwnershipAnalysis.getArrayField( fieldDesc.getType() ) &&
  84                                                   (   (hrnX.getNumReferencers()                         == 1) || // case 1
  85                                                       (hrnX.isSingleObject() && ln.getNumReferencees() == 1)    // case 2
  86                                                       )
  87                                                   ) {
  88                                                 strongUpdate = true;
  89                                               }
  90                                             }
  91                             }
  92                         ////
  93
  94                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
  95
  96                         while (heapRegionsItr.hasNext()) {
  97                                 ReferenceEdge edge = heapRegionsItr.next();
  98                                 HeapRegionNode hrn = edge.getDst();
  99
 100                                 if (hrn.isParameter()) {
 101
 102                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
 103                                                         .getID());
 104
 105                                         if (paramSet != null) {
 106                                                 Iterator<Integer> paramIter = paramSet.iterator();
 107                                                 while (paramIter.hasNext()) {
 108                                                         Integer paramID = paramIter.next();
 109                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 110                                                                         fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID()));
 111                                                         if(strongUpdate){
 112                                                                 effectsSet.addStrongUpdateVar(paramID, new EffectsKey(
 113                                                                                 fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID()));
 114                                                         }
 115
 116                                                 }
 117                                         }
 118
 119                                         // check weather this heap region is parameter
 120                                         // reachable...
 121
 122                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
 123                                         if (paramSet != null) {
 124                                                 Iterator<Integer> paramIter = paramSet.iterator();
 125
 126                                                 while (paramIter.hasNext()) {
 127                                                         Integer paramID = paramIter.next();
 128                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 129                                                                         fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID()));
 130                                                         if(strongUpdate){
 131                                                                 effectsSet.addStrongUpdateVar(paramID, new EffectsKey(
 132                                                                                 fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID()));
 133                                                         }
 134
 135                                                 }
 136                                         }
 137
 138                                 }
 139                         }
 140                 }
 141
 142         }
 143
 144         private Set<Integer> getReachableParamIndexSet(OwnershipGraph og,
 145                         TempDescriptor paramDesc) {
 146
 147                 HashSet<Integer> resultSet = new HashSet<Integer>();
 148
 149                 LabelNode ln = getLabelNodeFromTemp(og, paramDesc);
 150                 if (ln != null) {
 151
 152                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
 153
 154                         while (heapRegionsItr.hasNext()) {
 155                                 ReferenceEdge edge = heapRegionsItr.next();
 156                                 HeapRegionNode hrn = edge.getDst();
 157
 158                                 if (hrn.isParameter()) {
 159
 160                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
 161                                                         .getID());
 162
 163                                         if (paramSet != null) {
 164                                                 Iterator<Integer> paramIter = paramSet.iterator();
 165                                                 while (paramIter.hasNext()) {
 166                                                         Integer paramID = paramIter.next();
 167
 168                                                         resultSet.add(paramID);
 169
 170                                                 }
 171                                         }
 172
 173                                         // check weather this heap region is parameter
 174                                         // reachable...
 175
 176                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
 177                                         if (paramSet != null) {
 178                                                 Iterator<Integer> paramIter = paramSet.iterator();
 179
 180                                                 while (paramIter.hasNext()) {
 181                                                         Integer paramID = paramIter.next();
 182
 183                                                         resultSet.add(paramID);
 184
 185                                                 }
 186                                         }
 187
 188                                 }
 189                         }
 190
 191                 }
 192
 193                 return resultSet;
 194
 195         }
 196
 197         public void analyzeFlatCall(OwnershipGraph og, FlatCall fc,
 198                         MethodContext mc, MethodEffects callee) {
 199
 200                 TempDescriptor[] tdArray = fc.readsTemps();
 201
 202                 for (int calleeParamIdx = 0; calleeParamIdx < tdArray.length; calleeParamIdx++) {
 203                         TempDescriptor paramDesc = tdArray[calleeParamIdx];
 204
 205                         Set<Integer> paramIDs = getReachableParamIndexSet(og, paramDesc);
 206
 207                         // handle read effects
 208                         Iterator<Integer> paramIter = paramIDs.iterator();
 209                         while (paramIter.hasNext()) {
 210                                 Integer paramIdx = paramIter.next();
 211                                 HashSet<EffectsKey> newSet = callee.getEffects().getReadTable()
 212                                                 .get(calleeParamIdx);
 213                                 effectsSet.addReadingEffectsSet(paramIdx, newSet);
 214                         }
 215
 216                         // handle write effects
 217                         paramIter = paramIDs.iterator();
 218                         while (paramIter.hasNext()) {
 219                                 Integer paramIdx = paramIter.next();
 220                                 HashSet<EffectsKey> newSet = callee.getEffects()
 221                                                 .getWriteTable().get(calleeParamIdx);
 222                                 effectsSet.addWritingEffectsSet(paramIdx, newSet);
 223                         }
 224
 225                         // handle strong update effects
 226                         paramIter = paramIDs.iterator();
 227                         while (paramIter.hasNext()) {
 228                                 Integer paramIdx = paramIter.next();
 229                                 HashSet<EffectsKey> newSet = callee.getEffects()
 230                                                 .getStrongUpdateTable().get(calleeParamIdx);
 231                                 effectsSet.addStrongUpdateEffectsSet(paramIdx, newSet);
 232                         }
 233
 234                 }
 235
 236         }
 237
 238         protected LabelNode getLabelNodeFromTemp(OwnershipGraph og,
 239                         TempDescriptor td) {
 240                 assert td != null;
 241
 242                 if (!og.td2ln.containsKey(td)) {
 243                         og.td2ln.put(td, new LabelNode(td));
 244                 }
 245
 246                 return og.td2ln.get(td);
 247         }
 248
 249         public boolean equals(Object o) {
 250                 if (o == null) {
 251                         return false;
 252                 }
 253
 254                 if (!(o instanceof MethodEffects)) {
 255                         return false;
 256                 }
 257
 258                 MethodEffects in = (MethodEffects) o;
 259
 260                 if (getEffects().equals(in.getEffects())) {
 261                         return true;
 262                 } else {
 263                         return false;
 264                 }
 265
 266         }
 267
 268         public int hashCode() {
 269                 int hash = 1;
 270
 271                 hash += getEffects().hashCode() * 37;
 272
 273                 return hash;
 274         }
 275
 276 }