X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FAnalysis%2FSSJava%2FFlowDownCheck.java;h=f466b0edbe8abaedb2c3931d54a883e8d0007e5f;hb=ff3ceae6b47a1a01bc56fa55fa5770cba0bf252f;hp=9a7855c3a72f87fff54886c993dda5b8414f6f9f;hpb=f30751a0e91b1262a9eb775ef2fe008150e5345f;p=IRC.git diff --git a/Robust/src/Analysis/SSJava/FlowDownCheck.java b/Robust/src/Analysis/SSJava/FlowDownCheck.java index 9a7855c3..f466b0ed 100644 --- a/Robust/src/Analysis/SSJava/FlowDownCheck.java +++ b/Robust/src/Analysis/SSJava/FlowDownCheck.java @@ -25,6 +25,7 @@ import IR.SymbolTable; import IR.TypeDescriptor; import IR.TypeExtension; import IR.VarDescriptor; +import IR.Flat.FlatNode; import IR.Tree.ArrayAccessNode; import IR.Tree.AssignmentNode; import IR.Tree.BlockExpressionNode; @@ -225,7 +226,8 @@ public class FlowDownCheck { if (state.SSJAVADEBUG) { System.out.println("SSJAVA: Checking Flow-down Rules: " + md); } - checkMethodBody(cd, md, null); + CompositeLocation calleePCLOC = ssjava.getPCLocation(md); + checkMethodBody(cd, md, calleePCLOC); } } } @@ -305,23 +307,32 @@ public class FlowDownCheck { } Vector methodAnnotations = md.getModifiers().getAnnotations(); - // second, check return location annotation - if (!md.getReturnType().isVoid()) { - CompositeLocation returnLocComp = null; - - boolean hasReturnLocDeclaration = false; - if (methodAnnotations != null) { - for (int i = 0; i < methodAnnotations.size(); i++) { - AnnotationDescriptor an = methodAnnotations.elementAt(i); - if (an.getMarker().equals(ssjava.RETURNLOC)) { - // this case, developer explicitly defines method lattice - String returnLocDeclaration = an.getValue(); - returnLocComp = parseLocationDeclaration(md, null, returnLocDeclaration); - hasReturnLocDeclaration = true; - } + CompositeLocation returnLocComp = null; + + boolean hasReturnLocDeclaration = false; + if (methodAnnotations != null) { + for (int i = 0; i < methodAnnotations.size(); i++) { + AnnotationDescriptor an = methodAnnotations.elementAt(i); + if (an.getMarker().equals(ssjava.RETURNLOC)) { + // this case, developer explicitly defines method lattice + String returnLocDeclaration = an.getValue(); + returnLocComp = parseLocationDeclaration(md, null, returnLocDeclaration); + hasReturnLocDeclaration = true; + } else if (an.getMarker().equals(ssjava.THISLOC)) { + String thisLoc = an.getValue(); + ssjava.getMethodLattice(md).setThisLoc(thisLoc); + } else if (an.getMarker().equals(ssjava.GLOBALLOC)) { + String globalLoc = an.getValue(); + ssjava.getMethodLattice(md).setGlobalLoc(globalLoc); + } else if (an.getMarker().equals(ssjava.PCLOC)) { + String pcLocDeclaration = an.getValue(); + ssjava.setPCLocation(md, parseLocationDeclaration(md, null, pcLocDeclaration)); } } + } + // second, check return location annotation + if (!md.getReturnType().isVoid()) { if (!hasReturnLocDeclaration) { // if developer does not define method lattice // search return location in the method default lattice @@ -338,19 +349,17 @@ public class FlowDownCheck { md2ReturnLoc.put(md, returnLocComp); - // check this location + } + + if (!md.getReturnType().isVoid()) { MethodLattice methodLattice = ssjava.getMethodLattice(md); String thisLocId = methodLattice.getThisLoc(); - if (thisLocId == null) { + if ((!md.isStatic()) && thisLocId == null) { throw new Error("Method '" + md + "' does not have the definition of 'this' location at " + md.getClassDesc().getSourceFileName()); } CompositeLocation thisLoc = new CompositeLocation(new Location(md, thisLocId)); paramList.add(0, thisLoc); - - // System.out.println("### ReturnLocGenerator=" + md); - // System.out.println("### md2ReturnLoc.get(md)=" + md2ReturnLoc.get(md)); - md2ReturnLocGen.put(md, new ReturnLocGenerator(md2ReturnLoc.get(md), md, paramList, md + " of " + cd.getSourceFileName())); } @@ -605,6 +614,12 @@ public class FlowDownCheck { // check 'for loop' case BlockNode bn = ln.getInitializer(); bn.getVarTable().setParent(nametable); + // need to check initialization node + // checkLocationFromBlockNode(md, bn.getVarTable(), bn, constraint); + for (int i = 0; i < bn.size(); i++) { + BlockStatementNode bsn = bn.get(i); + checkLocationFromBlockStatementNode(md, bn.getVarTable(), bsn, constraint); + } // calculate glb location of condition and update statements CompositeLocation condLoc = @@ -681,7 +696,7 @@ public class FlowDownCheck { } if (!isOwned) { throw new Error( - "It is now allowed to create the reference alias from the reference not owned by the method at " + "It is not allowed to create the reference alias from the reference not owned by the method at " + generateErrorMessage(md.getClassDesc(), tn)); } @@ -728,11 +743,12 @@ public class FlowDownCheck { private void checkDeclarationInSubBlockNode(MethodDescriptor md, SymbolTable nametable, SubBlockNode sbn) { - checkDeclarationInBlockNode(md, nametable.getParent(), sbn.getBlockNode()); + checkDeclarationInBlockNode(md, nametable, sbn.getBlockNode()); } private CompositeLocation checkLocationFromBlockExpressionNode(MethodDescriptor md, SymbolTable nametable, BlockExpressionNode ben, CompositeLocation constraint) { + CompositeLocation compLoc = checkLocationFromExpressionNode(md, nametable, ben.getExpression(), null, constraint, false); // addTypeLocation(ben.getExpression().getType(), compLoc); @@ -887,7 +903,7 @@ public class FlowDownCheck { CompositeLocation constraint) { ClassDescriptor cd = md.getClassDesc(); - MethodDescriptor calleeMD = min.getMethod(); + MethodDescriptor calleeMethodDesc = min.getMethod(); NameDescriptor baseName = min.getBaseName(); boolean isSystemout = false; @@ -895,8 +911,9 @@ public class FlowDownCheck { isSystemout = baseName.getSymbol().equals("System.out"); } - if (!ssjava.isSSJavaUtil(calleeMD.getClassDesc()) && !ssjava.isTrustMethod(calleeMD) - && !calleeMD.getModifiers().isNative() && !isSystemout) { + if (!ssjava.isSSJavaUtil(calleeMethodDesc.getClassDesc()) + && !ssjava.isTrustMethod(calleeMethodDesc) && !calleeMethodDesc.getModifiers().isNative() + && !isSystemout) { CompositeLocation baseLocation = null; if (min.getExpression() != null) { @@ -921,19 +938,77 @@ public class FlowDownCheck { // min.printNode(0) // + " baseLocation=" + baseLocation + " constraint=" + constraint); + // setup the location list of caller's arguments + List callerArgList = new ArrayList(); + + // setup the location list of callee's parameters + MethodLattice calleeLattice = ssjava.getMethodLattice(calleeMethodDesc); + List calleeParamList = new ArrayList(); + + if (min.numArgs() > 0) { + if (!calleeMethodDesc.isStatic()) { + callerArgList.add(baseLocation); + } + for (int i = 0; i < min.numArgs(); i++) { + ExpressionNode en = min.getArg(i); + CompositeLocation callerArgLoc = + checkLocationFromExpressionNode(md, nametable, en, new CompositeLocation(), + constraint, false); + callerArgList.add(callerArgLoc); + } + + if (!calleeMethodDesc.isStatic()) { + CompositeLocation calleeThisLoc = + new CompositeLocation(new Location(calleeMethodDesc, calleeLattice.getThisLoc())); + calleeParamList.add(calleeThisLoc); + } + + for (int i = 0; i < calleeMethodDesc.numParameters(); i++) { + VarDescriptor calleevd = (VarDescriptor) calleeMethodDesc.getParameter(i); + CompositeLocation calleeLoc = d2loc.get(calleevd); + calleeParamList.add(calleeLoc); + } + } + if (constraint != null) { - int compareResult = - CompositeLattice.compare(constraint, baseLocation, true, generateErrorMessage(cd, min)); - if (compareResult != ComparisonResult.GREATER) { - // if the current constraint is higher than method's THIS location - // no need to check constraints! - CompositeLocation calleeConstraint = - translateCallerLocToCalleeLoc(calleeMD, baseLocation, constraint); - // System.out.println("check method body for constraint:" + calleeMD + - // " calleeConstraint=" - // + calleeConstraint); - checkMethodBody(calleeMD.getClassDesc(), calleeMD, calleeConstraint); + // check whether the PC location is lower than one of the + // argument locations. If it is lower, the callee has to have @PCLOC + // annotation that declares the program counter that is higher than + // corresponding parameter + + CompositeLocation calleePCLOC = ssjava.getPCLocation(calleeMethodDesc); + + for (int idx = 0; idx < callerArgList.size(); idx++) { + CompositeLocation argLocation = callerArgList.get(idx); + + // need to check that param is higher than PCLOC + if (!argLocation.get(0).isTop() + && CompositeLattice.compare(argLocation, constraint, true, + generateErrorMessage(cd, min)) == ComparisonResult.GREATER) { + + CompositeLocation paramLocation = calleeParamList.get(idx); + + int paramCompareResult = + CompositeLattice.compare(calleePCLOC, paramLocation, true, + generateErrorMessage(cd, min)); + + if (paramCompareResult == ComparisonResult.GREATER) { + throw new Error( + "The program counter location " + + constraint + + " is lower than the argument(idx=" + + idx + + ") location " + + argLocation + + ". Need to specify that the initial PC location of the callee, which is currently set to " + + calleePCLOC + ", is lower than " + paramLocation + " in the method " + + calleeMethodDesc.getSymbol() + ":" + min.getNumLine()); + } + + } + } + } checkCalleeConstraints(md, nametable, min, baseLocation, constraint); @@ -1205,6 +1280,7 @@ public class FlowDownCheck { CompositeLocation arrayLoc = checkLocationFromExpressionNode(md, nametable, aan.getExpression(), new CompositeLocation(), constraint, isLHS); + // addTypeLocation(aan.getExpression().getType(), arrayLoc); CompositeLocation indexLoc = checkLocationFromExpressionNode(md, nametable, aan.getIndex(), new CompositeLocation(), @@ -1433,14 +1509,16 @@ public class FlowDownCheck { // fan.printNode(0)); // System.out.println("### left=" + left.printNode(0)); - if (left.getType().isArray()) { - // array.length case: return the location of the array - return loc; - } else if (!left.getType().isPrimitive()) { + if (!left.getType().isPrimitive()) { + + if (fd.getSymbol().equals("length")) { + // array.length access, return the location of the array + return loc; + } + Location fieldLoc = getFieldLocation(fd); loc.addLocation(fieldLoc); } - // System.out.println("### field loc=" + loc); return loc; } @@ -1485,8 +1563,6 @@ public class FlowDownCheck { private CompositeLocation checkLocationFromAssignmentNode(MethodDescriptor md, SymbolTable nametable, AssignmentNode an, CompositeLocation loc, CompositeLocation constraint) { - // System.out.println("\n# ASSIGNMENTNODE=" + an.printNode(0)); - ClassDescriptor cd = md.getClassDesc(); Set inputGLBSet = new HashSet(); @@ -1514,20 +1590,22 @@ public class FlowDownCheck { checkLocationFromExpressionNode(md, nametable, an.getSrc(), new CompositeLocation(), constraint, false); - srcLocation = rhsLocation; + if (an.getOperation().getOp() >= 2 && an.getOperation().getOp() <= 12) { + // if assignment contains OP+EQ operator, need to merge location types + // of LHS & RHS into the RHS + Set srcGLBSet = new HashSet(); + srcGLBSet.add(rhsLocation); + srcGLBSet.add(destLocation); + srcLocation = CompositeLattice.calculateGLB(srcGLBSet, generateErrorMessage(cd, an)); + } else { + srcLocation = rhsLocation; + } - // if (!rhsLocation.get(rhsLocation.getSize() - 1).isTop()) { if (constraint != null) { - inputGLBSet.add(rhsLocation); + inputGLBSet.add(srcLocation); inputGLBSet.add(constraint); srcLocation = CompositeLattice.calculateGLB(inputGLBSet, generateErrorMessage(cd, an)); } - // } - - // System.out.println("dstLocation=" + destLocation); - // System.out.println("rhsLocation=" + rhsLocation); - // System.out.println("srcLocation=" + srcLocation); - // System.out.println("constraint=" + constraint); if (!CompositeLattice.isGreaterThan(srcLocation, destLocation, generateErrorMessage(cd, an))) { @@ -1541,6 +1619,16 @@ public class FlowDownCheck { + " at " + cd.getSourceFileName() + "::" + an.getNumLine()); } + if (srcLocation.equals(destLocation)) { + // keep it for definitely written analysis + Set flatNodeSet = ssjava.getBuildFlat().getFlatNodeSet(an); + for (Iterator iterator = flatNodeSet.iterator(); iterator.hasNext();) { + FlatNode fn = (FlatNode) iterator.next(); + ssjava.addSameHeightWriteFlatNode(fn); + } + + } + } else { destLocation = rhsLocation = @@ -1555,10 +1643,6 @@ public class FlowDownCheck { srcLocation = rhsLocation; } - // System.out.println("srcLocation=" + srcLocation); - // System.out.println("rhsLocation=" + rhsLocation); - // System.out.println("constraint=" + constraint); - if (!CompositeLattice.isGreaterThan(srcLocation, destLocation, generateErrorMessage(cd, an))) { if (srcLocation.equals(destLocation)) { @@ -1573,6 +1657,15 @@ public class FlowDownCheck { } + if (srcLocation.equals(destLocation)) { + // keep it for definitely written analysis + Set flatNodeSet = ssjava.getBuildFlat().getFlatNodeSet(an); + for (Iterator iterator = flatNodeSet.iterator(); iterator.hasNext();) { + FlatNode fn = (FlatNode) iterator.next(); + ssjava.addSameHeightWriteFlatNode(fn); + } + } + } return destLocation;