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(),hrn.getGloballyUniqueIdentifier(),0));
  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(),hrn.getGloballyUniqueIdentifier(),1));
  59
  60                                                 }
  61                                         }
  62
  63                                 }
  64                         }
  65                 }
  66
  67         }
  68
  69         public void analyzeFlatElementNode(OwnershipGraph og,
  70                         TempDescriptor srcDesc, FieldDescriptor fieldDesc){
  71
  72                 LabelNode ln = getLabelNodeFromTemp(og, srcDesc);
  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                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
  82                                                         .getID());
  83
  84                                         if (paramSet != null) {
  85                                                 Iterator<Integer> paramIter = paramSet.iterator();
  86                                                 while (paramIter.hasNext()) {
  87                                                         Integer paramID = paramIter.next();
  88                                                         effectsSet.addReadingVar(paramID, new EffectsKey(
  89                                                         fieldDesc.getSymbol(), srcDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),0));
  90                                                 }
  91                                         }
  92
  93                                         // check weather this heap region is parameter
  94                                         // reachable...
  95
  96                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
  97                                         if (paramSet != null) {
  98                                                 Iterator<Integer> paramIter = paramSet.iterator();
  99
 100                                                 while (paramIter.hasNext()) {
 101                                                         Integer paramID = paramIter.next();
 102                                                         effectsSet.addReadingVar(paramID, new EffectsKey(
 103                                                                         fieldDesc.getSymbol(), srcDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),1));
 104                                                 }
 105                                         }
 106
 107                                 }
 108                         }
 109                 }
 110
 111
 112
 113
 114         }
 115
 116         public void analyzeFlatSetElementNode(OwnershipGraph og,
 117                         TempDescriptor dstDesc, FieldDescriptor fieldDesc) {
 118
 119                 LabelNode ln = getLabelNodeFromTemp(og, dstDesc);
 120                 if (ln != null) {
 121
 122                         // / check possible strong updates
 123                         boolean strongUpdate = false;
 124                         if (!fieldDesc.getType().isImmutable()
 125                                         || fieldDesc.getType().isArray()) {
 126                                 Iterator<ReferenceEdge> itrXhrn = ln.iteratorToReferencees();
 127                                 while (itrXhrn.hasNext()) {
 128                                         ReferenceEdge edgeX = itrXhrn.next();
 129                                         HeapRegionNode hrnX = edgeX.getDst();
 130
 131                                         if (fieldDesc != null
 132                                                         && fieldDesc != OwnershipAnalysis
 133                                                                         .getArrayField(fieldDesc.getType())
 134                                                         && ((hrnX.getNumReferencers() == 1) || // case 1
 135                                                         (hrnX.isSingleObject() && ln.getNumReferencees() == 1) // case
 136                                                                                                                                                                         // 2
 137                                                         )) {
 138                                                 strongUpdate = true;
 139                                         }
 140                                 }
 141                         }
 142                         // //
 143
 144                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
 145                         while (heapRegionsItr.hasNext()) {
 146                                 ReferenceEdge edge = heapRegionsItr.next();
 147                                 HeapRegionNode hrn = edge.getDst();
 148
 149                                 if (hrn.isParameter()) {
 150                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
 151                                                         .getID());
 152
 153                                         if (paramSet != null) {
 154                                                 Iterator<Integer> paramIter = paramSet.iterator();
 155                                                 while (paramIter.hasNext()) {
 156                                                         Integer paramID = paramIter.next();
 157                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 158                                                                         fieldDesc.getSymbol(), dstDesc.getType(),
 159                                                                         hrn.getID(), hrn
 160                                                                                         .getGloballyUniqueIdentifier(), 0));
 161                                                         if(strongUpdate){
 162                                                                 effectsSet.addStrongUpdateVar(paramID, new EffectsKey(
 163                                                                                 fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),0));
 164                                                         }
 165                                                 }
 166                                         }
 167
 168                                         // check weather this heap region is parameter
 169                                         // reachable...
 170
 171                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
 172                                         if (paramSet != null) {
 173                                                 Iterator<Integer> paramIter = paramSet.iterator();
 174
 175                                                 while (paramIter.hasNext()) {
 176                                                         Integer paramID = paramIter.next();
 177                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 178                                                                         fieldDesc.getSymbol(), dstDesc.getType(),
 179                                                                         hrn.getID(), hrn
 180                                                                                         .getGloballyUniqueIdentifier(), 1));
 181                                                         if(strongUpdate){
 182                                                                 effectsSet.addStrongUpdateVar(paramID, new EffectsKey(
 183                                                                                 fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),0));
 184                                                         }
 185                                                 }
 186                                         }
 187
 188                                 }
 189
 190                         }
 191                 }
 192
 193         }
 194
 195         public void analyzeFlatSetFieldNode(OwnershipGraph og,
 196                         TempDescriptor dstDesc, FieldDescriptor fieldDesc) {
 197
 198                 LabelNode ln = getLabelNodeFromTemp(og, dstDesc);
 199                 if (ln != null) {
 200                         /// check possible strong updates
 201                             boolean strongUpdate = false;
 202                             if( !fieldDesc.getType().isImmutable() || fieldDesc.getType().isArray() ) {
 203                                  Iterator<ReferenceEdge> itrXhrn = ln.iteratorToReferencees();
 204                                             while( itrXhrn.hasNext() ) {
 205                                               ReferenceEdge edgeX = itrXhrn.next();
 206                                               HeapRegionNode hrnX = edgeX.getDst();
 207
 208                                               if( fieldDesc != null &&
 209                                                           fieldDesc != OwnershipAnalysis.getArrayField( fieldDesc.getType() ) &&
 210                                                   (   (hrnX.getNumReferencers()                         == 1) || // case 1
 211                                                       (hrnX.isSingleObject() && ln.getNumReferencees() == 1)    // case 2
 212                                                       )
 213                                                   ) {
 214                                                 strongUpdate = true;
 215                                               }
 216                                             }
 217                             }
 218                         ////
 219
 220                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
 221
 222                         while (heapRegionsItr.hasNext()) {
 223                                 ReferenceEdge edge = heapRegionsItr.next();
 224                                 HeapRegionNode hrn = edge.getDst();
 225
 226                                 if (hrn.isParameter()) {
 227
 228                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
 229                                                         .getID());
 230
 231                                         if (paramSet != null) {
 232                                                 Iterator<Integer> paramIter = paramSet.iterator();
 233                                                 while (paramIter.hasNext()) {
 234                                                         Integer paramID = paramIter.next();
 235                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 236                                                                         fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),0));
 237                                                         if(strongUpdate){
 238                                                                 effectsSet.addStrongUpdateVar(paramID, new EffectsKey(
 239                                                                                 fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),0));
 240                                                         }
 241
 242                                                 }
 243                                         }
 244
 245                                         // check weather this heap region is parameter
 246                                         // reachable...
 247
 248                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
 249                                         if (paramSet != null) {
 250                                                 Iterator<Integer> paramIter = paramSet.iterator();
 251
 252                                                 while (paramIter.hasNext()) {
 253                                                         Integer paramID = paramIter.next();
 254                                                         effectsSet.addWritingVar(paramID, new EffectsKey(
 255                                                                         fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),1));
 256                                                         if(strongUpdate){
 257                                                                 effectsSet.addStrongUpdateVar(paramID, new EffectsKey(
 258                                                                                 fieldDesc.getSymbol(), dstDesc.getType(),hrn.getID(),hrn.getGloballyUniqueIdentifier(),1));
 259                                                         }
 260
 261                                                 }
 262                                         }
 263
 264                                 }
 265                         }
 266                 }
 267
 268         }
 269
 270         private Set<Integer> getReachableParamIndexSet(OwnershipGraph og,
 271                         TempDescriptor paramDesc) {
 272
 273                 HashSet<Integer> resultSet = new HashSet<Integer>();
 274
 275                 LabelNode ln = getLabelNodeFromTemp(og, paramDesc);
 276                 if (ln != null) {
 277
 278                         Iterator<ReferenceEdge> heapRegionsItr = ln.iteratorToReferencees();
 279
 280                         while (heapRegionsItr.hasNext()) {
 281                                 ReferenceEdge edge = heapRegionsItr.next();
 282                                 HeapRegionNode hrn = edge.getDst();
 283
 284                                 if (hrn.isParameter()) {
 285
 286                                         Set<Integer> paramSet = og.idPrimary2paramIndexSet.get(hrn
 287                                                         .getID());
 288
 289                                         if (paramSet != null) {
 290                                                 Iterator<Integer> paramIter = paramSet.iterator();
 291                                                 while (paramIter.hasNext()) {
 292                                                         Integer paramID = paramIter.next();
 293
 294                                                         resultSet.add(paramID);
 295
 296                                                 }
 297                                         }
 298
 299                                         // check weather this heap region is parameter
 300                                         // reachable...
 301
 302                                         paramSet = og.idSecondary2paramIndexSet.get(hrn.getID());
 303                                         if (paramSet != null) {
 304                                                 Iterator<Integer> paramIter = paramSet.iterator();
 305
 306                                                 while (paramIter.hasNext()) {
 307                                                         Integer paramID = paramIter.next();
 308
 309                                                         resultSet.add(paramID);
 310
 311                                                 }
 312                                         }
 313
 314                                 }
 315                         }
 316
 317                 }
 318
 319                 return resultSet;
 320
 321         }
 322
 323         public void analyzeFlatCall(OwnershipGraph og, FlatCall fc,
 324                         MethodContext mc, MethodEffects callee) {
 325
 326                 TempDescriptor[] tdArray = fc.readsTemps();
 327
 328                 for (int calleeParamIdx = 0; calleeParamIdx < tdArray.length; calleeParamIdx++) {
 329                         TempDescriptor paramDesc = tdArray[calleeParamIdx];
 330
 331                         Set<Integer> paramIDs = getReachableParamIndexSet(og, paramDesc);
 332
 333                         // handle read effects
 334                         Iterator<Integer> paramIter = paramIDs.iterator();
 335                         while (paramIter.hasNext()) {
 336                                 Integer paramIdx = paramIter.next();
 337                                 HashSet<EffectsKey> newSet = callee.getEffects().getReadTable()
 338                                                 .get(calleeParamIdx);
 339
 340
 341                                 if(newSet!=null){
 342                                         HashSet<EffectsKey> thisSet=new HashSet<EffectsKey>();
 343                                         HeapRegionNode priHRN=og.id2hrn.get(og.paramIndex2idPrimary.get(paramIdx));
 344                                         Integer secIdx=og.paramIndex2idSecondary.get(paramIdx);
 345                                         HeapRegionNode secHRN=null;
 346                                         if(secIdx!=null){
 347                                                  secHRN=og.id2hrn.get(secIdx);
 348                                         }else{
 349                                                 secHRN=priHRN;
 350                                         }
 351
 352                                         for (Iterator iterator = newSet.iterator(); iterator.hasNext();) {
 353                                                 EffectsKey effectsKey = (EffectsKey) iterator.next();
 354                                                 HeapRegionNode hrnTemp;
 355                                                 if(effectsKey.getParamIden()==0){//primary
 356                                                         hrnTemp=priHRN;
 357                                                 }else{//secondary
 358                                                         hrnTemp=secHRN;
 359                                                 }
 360                                                 EffectsKey newEffectsKey;
 361                                                 if(secIdx==null){
 362                                                         newEffectsKey=new EffectsKey(effectsKey.getFieldDescriptor(), effectsKey.getTypeDescriptor(), hrnTemp.getID(),hrnTemp.getGloballyUniqueIdentifier(),0);
 363                                                 }else{
 364                                                         newEffectsKey=new EffectsKey(effectsKey.getFieldDescriptor(), effectsKey.getTypeDescriptor(), hrnTemp.getID(),hrnTemp.getGloballyUniqueIdentifier(),effectsKey.getParamIden());
 365                                                 }
 366                                                 thisSet.add(newEffectsKey);
 367                                         }
 368
 369                                         effectsSet.addReadingEffectsSet(paramIdx, thisSet);
 370                                 }
 371
 372                         }
 373
 374                         // handle write effects
 375                         paramIter = paramIDs.iterator();
 376                         while (paramIter.hasNext()) {
 377                                 Integer paramIdx = paramIter.next();
 378                                 HashSet<EffectsKey> newSet = callee.getEffects()
 379                                                 .getWriteTable().get(calleeParamIdx);
 380
 381                                 if(newSet!=null){
 382
 383                                         HashSet<EffectsKey> thisSet=new HashSet<EffectsKey>();
 384                                         HeapRegionNode priHRN=og.id2hrn.get(og.paramIndex2idPrimary.get(paramIdx));
 385                                         Integer secIdx=og.paramIndex2idSecondary.get(paramIdx);
 386                                         HeapRegionNode secHRN=null;
 387                                         if(secIdx!=null){
 388                                                  secHRN=og.id2hrn.get(secIdx);
 389                                         }else{
 390                                                 secHRN=priHRN;
 391                                         }
 392
 393                                         for (Iterator iterator = newSet.iterator(); iterator.hasNext();) {
 394                                                 EffectsKey effectsKey = (EffectsKey) iterator.next();
 395                                                 HeapRegionNode hrnTemp;
 396                                                 if(effectsKey.getParamIden()==0){//primary
 397                                                         hrnTemp=priHRN;
 398                                                 }else{//secondary
 399                                                         hrnTemp=secHRN;
 400                                                 }
 401                                                 EffectsKey newEffectsKey;
 402                                                 if(secIdx==null){
 403                                                         newEffectsKey=new EffectsKey(effectsKey.getFieldDescriptor(), effectsKey.getTypeDescriptor(), hrnTemp.getID(),hrnTemp.getGloballyUniqueIdentifier(),0);
 404                                                 }else{
 405                                                         newEffectsKey=new EffectsKey(effectsKey.getFieldDescriptor(), effectsKey.getTypeDescriptor(), hrnTemp.getID(),hrnTemp.getGloballyUniqueIdentifier(),effectsKey.getParamIden());
 406                                                 }
 407                                                 thisSet.add(newEffectsKey);
 408                                         }
 409
 410                                         effectsSet.addWritingEffectsSet(paramIdx, thisSet);
 411                                 }
 412
 413                         }
 414
 415                         // handle strong update effects
 416                         paramIter = paramIDs.iterator();
 417                         while (paramIter.hasNext()) {
 418                                 Integer paramIdx = paramIter.next();
 419                                 HashSet<EffectsKey> newSet = callee.getEffects()
 420                                                 .getStrongUpdateTable().get(calleeParamIdx);
 421                                 if(newSet!=null){
 422
 423                                         HashSet<EffectsKey> thisSet=new HashSet<EffectsKey>();
 424                                         HeapRegionNode priHRN=og.id2hrn.get(og.paramIndex2idPrimary.get(paramIdx));
 425                                         Integer secIdx=og.paramIndex2idSecondary.get(paramIdx);
 426                                         HeapRegionNode secHRN=null;
 427                                         if(secIdx!=null){
 428                                                  secHRN=og.id2hrn.get(secIdx);
 429                                         }else{
 430                                                 secHRN=priHRN;
 431                                         }
 432
 433                                         for (Iterator iterator = newSet.iterator(); iterator.hasNext();) {
 434                                                 EffectsKey effectsKey = (EffectsKey) iterator.next();
 435                                                 HeapRegionNode hrnTemp;
 436                                                 if(effectsKey.getParamIden()==0){//primary
 437                                                         hrnTemp=priHRN;
 438                                                 }else{//secondary
 439                                                         hrnTemp=secHRN;
 440                                                 }
 441                                                 EffectsKey newEffectsKey;
 442                                                 if(secIdx==null){
 443                                                         newEffectsKey=new EffectsKey(effectsKey.getFieldDescriptor(), effectsKey.getTypeDescriptor(), hrnTemp.getID(),hrnTemp.getGloballyUniqueIdentifier(),0);
 444                                                 }else{
 445                                                         newEffectsKey=new EffectsKey(effectsKey.getFieldDescriptor(), effectsKey.getTypeDescriptor(), hrnTemp.getID(),hrnTemp.getGloballyUniqueIdentifier(),effectsKey.getParamIden());
 446                                                 }
 447                                                 thisSet.add(newEffectsKey);
 448                                         }
 449
 450                                         effectsSet.addStrongUpdateEffectsSet(paramIdx, thisSet);
 451                                 }
 452
 453                         }
 454
 455                 }
 456
 457         }
 458
 459         protected LabelNode getLabelNodeFromTemp(OwnershipGraph og,
 460                         TempDescriptor td) {
 461                 assert td != null;
 462
 463                 if (!og.td2ln.containsKey(td)) {
 464                         og.td2ln.put(td, new LabelNode(td));
 465                 }
 466
 467                 return og.td2ln.get(td);
 468         }
 469
 470         public boolean equals(Object o) {
 471                 if (o == null) {
 472                         return false;
 473                 }
 474
 475                 if (!(o instanceof MethodEffects)) {
 476                         return false;
 477                 }
 478
 479                 MethodEffects in = (MethodEffects) o;
 480
 481                 if (getEffects().equals(in.getEffects())) {
 482                         return true;
 483                 } else {
 484                         return false;
 485                 }
 486
 487         }
 488
 489         public int hashCode() {
 490                 int hash = 1;
 491
 492                 hash += getEffects().hashCode() * 37;
 493
 494                 return hash;
 495         }
 496
 497 }