Robust/src/Analysis/SSJava/MethodAnnotationCheck.java

   1 package Analysis.SSJava;
   2
   3 import java.util.HashSet;
   4 import java.util.Hashtable;
   5 import java.util.Iterator;
   6 import java.util.Set;
   7 import java.util.Vector;
   8
   9 import IR.AnnotationDescriptor;
  10 import IR.ClassDescriptor;
  11 import IR.MethodDescriptor;
  12 import IR.Operation;
  13 import IR.State;
  14 import IR.SymbolTable;
  15 import IR.TypeUtil;
  16 import IR.Tree.ArrayAccessNode;
  17 import IR.Tree.ArrayInitializerNode;
  18 import IR.Tree.AssignmentNode;
  19 import IR.Tree.BlockExpressionNode;
  20 import IR.Tree.BlockNode;
  21 import IR.Tree.BlockStatementNode;
  22 import IR.Tree.CastNode;
  23 import IR.Tree.CreateObjectNode;
  24 import IR.Tree.DeclarationNode;
  25 import IR.Tree.ExpressionNode;
  26 import IR.Tree.FieldAccessNode;
  27 import IR.Tree.IfStatementNode;
  28 import IR.Tree.InstanceOfNode;
  29 import IR.Tree.Kind;
  30 import IR.Tree.LoopNode;
  31 import IR.Tree.MethodInvokeNode;
  32 import IR.Tree.OpNode;
  33 import IR.Tree.ReturnNode;
  34 import IR.Tree.SubBlockNode;
  35 import IR.Tree.SwitchBlockNode;
  36 import IR.Tree.SwitchStatementNode;
  37 import IR.Tree.TertiaryNode;
  38 import Util.Pair;
  39
  40 public class MethodAnnotationCheck {
  41
  42   State state;
  43   SSJavaAnalysis ssjava;
  44   TypeUtil tu;
  45
  46   Set<MethodDescriptor> annotatedMDSet;
  47   Hashtable<MethodDescriptor, Set<MethodDescriptor>> caller2calleeSet;
  48
  49   public MethodAnnotationCheck(SSJavaAnalysis ssjava, State state, TypeUtil tu) {
  50     this.ssjava = ssjava;
  51     this.state = state;
  52     this.tu = tu;
  53     caller2calleeSet = new Hashtable<MethodDescriptor, Set<MethodDescriptor>>();
  54     annotatedMDSet = new HashSet<MethodDescriptor>();
  55   }
  56
  57   public void methodAnnoatationCheck() {
  58     SymbolTable classtable = state.getClassSymbolTable();
  59     HashSet toanalyze = new HashSet();
  60     toanalyze.addAll(classtable.getValueSet());
  61     toanalyze.addAll(state.getTaskSymbolTable().getValueSet());
  62     while (!toanalyze.isEmpty()) {
  63       Object obj = toanalyze.iterator().next();
  64       ClassDescriptor cd = (ClassDescriptor) obj;
  65       toanalyze.remove(cd);
  66
  67       if (!cd.isInterface()) {
  68         for (Iterator method_it = cd.getMethods(); method_it.hasNext();) {
  69           MethodDescriptor md = (MethodDescriptor) method_it.next();
  70           checkTrustworthyMethodAnnotation(md);
  71           checkMethodBody(cd, md);
  72         }
  73       }
  74
  75     }
  76
  77     for (Iterator iterator = annotatedMDSet.iterator(); iterator.hasNext();) {
  78       MethodDescriptor md = (MethodDescriptor) iterator.next();
  79       ssjava.addAnnotationRequire(md);
  80     }
  81
  82     Set<Pair> visited = new HashSet<Pair>();
  83     Set<MethodDescriptor> tovisit = new HashSet<MethodDescriptor>();
  84     tovisit.addAll(annotatedMDSet);
  85
  86     while (!tovisit.isEmpty()) {
  87       MethodDescriptor callerMD = tovisit.iterator().next();
  88       tovisit.remove(callerMD);
  89
  90       Set<MethodDescriptor> calleeSet = caller2calleeSet.get(callerMD);
  91       if (calleeSet != null) {
  92         for (Iterator iterator = calleeSet.iterator(); iterator.hasNext();) {
  93           MethodDescriptor calleeMD = (MethodDescriptor) iterator.next();
  94           Pair p = new Pair(callerMD, calleeMD);
  95           if (!visited.contains(p)) {
  96             visited.add(p);
  97
  98             if (!ssjava.isTrustMethod(calleeMD)) {
  99               // if method is annotated as "TRUST", do not need to check for
 100               // linear type & flow-down rule
 101               tovisit.add(calleeMD);
 102
 103               Set<MethodDescriptor> possibleCalleeSet =
 104                   (Set<MethodDescriptor>) ssjava.getCallGraph().getMethods(calleeMD);
 105
 106               for (Iterator iterator2 = possibleCalleeSet.iterator(); iterator2.hasNext();) {
 107                 MethodDescriptor possibleCallee = (MethodDescriptor) iterator2.next();
 108
 109                 if (!possibleCallee.isAbstract() && !possibleCallee.getModifiers().isNative()) {
 110                   ssjava.addAnnotationRequire(possibleCallee);
 111                   tovisit.add(possibleCallee);
 112                 }
 113               }
 114             }
 115
 116           }
 117         }
 118       }
 119     }
 120
 121   }
 122
 123   private void checkTrustworthyMethodAnnotation(MethodDescriptor md) {
 124     // method annotation parsing
 125     Vector<AnnotationDescriptor> methodAnnotations = md.getModifiers().getAnnotations();
 126     if (methodAnnotations != null) {
 127       for (int i = 0; i < methodAnnotations.size(); i++) {
 128         AnnotationDescriptor an = methodAnnotations.elementAt(i);
 129         if (an.getMarker().equals(ssjava.TRUST)) {
 130           ssjava.addTrustMethod(md);
 131         }
 132       }
 133     }
 134   }
 135
 136   public void methodAnnoataionInheritanceCheck() {
 137     // check If a method is annotated, any method that overrides it should
 138     // be annotated.
 139
 140     Set<MethodDescriptor> tovisit = new HashSet<MethodDescriptor>();
 141     tovisit.addAll(ssjava.getAnnotationRequireSet());
 142
 143     while (!tovisit.isEmpty()) {
 144       MethodDescriptor md = tovisit.iterator().next();
 145       tovisit.remove(md);
 146
 147       ClassDescriptor cd = md.getClassDesc();
 148
 149       Set subClassSet = tu.getSubClasses(cd);
 150       if (subClassSet != null) {
 151         for (Iterator iterator2 = subClassSet.iterator(); iterator2.hasNext();) {
 152           ClassDescriptor subCD = (ClassDescriptor) iterator2.next();
 153           Set possiblematches = subCD.getMethodTable().getSet(md.getSymbol());
 154           for (Iterator methodit = possiblematches.iterator(); methodit.hasNext();) {
 155             MethodDescriptor matchmd = (MethodDescriptor) methodit.next();
 156             if (md.matches(matchmd)) {
 157               if (matchmd.getClassDesc().equals(subCD)) {
 158                 ssjava.addAnnotationRequire(matchmd);
 159               }
 160             }
 161           }
 162         }
 163       }
 164
 165       // need to check super classess if the current method is inherited from
 166       // them, all of ancestor method should be annotated.
 167
 168       ClassDescriptor curClassDesc;
 169       ClassDescriptor parentClassDesc = cd;
 170
 171       while (!parentClassDesc.getSymbol().equals("Object")) {
 172         curClassDesc = parentClassDesc;
 173         parentClassDesc = tu.getSuper(curClassDesc);
 174         Set possiblematches = parentClassDesc.getMethodTable().getSet(md.getSymbol());
 175         for (Iterator methodit = possiblematches.iterator(); methodit.hasNext();) {
 176           MethodDescriptor matchmd = (MethodDescriptor) methodit.next();
 177           if (md.matches(matchmd)) {
 178             ssjava.addAnnotationRequire(matchmd);
 179           }
 180         }
 181       }
 182
 183       Set<ClassDescriptor> superIFSet = tu.getSuperIFs(cd);
 184       for (Iterator iterator = superIFSet.iterator(); iterator.hasNext();) {
 185         ClassDescriptor parentInterface = (ClassDescriptor) iterator.next();
 186         Set possiblematches = parentInterface.getMethodTable().getSet(md.getSymbol());
 187         for (Iterator methodit = possiblematches.iterator(); methodit.hasNext();) {
 188           MethodDescriptor matchmd = (MethodDescriptor) methodit.next();
 189           if (md.matches(matchmd)) {
 190             ssjava.addAnnotationRequire(matchmd);
 191           }
 192         }
 193       }
 194
 195     }
 196
 197   }
 198
 199   private void checkMethodBody(ClassDescriptor cd, MethodDescriptor md) {
 200     BlockNode bn = state.getMethodBody(md);
 201     checkBlockNode(md, md.getParameterTable(), bn, false);
 202   }
 203
 204   private void checkBlockNode(MethodDescriptor md, SymbolTable nametable, BlockNode bn, boolean flag) {
 205     bn.getVarTable().setParent(nametable);
 206     String label = bn.getLabel();
 207     boolean isSSJavaLoop = flag;
 208     if (label != null && label.equals(ssjava.SSJAVA)) {
 209       if (isSSJavaLoop) {
 210         throw new Error("Only outermost loop can be the self-stabilizing loop.");
 211       } else {
 212         annotatedMDSet.add(md);
 213         isSSJavaLoop = true;
 214       }
 215     }
 216
 217     for (int i = 0; i < bn.size(); i++) {
 218       BlockStatementNode bsn = bn.get(i);
 219       checkBlockStatementNode(md, bn.getVarTable(), bsn, isSSJavaLoop);
 220     }
 221
 222   }
 223
 224   private void checkBlockStatementNode(MethodDescriptor md, SymbolTable nametable,
 225       BlockStatementNode bsn, boolean flag) {
 226
 227     switch (bsn.kind()) {
 228     case Kind.SubBlockNode:
 229       checkSubBlockNode(md, nametable, (SubBlockNode) bsn, flag);
 230       return;
 231
 232     case Kind.BlockExpressionNode:
 233       checkBlockExpressionNode(md, nametable, (BlockExpressionNode) bsn, flag);
 234       break;
 235
 236     case Kind.DeclarationNode:
 237       checkDeclarationNode(md, nametable, (DeclarationNode) bsn, flag);
 238       break;
 239
 240     case Kind.IfStatementNode:
 241       checkIfStatementNode(md, nametable, (IfStatementNode) bsn, flag);
 242       break;
 243
 244     case Kind.LoopNode:
 245       checkLoopNode(md, nametable, (LoopNode) bsn, flag);
 246       break;
 247
 248     case Kind.ReturnNode:
 249       checkReturnNode(md, nametable, (ReturnNode) bsn, flag);
 250       break;
 251
 252     case Kind.SwitchStatementNode:
 253       checkSwitchStatementNode(md, nametable, (SwitchStatementNode) bsn, flag);
 254       return;
 255
 256     }
 257   }
 258
 259   private void checkSwitchStatementNode(MethodDescriptor md, SymbolTable nametable,
 260       SwitchStatementNode ssn, boolean flag) {
 261
 262     checkExpressionNode(md, nametable, ssn.getCondition(), flag);
 263
 264     BlockNode sbn = ssn.getSwitchBody();
 265     for (int i = 0; i < sbn.size(); i++) {
 266       checkBlockNode(md, nametable, ((SwitchBlockNode) sbn.get(i)).getSwitchBlockStatement(), flag);
 267     }
 268
 269   }
 270
 271   private void checkDeclarationNode(MethodDescriptor md, SymbolTable nametable, DeclarationNode dn,
 272       boolean flag) {
 273     if (dn.getExpression() != null) {
 274       checkExpressionNode(md, nametable, dn.getExpression(), flag);
 275     }
 276   }
 277
 278   private void checkReturnNode(MethodDescriptor md, SymbolTable nametable, ReturnNode rn,
 279       boolean flag) {
 280     if (rn.getReturnExpression() != null) {
 281       if (md.getReturnType() != null) {
 282         checkExpressionNode(md, nametable, rn.getReturnExpression(), flag);
 283       }
 284     }
 285   }
 286
 287   private void checkLoopNode(MethodDescriptor md, SymbolTable nametable, LoopNode ln, boolean flag) {
 288     if (ln.getType() == LoopNode.WHILELOOP || ln.getType() == LoopNode.DOWHILELOOP) {
 289       checkExpressionNode(md, nametable, ln.getCondition(), flag);
 290       checkBlockNode(md, nametable, ln.getBody(), flag);
 291     } else {
 292       // For loop case
 293       /* Link in the initializer naming environment */
 294       BlockNode bn = ln.getInitializer();
 295       bn.getVarTable().setParent(nametable);
 296       for (int i = 0; i < bn.size(); i++) {
 297         BlockStatementNode bsn = bn.get(i);
 298         checkBlockStatementNode(md, bn.getVarTable(), bsn, flag);
 299       }
 300       // check the condition
 301       checkExpressionNode(md, bn.getVarTable(), ln.getCondition(), flag);
 302       checkBlockNode(md, bn.getVarTable(), ln.getBody(), flag);
 303       checkBlockNode(md, bn.getVarTable(), ln.getUpdate(), flag);
 304     }
 305   }
 306
 307   private void checkIfStatementNode(MethodDescriptor md, SymbolTable nametable,
 308       IfStatementNode isn, boolean flag) {
 309     checkExpressionNode(md, nametable, isn.getCondition(), flag);
 310     checkBlockNode(md, nametable, isn.getTrueBlock(), flag);
 311     if (isn.getFalseBlock() != null) {
 312       checkBlockNode(md, nametable, isn.getFalseBlock(), flag);
 313     }
 314   }
 315
 316   private void checkSubBlockNode(MethodDescriptor md, SymbolTable nametable, SubBlockNode sbn,
 317       boolean flag) {
 318     checkBlockNode(md, nametable.getParent(), sbn.getBlockNode(), flag);
 319   }
 320
 321   private void checkBlockExpressionNode(MethodDescriptor md, SymbolTable nametable,
 322       BlockExpressionNode ben, boolean flag) {
 323     checkExpressionNode(md, nametable, ben.getExpression(), flag);
 324   }
 325
 326   private void checkExpressionNode(MethodDescriptor md, SymbolTable nametable, ExpressionNode en,
 327       boolean flag) {
 328     switch (en.kind()) {
 329     case Kind.AssignmentNode:
 330       checkAssignmentNode(md, nametable, (AssignmentNode) en, flag);
 331       return;
 332
 333     case Kind.CastNode:
 334       checkCastNode(md, nametable, (CastNode) en, flag);
 335       return;
 336
 337     case Kind.CreateObjectNode:
 338       checkCreateObjectNode(md, nametable, (CreateObjectNode) en, flag);
 339       return;
 340
 341     case Kind.FieldAccessNode:
 342       checkFieldAccessNode(md, nametable, (FieldAccessNode) en, flag);
 343       return;
 344
 345     case Kind.ArrayAccessNode:
 346       checkArrayAccessNode(md, nametable, (ArrayAccessNode) en, flag);
 347       return;
 348
 349       // case Kind.LiteralNode:
 350       // checkLiteralNode(md, nametable, (LiteralNode) en, flag);
 351       // return;
 352
 353     case Kind.MethodInvokeNode:
 354       checkMethodInvokeNode(md, nametable, (MethodInvokeNode) en, flag);
 355       return;
 356
 357       // case Kind.NameNode:
 358       // checkNameNode(md, nametable, (NameNode) en, flag);
 359       // return;
 360
 361     case Kind.OpNode:
 362       checkOpNode(md, nametable, (OpNode) en, flag);
 363       return;
 364
 365       // case Kind.OffsetNode:
 366       // checkOffsetNode(md, nametable, (OffsetNode) en, flag);
 367       // return;
 368
 369     case Kind.TertiaryNode:
 370       checkTertiaryNode(md, nametable, (TertiaryNode) en, flag);
 371       return;
 372
 373     case Kind.InstanceOfNode:
 374       checkInstanceOfNode(md, nametable, (InstanceOfNode) en, flag);
 375       return;
 376
 377     case Kind.ArrayInitializerNode:
 378       checkArrayInitializerNode(md, nametable, (ArrayInitializerNode) en, flag);
 379       return;
 380
 381       // case Kind.ClassTypeNode:
 382       // checkClassTypeNode(md, nametable, (ClassTypeNode) en, flag);
 383       // return;
 384     }
 385   }
 386
 387   private void checkArrayInitializerNode(MethodDescriptor md, SymbolTable nametable,
 388       ArrayInitializerNode ain, boolean flag) {
 389
 390     for (int i = 0; i < ain.numVarInitializers(); ++i) {
 391       checkExpressionNode(md, nametable, ain.getVarInitializer(i), flag);
 392     }
 393
 394   }
 395
 396   private void checkInstanceOfNode(MethodDescriptor md, SymbolTable nametable, InstanceOfNode tn,
 397       boolean flag) {
 398     checkExpressionNode(md, nametable, tn.getExpr(), flag);
 399   }
 400
 401   private void checkTertiaryNode(MethodDescriptor md, SymbolTable nametable, TertiaryNode tn,
 402       boolean flag) {
 403     checkExpressionNode(md, nametable, tn.getCond(), flag);
 404     checkExpressionNode(md, nametable, tn.getTrueExpr(), flag);
 405     checkExpressionNode(md, nametable, tn.getFalseExpr(), flag);
 406   }
 407
 408   private void checkOpNode(MethodDescriptor md, SymbolTable nametable, OpNode on, boolean flag) {
 409
 410     checkExpressionNode(md, nametable, on.getLeft(), flag);
 411     if (on.getRight() != null) {
 412       checkExpressionNode(md, nametable, on.getRight(), flag);
 413     }
 414
 415   }
 416
 417   private void checkMethodInvokeNode(MethodDescriptor md, SymbolTable nametable,
 418       MethodInvokeNode min, boolean flag) {
 419     for (int i = 0; i < min.numArgs(); i++) {
 420       ExpressionNode en = min.getArg(i);
 421       checkExpressionNode(md, nametable, en, flag);
 422     }
 423
 424     if (min.getExpression() != null) {
 425       checkExpressionNode(md, nametable, min.getExpression(), flag);
 426     }
 427
 428     if (flag) {
 429       annotatedMDSet.add(min.getMethod());
 430     }
 431
 432     Set<MethodDescriptor> mdSet = caller2calleeSet.get(md);
 433     if (mdSet == null) {
 434       mdSet = new HashSet<MethodDescriptor>();
 435       caller2calleeSet.put(md, mdSet);
 436     }
 437     mdSet.add(min.getMethod());
 438
 439   }
 440
 441   private void checkArrayAccessNode(MethodDescriptor md, SymbolTable nametable,
 442       ArrayAccessNode aan, boolean flag) {
 443
 444     ExpressionNode left = aan.getExpression();
 445     checkExpressionNode(md, nametable, left, flag);
 446     checkExpressionNode(md, nametable, aan.getIndex(), flag);
 447
 448   }
 449
 450   private void checkFieldAccessNode(MethodDescriptor md, SymbolTable nametable,
 451       FieldAccessNode fan, boolean flag) {
 452     ExpressionNode left = fan.getExpression();
 453     checkExpressionNode(md, nametable, left, flag);
 454   }
 455
 456   private void checkCreateObjectNode(MethodDescriptor md, SymbolTable nametable,
 457       CreateObjectNode con, boolean flag) {
 458
 459     for (int i = 0; i < con.numArgs(); i++) {
 460       ExpressionNode en = con.getArg(i);
 461       checkExpressionNode(md, nametable, en, flag);
 462     }
 463
 464   }
 465
 466   private void checkCastNode(MethodDescriptor md, SymbolTable nametable, CastNode cn, boolean flag) {
 467     ExpressionNode en = cn.getExpression();
 468     checkExpressionNode(md, nametable, en, flag);
 469   }
 470
 471   private void checkAssignmentNode(MethodDescriptor md, SymbolTable nametable, AssignmentNode an,
 472       boolean flag) {
 473     boolean postinc = true;
 474
 475     if (an.getOperation().getBaseOp() == null
 476         || (an.getOperation().getBaseOp().getOp() != Operation.POSTINC && an.getOperation()
 477             .getBaseOp().getOp() != Operation.POSTDEC))
 478       postinc = false;
 479
 480     if (!postinc) {
 481       checkExpressionNode(md, nametable, an.getSrc(), flag);
 482     }
 483
 484     checkExpressionNode(md, nametable, an.getDest(), flag);
 485
 486   }
 487
 488 }