private Map<MethodDescriptor, Set<MethodDescriptor>> mapMethodToCalleeSet;
+ private Map<MethodDescriptor, Set<FlowNode>> mapMethodDescToParamNodeFlowsToReturnValue;
+
private Map<String, Vector<String>> mapFileNameToLineVector;
private Map<Descriptor, Integer> mapDescToDefinitionLine;
public static final String TOPLOC = "TOPLOC";
+ public static final String INTERLOC = "INTERLOC";
+
public static final Descriptor GLOBALDESC = new NameDescriptor(GLOBALLOC);
public static final Descriptor TOPDESC = new NameDescriptor(TOPLOC);
this.mapFileNameToLineVector = new HashMap<String, Vector<String>>();
this.mapDescToDefinitionLine = new HashMap<Descriptor, Integer>();
+ this.mapMethodDescToParamNodeFlowsToReturnValue =
+ new HashMap<MethodDescriptor, Set<FlowNode>>();
}
public void setupToAnalyze() {
SymbolTable classtable = state.getClassSymbolTable();
toanalyzeList.clear();
toanalyzeList.addAll(classtable.getValueSet());
- Collections.sort(toanalyzeList, new Comparator<ClassDescriptor>() {
- public int compare(ClassDescriptor o1, ClassDescriptor o2) {
- return o1.getClassName().compareToIgnoreCase(o2.getClassName());
- }
- });
+ // Collections.sort(toanalyzeList, new Comparator<ClassDescriptor>() {
+ // public int compare(ClassDescriptor o1, ClassDescriptor o2) {
+ // return o1.getClassName().compareToIgnoreCase(o2.getClassName());
+ // }
+ // });
}
public void setupToAnalazeMethod(ClassDescriptor cd) {
if (desc instanceof MethodDescriptor) {
TypeDescriptor returnType = ((MethodDescriptor) desc).getReturnType();
+
+ MethodLocationInfo methodLocInfo = getMethodLocationInfo((MethodDescriptor) desc);
+
if (returnType != null && (!returnType.isVoid())) {
- rtr += "\n@RETURNLOC(\"RETURNLOC\")";
+ rtr +=
+ "\n@RETURNLOC(\"" + generateLocationAnnoatation(methodLocInfo.getReturnLoc()) + "\")";
+ }
+
+ rtr += "\n@THISLOC(\"this\")";
+ rtr += "\n@GLOBALLOC(\"GLOBALLOC\")";
+
+ CompositeLocation pcLoc = methodLocInfo.getPCLoc();
+ if ((pcLoc != null) && (!pcLoc.get(0).isTop())) {
+ rtr += "\n@PCLOC(\"" + generateLocationAnnoatation(pcLoc) + "\")";
}
- rtr += "\n@THISLOC(\"this\")\n@PCLOC(\"PCLOC\")\n@GLOBALLOC(\"GLOBALLOC\")";
}
}
for (Iterator iter = cd.getFields(); iter.hasNext();) {
- Descriptor fieldDesc = (Descriptor) iter.next();
- String locIdentifier = locInfo.getFieldInferLocation(fieldDesc).getLocIdentifier();
- if (!getLattice(cd).containsKey(locIdentifier)) {
- getLattice(cd).put(locIdentifier);
+ FieldDescriptor fieldDesc = (FieldDescriptor) iter.next();
+ if (!(fieldDesc.isStatic() && fieldDesc.isFinal())) {
+ String locIdentifier = locInfo.getFieldInferLocation(fieldDesc).getLocIdentifier();
+ if (!getLattice(cd).getElementSet().contains(locIdentifier)) {
+ getLattice(cd).put(locIdentifier);
+ }
}
}
FieldDescriptor fd = (FieldDescriptor) iter.next();
String locAnnotationStr;
- if (inferLocMap.containsKey(fd)) {
- CompositeLocation inferLoc = inferLocMap.get(fd);
- locAnnotationStr = generateLocationAnnoatation(inferLoc);
- } else {
- // if the field is not accssed by SS part, just assigns dummy
- // location
- locAnnotationStr = "@LOC(\"LOC\")";
+ CompositeLocation inferLoc = inferLocMap.get(fd);
+
+ if (inferLoc != null) {
+ // infer loc is null if the corresponding field is static and final
+ locAnnotationStr = "@LOC(\"" + generateLocationAnnoatation(inferLoc) + "\")";
+ int fdLineNum = fd.getLineNum();
+ String orgFieldDeclarationStr = sourceVec.get(fdLineNum);
+ String fieldDeclaration = fd.toString();
+ fieldDeclaration = fieldDeclaration.substring(0, fieldDeclaration.length() - 1);
+ String annoatedStr = locAnnotationStr + " " + orgFieldDeclarationStr;
+ sourceVec.set(fdLineNum, annoatedStr);
}
- int fdLineNum = fd.getLineNum();
- String orgFieldDeclarationStr = sourceVec.get(fdLineNum);
- String fieldDeclaration = fd.toString();
- fieldDeclaration = fieldDeclaration.substring(0, fieldDeclaration.length() - 1);
-
- String annoatedStr = locAnnotationStr + " " + orgFieldDeclarationStr;
- sourceVec.set(fdLineNum, annoatedStr);
}
while (!toAnalyzeMethodIsEmpty()) {
MethodDescriptor md = toAnalyzeMethodNext();
+
+ if (!ssjava.needTobeAnnotated(md)) {
+ continue;
+ }
+
SSJavaLattice<String> methodLattice = md2lattice.get(md);
if (methodLattice != null) {
methodLocInfo.getMapDescToInferLocation();
Set<Descriptor> localVarDescSet = methodInferLocMap.keySet();
+ Set<String> localLocElementSet = methodLattice.getElementSet();
+
for (Iterator iterator = localVarDescSet.iterator(); iterator.hasNext();) {
Descriptor localVarDesc = (Descriptor) iterator.next();
CompositeLocation inferLoc = methodInferLocMap.get(localVarDesc);
- String locAnnotationStr = generateLocationAnnoatation(inferLoc);
+ String localLocIdentifier = inferLoc.get(0).getLocIdentifier();
+ if (!localLocElementSet.contains(localLocIdentifier)) {
+ methodLattice.put(localLocIdentifier);
+ }
+
+ String locAnnotationStr = "@LOC(\"" + generateLocationAnnoatation(inferLoc) + "\")";
if (!isParameter(md, localVarDesc)) {
if (mapDescToDefinitionLine.containsKey(localVarDesc)) {
}
} else {
String methodDefStr = sourceVec.get(methodDefLine);
- int idx = methodDefStr.indexOf(generateVarDeclaration((VarDescriptor) localVarDesc));
+
+ int idx =
+ getParamLocation(methodDefStr,
+ generateVarDeclaration((VarDescriptor) localVarDesc));
+
assert (idx != -1);
+
String annoatedStr =
methodDefStr.substring(0, idx) + locAnnotationStr + " "
+ methodDefStr.substring(idx);
}
+ // check if the lattice has to have the location type for the this
+ // reference...
+
+ // boolean needToAddthisRef = hasThisReference(md);
+ if (localLocElementSet.contains("this")) {
+ methodLattice.put("this");
+ }
+
String methodLatticeDefStr = generateLatticeDefinition(md);
String annoatedStr = methodLatticeDefStr + newline + sourceVec.get(methodDefLine);
sourceVec.set(methodDefLine, annoatedStr);
codeGen();
}
+ private boolean hasThisReference(MethodDescriptor md) {
+
+ FlowGraph fg = getFlowGraph(md);
+ Set<FlowNode> nodeSet = fg.getNodeSet();
+ for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
+ FlowNode flowNode = (FlowNode) iterator.next();
+ if (flowNode.getDescTuple().get(0).equals(md.getThis())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private int getParamLocation(String methodStr, String paramStr) {
+
+ String pattern = paramStr + ",";
+
+ int idx = methodStr.indexOf(pattern);
+ if (idx != -1) {
+ return idx;
+ } else {
+ pattern = paramStr + ")";
+ return methodStr.indexOf(pattern);
+ }
+
+ }
+
private String generateVarDeclaration(VarDescriptor varDesc) {
TypeDescriptor td = varDesc.getType();
}
private String generateLocationAnnoatation(CompositeLocation loc) {
- String rtr = "@LOC(\"";
-
+ String rtr = "";
// method location
Location methodLoc = loc.get(0);
rtr += methodLoc.getLocIdentifier();
rtr += "," + element.getDescriptor().getSymbol() + "." + element.getLocIdentifier();
}
- rtr += "\")";
return rtr;
}
// dependency in the call graph
methodDescriptorsToVisitStack.clear();
- descriptorListToAnalyze.removeFirst();
+ // descriptorListToAnalyze.removeFirst();
Set<MethodDescriptor> methodDescriptorToVistSet = new HashSet<MethodDescriptor>();
methodDescriptorToVistSet.addAll(descriptorListToAnalyze);
// do fixed-point analysis
+ ssjava.init();
LinkedList<MethodDescriptor> descriptorListToAnalyze = ssjava.getSortedDescriptors();
- Collections.sort(descriptorListToAnalyze, new Comparator<MethodDescriptor>() {
- public int compare(MethodDescriptor o1, MethodDescriptor o2) {
- return o1.getSymbol().compareToIgnoreCase(o2.getSymbol());
- }
- });
+ // Collections.sort(descriptorListToAnalyze, new
+ // Comparator<MethodDescriptor>() {
+ // public int compare(MethodDescriptor o1, MethodDescriptor o2) {
+ // return o1.getSymbol().compareToIgnoreCase(o2.getSymbol());
+ // }
+ // });
// current descriptors to visit in fixed-point interprocedural analysis,
// prioritized by
}
}
+
+ descriptorListToAnalyze = ssjava.getSortedDescriptors();
+ for (Iterator iterator = descriptorListToAnalyze.iterator(); iterator.hasNext();) {
+ MethodDescriptor md = (MethodDescriptor) iterator.next();
+ calculateExtraLocations(md);
+ }
+
}
private void setMethodLocInfo(MethodDescriptor md, MethodLocationInfo methodInfo) {
if (!md1.getReturnType().isVoid()) {
// add return value location
- CompositeLocation rtrLoc1 =
- new CompositeLocation(new Location(md1, locInfo1.getReturnLocName()));
- CompositeLocation rtrLoc2 =
- new CompositeLocation(new Location(md2, locInfo2.getReturnLocName()));
+ CompositeLocation rtrLoc1 = getMethodLocationInfo(md1).getReturnLoc();
+ CompositeLocation rtrLoc2 = getMethodLocationInfo(md2).getReturnLoc();
list1.add(rtrLoc1);
list2.add(rtrLoc2);
}
// value flow between local var - local var or local var - field
addRelationToLattice(md, methodLattice, methodInfo, srcNode, dstNode);
}
-
- // else if (srcNodeTuple.size() == 1 || dstNodeTuple.size() == 1) {
- // // for the method lattice, we need to look at the first element of
- // // NTuple<Descriptor>
- // // in this case, take a look at connected nodes at the local level
- // addRelationToLattice(md, methodLattice, methodInfo, srcNode,
- // dstNode);
- // } else {
- // if
- // (!srcNode.getDescTuple().get(0).equals(dstNode.getDescTuple().get(0)))
- // {
- // // in this case, take a look at connected nodes at the local level
- // addRelationToLattice(md, methodLattice, methodInfo, srcNode,
- // dstNode);
- // } else {
- // Descriptor srcDesc = srcNode.getDescTuple().get(0);
- // Descriptor dstDesc = dstNode.getDescTuple().get(0);
- // recursivelyAddCompositeRelation(md, fg, methodInfo, srcNode,
- // dstNode, srcDesc,
- // dstDesc);
- // // recursiveAddRelationToLattice(1, md, srcNode, dstNode);
- // }
- // }
-
}
}
}
- for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
- FlowNode flowNode = (FlowNode) iterator.next();
- if (flowNode.isDeclaratonNode()) {
- CompositeLocation inferLoc = methodInfo.getInferLocation(flowNode.getDescTuple().get(0));
- String locIdentifier = inferLoc.get(0).getLocIdentifier();
- if (!methodLattice.containsKey(locIdentifier)) {
- methodLattice.put(locIdentifier);
- }
-
- }
- }
-
// create mapping from param idx to inferred composite location
int offset;
methodInfo.addMapParamIdxToInferLoc(idx + offset, inferParamLoc);
}
- // calculate the initial program counter location
- // PC location is higher than location types of all parameters
- String pcLocSymbol = "PCLOC";
- Map<Integer, CompositeLocation> mapParamToLoc = methodInfo.getMapParamIdxToInferLoc();
- Set<Integer> keySet = mapParamToLoc.keySet();
- for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
- Integer paramIdx = (Integer) iterator.next();
- CompositeLocation inferLoc = mapParamToLoc.get(paramIdx);
- String paramLocLocalSymbol = inferLoc.get(0).getLocIdentifier();
- if (!methodLattice.isGreaterThan(pcLocSymbol, paramLocLocalSymbol)) {
- addRelationHigherToLower(methodLattice, methodInfo, pcLocSymbol, paramLocLocalSymbol);
+ }
+
+ private void calculateExtraLocations(MethodDescriptor md) {
+ // calcualte pcloc, returnloc,...
+
+ SSJavaLattice<String> methodLattice = getMethodLattice(md);
+ MethodLocationInfo methodInfo = getMethodLocationInfo(md);
+ FlowGraph fg = getFlowGraph(md);
+ Set<FlowNode> nodeSet = fg.getNodeSet();
+
+ for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
+ FlowNode flowNode = (FlowNode) iterator.next();
+ if (flowNode.isDeclaratonNode()) {
+ CompositeLocation inferLoc = methodInfo.getInferLocation(flowNode.getDescTuple().get(0));
+ String locIdentifier = inferLoc.get(0).getLocIdentifier();
+ if (!methodLattice.containsKey(locIdentifier)) {
+ methodLattice.put(locIdentifier);
+ }
+
}
}
- // calculate a return location
- // the return location type is lower than all parameters
- if (!md.getReturnType().isVoid()) {
+ Map<Integer, CompositeLocation> mapParamToLoc = methodInfo.getMapParamIdxToInferLoc();
+ Set<Integer> paramIdxSet = mapParamToLoc.keySet();
+
+ try {
+ if (!ssjava.getMethodContainingSSJavaLoop().equals(md)) {
+ // calculate the initial program counter location
+ // PC location is higher than location types of all parameters
+ String pcLocSymbol = "PCLOC";
+
+ Set<CompositeLocation> paramInFlowSet = new HashSet<CompositeLocation>();
+
+ for (Iterator iterator = paramIdxSet.iterator(); iterator.hasNext();) {
+ Integer paramIdx = (Integer) iterator.next();
+
+ FlowNode paramFlowNode = fg.getParamFlowNode(paramIdx);
+
+ if (fg.getIncomingFlowNodeSet(paramFlowNode).size() > 0) {
+ // parameter has in-value flows
+ CompositeLocation inferLoc = mapParamToLoc.get(paramIdx);
+ paramInFlowSet.add(inferLoc);
+ }
+ }
- String returnLocSymbol = "RETURNLOC";
+ if (paramInFlowSet.size() > 0) {
+ CompositeLocation lowestLoc = getLowest(methodLattice, paramInFlowSet);
+ assert (lowestLoc != null);
+ methodInfo.setPCLoc(lowestLoc);
+ }
+
+ }
- for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
- Integer paramIdx = (Integer) iterator.next();
- CompositeLocation inferLoc = mapParamToLoc.get(paramIdx);
- String paramLocLocalSymbol = inferLoc.get(0).getLocIdentifier();
- if (!methodLattice.isGreaterThan(paramLocLocalSymbol, returnLocSymbol)) {
- addRelationHigherToLower(methodLattice, methodInfo, paramLocLocalSymbol, returnLocSymbol);
+ // calculate a return location
+ // the return location type is lower than all parameters and location
+ // types
+ // of return values
+ if (!md.getReturnType().isVoid()) {
+ // first, generate the set of return value location types that starts
+ // with
+ // 'this' reference
+
+ Set<CompositeLocation> inferFieldReturnLocSet = new HashSet<CompositeLocation>();
+
+ Set<FlowNode> paramFlowNode = getParamNodeFlowingToReturnValue(md);
+ Set<CompositeLocation> inferParamLocSet = new HashSet<CompositeLocation>();
+ if (paramFlowNode != null) {
+ for (Iterator iterator = paramFlowNode.iterator(); iterator.hasNext();) {
+ FlowNode fn = (FlowNode) iterator.next();
+ CompositeLocation inferLoc =
+ generateInferredCompositeLocation(methodInfo, getFlowGraph(md).getLocationTuple(fn));
+ inferParamLocSet.add(inferLoc);
+ }
}
+
+ Set<FlowNode> returnNodeSet = fg.getReturnNodeSet();
+
+ skip: for (Iterator iterator = returnNodeSet.iterator(); iterator.hasNext();) {
+ FlowNode returnNode = (FlowNode) iterator.next();
+ CompositeLocation inferReturnLoc =
+ generateInferredCompositeLocation(methodInfo, fg.getLocationTuple(returnNode));
+ if (inferReturnLoc.get(0).getLocIdentifier().equals("this")) {
+ // if the location type of the return value matches "this" reference
+ // then, check whether this return value is equal to/lower than all
+ // of
+ // parameters that possibly flow into the return values
+ for (Iterator iterator2 = inferParamLocSet.iterator(); iterator2.hasNext();) {
+ CompositeLocation paramInferLoc = (CompositeLocation) iterator2.next();
+
+ if ((!paramInferLoc.equals(inferReturnLoc))
+ && !isGreaterThan(methodLattice, paramInferLoc, inferReturnLoc)) {
+ continue skip;
+ }
+ }
+ inferFieldReturnLocSet.add(inferReturnLoc);
+
+ }
+ }
+
+ if (inferFieldReturnLocSet.size() > 0) {
+
+ CompositeLocation returnLoc = getLowest(methodLattice, inferFieldReturnLocSet);
+ if (returnLoc == null) {
+ // in this case, assign <'this',bottom> to the RETURNLOC
+ returnLoc = new CompositeLocation(new Location(md, md.getThis().getSymbol()));
+ returnLoc.addLocation(new Location(md.getClassDesc(), getLattice(md.getClassDesc())
+ .getBottomItem()));
+ }
+ methodInfo.setReturnLoc(returnLoc);
+
+ } else {
+ String returnLocSymbol = "RETURNLOC";
+ CompositeLocation returnLocInferLoc =
+ new CompositeLocation(new Location(md, returnLocSymbol));
+ methodInfo.setReturnLoc(returnLocInferLoc);
+
+ for (Iterator iterator = paramIdxSet.iterator(); iterator.hasNext();) {
+ Integer paramIdx = (Integer) iterator.next();
+ CompositeLocation inferLoc = mapParamToLoc.get(paramIdx);
+ String paramLocLocalSymbol = inferLoc.get(0).getLocIdentifier();
+ if (!methodLattice.isGreaterThan(paramLocLocalSymbol, returnLocSymbol)) {
+ addRelationHigherToLower(methodLattice, methodInfo, paramLocLocalSymbol,
+ returnLocSymbol);
+ }
+ }
+
+ for (Iterator iterator = returnNodeSet.iterator(); iterator.hasNext();) {
+ FlowNode returnNode = (FlowNode) iterator.next();
+ CompositeLocation inferLoc =
+ generateInferredCompositeLocation(methodInfo, fg.getLocationTuple(returnNode));
+ if (!isGreaterThan(methodLattice, inferLoc, returnLocInferLoc)) {
+ addRelation(methodLattice, methodInfo, inferLoc, returnLocInferLoc);
+ }
+ }
+
+ }
+
}
+ } catch (CyclicFlowException e) {
+ e.printStackTrace();
}
}
+ private Set<String> getHigherLocSymbolThan(SSJavaLattice<String> lattice, String loc) {
+ Set<String> higherLocSet = new HashSet<String>();
+
+ Set<String> locSet = lattice.getTable().keySet();
+ for (Iterator iterator = locSet.iterator(); iterator.hasNext();) {
+ String element = (String) iterator.next();
+ if (lattice.isGreaterThan(element, loc) && (!element.equals(lattice.getTopItem()))) {
+ higherLocSet.add(element);
+ }
+ }
+ return higherLocSet;
+ }
+
+ private CompositeLocation getLowest(SSJavaLattice<String> methodLattice,
+ Set<CompositeLocation> set) {
+
+ CompositeLocation lowest = set.iterator().next();
+
+ if (set.size() == 1) {
+ return lowest;
+ }
+
+ for (Iterator iterator = set.iterator(); iterator.hasNext();) {
+ CompositeLocation loc = (CompositeLocation) iterator.next();
+
+ if ((!loc.equals(lowest)) && (!isComparable(methodLattice, lowest, loc))) {
+ // if there is a case where composite locations are incomparable, just
+ // return null
+ return null;
+ }
+
+ if ((!loc.equals(lowest)) && isGreaterThan(methodLattice, lowest, loc)) {
+ lowest = loc;
+ }
+ }
+ return lowest;
+ }
+
+ private boolean isComparable(SSJavaLattice<String> methodLattice, CompositeLocation comp1,
+ CompositeLocation comp2) {
+
+ int size = comp1.getSize() >= comp2.getSize() ? comp2.getSize() : comp1.getSize();
+
+ for (int idx = 0; idx < size; idx++) {
+ Location loc1 = comp1.get(idx);
+ Location loc2 = comp2.get(idx);
+
+ Descriptor desc1 = loc1.getDescriptor();
+ Descriptor desc2 = loc2.getDescriptor();
+
+ if (!desc1.equals(desc2)) {
+ throw new Error("Fail to compare " + comp1 + " and " + comp2);
+ }
+
+ String symbol1 = loc1.getLocIdentifier();
+ String symbol2 = loc2.getLocIdentifier();
+
+ SSJavaLattice<String> lattice;
+ if (idx == 0) {
+ lattice = methodLattice;
+ } else {
+ lattice = getLattice(desc1);
+ }
+
+ if (symbol1.equals(symbol2)) {
+ continue;
+ } else if (!lattice.isComparable(symbol1, symbol2)) {
+ return false;
+ }
+
+ }
+
+ return true;
+ }
+
private boolean isGreaterThan(SSJavaLattice<String> methodLattice, CompositeLocation comp1,
CompositeLocation comp2) {
} else {
lattice = getLattice(desc1);
}
+
if (symbol1.equals(symbol2)) {
continue;
} else if (lattice.isGreaterThan(symbol1, symbol2)) {
for (int k = 0; k < numParam; k++) {
if (i != k) {
CompositeLocation param2 = calleeLocInfo.getParamCompositeLocation(k);
+
if (isGreaterThan(getLattice(possibleMdCallee), param1, param2)) {
NodeTupleSet argDescTupleSet1 = getNodeTupleSetByArgIdx(min, i);
NodeTupleSet argDescTupleSet2 = getNodeTupleSetByArgIdx(min, k);
for (int i = 0; i < localVarInferLoc.getSize(); i++) {
inferLoc.addLocation(localVarInferLoc.get(i));
}
- // System.out.println("@@@@@localVarInferLoc=" + localVarInferLoc);
for (int i = 1; i < tuple.size(); i++) {
Location cur = tuple.get(i);
Location inferLocElement;
if (curDesc == null) {
// in this case, we have a newly generated location.
- // System.out.println("!!! generated location=" +
- // cur.getLocIdentifier());
inferLocElement = new Location(enclosingDesc, cur.getLocIdentifier());
} else {
String fieldLocSymbol =
FlowGraph flowGraph = getFlowGraph(md);
try {
System.out.println("***** src composite case::");
- calculateCompositeLocation(flowGraph, methodLattice, methodInfo, srcNode);
+ calculateCompositeLocation(flowGraph, methodLattice, methodInfo, srcNode, null);
CompositeLocation srcInferLoc =
generateInferredCompositeLocation(methodInfo, flowGraph.getLocationTuple(srcNode));
// there is a cyclic value flow... try to calculate a composite location
// for the destination node
System.out.println("***** dst composite case::");
- calculateCompositeLocation(flowGraph, methodLattice, methodInfo, dstNode);
+ calculateCompositeLocation(flowGraph, methodLattice, methodInfo, dstNode, srcNode);
CompositeLocation srcInferLoc =
generateInferredCompositeLocation(methodInfo, flowGraph.getLocationTuple(srcNode));
CompositeLocation dstInferLoc =
}
private boolean calculateCompositeLocation(FlowGraph flowGraph,
- SSJavaLattice<String> methodLattice, MethodLocationInfo methodInfo, FlowNode flowNode)
- throws CyclicFlowException {
+ SSJavaLattice<String> methodLattice, MethodLocationInfo methodInfo, FlowNode flowNode,
+ FlowNode srcNode) throws CyclicFlowException {
Descriptor localVarDesc = flowNode.getDescTuple().get(0);
NTuple<Location> flowNodelocTuple = flowGraph.getLocationTuple(flowNode);
}
});
+ // System.out.println("prefixList=" + prefixList);
+ // System.out.println("reachableNodeSet=" + reachableNodeSet);
+
// find out reachable nodes that have the longest common prefix
for (int i = 0; i < prefixList.size(); i++) {
NTuple<Location> curPrefix = prefixList.get(i);
if (inferLocation.getTuple().startsWith(curPrefix)) {
// the same infer location is already existed. no need to do
// anything
+ System.out.println("NO ATTEMPT TO MAKE A COMPOSITE LOCATION curPrefix=" + curPrefix);
+
+ // TODO: refactoring!
+ if (srcNode != null) {
+ CompositeLocation newLoc = new CompositeLocation();
+ String newLocSymbol = "Loc" + (SSJavaLattice.seed++);
+ for (int locIdx = 0; locIdx < curPrefix.size(); locIdx++) {
+ newLoc.addLocation(curPrefix.get(locIdx));
+ }
+ Location newLocationElement = new Location(desc, newLocSymbol);
+ newLoc.addLocation(newLocationElement);
+
+ Descriptor srcLocalVar = srcNode.getDescTuple().get(0);
+ methodInfo.mapDescriptorToLocation(srcLocalVar, newLoc.clone());
+ addMapLocSymbolToInferredLocation(methodInfo.getMethodDesc(), srcLocalVar, newLoc);
+ methodInfo.removeMaplocalVarToLocSet(srcLocalVar);
+
+ // add the field/var descriptor to the set of the location symbol
+ int lastIdx = srcNode.getDescTuple().size() - 1;
+ Descriptor lastFlowNodeDesc = srcNode.getDescTuple().get(lastIdx);
+ NTuple<Location> srcNodelocTuple = flowGraph.getLocationTuple(srcNode);
+ Descriptor enclosinglastLastFlowNodeDesc = srcNodelocTuple.get(lastIdx).getDescriptor();
+
+ CompositeLocation newlyInferredLocForFlowNode =
+ generateInferredCompositeLocation(methodInfo, srcNodelocTuple);
+ Location lastInferLocElement =
+ newlyInferredLocForFlowNode.get(newlyInferredLocForFlowNode.getSize() - 1);
+ Descriptor enclosingLastInferLocElement = lastInferLocElement.getDescriptor();
+
+ // getLocationInfo(enclosingLastInferLocElement).addMapLocSymbolToDescSet(
+ // lastInferLocElement.getLocIdentifier(), lastFlowNodeDesc);
+ getLocationInfo(enclosingLastInferLocElement).addMapLocSymbolToRelatedInferLoc(
+ lastInferLocElement.getLocIdentifier(), enclosinglastLastFlowNodeDesc,
+ lastFlowNodeDesc);
+
+ System.out.println("@@@@@@@ ASSIGN " + newLoc + " to SRC=" + srcNode);
+ }
+
return true;
} else {
// assign a new composite location
}
+ System.out.println("curPrefix=" + curPrefix);
System.out.println("ASSIGN NEW COMPOSITE LOCATION =" + newInferLocation + " to "
+ flowNode);
return cd2lattice.get(cd);
}
- public void constructFlowGraph() {
+ public LinkedList<MethodDescriptor> computeMethodList() {
+
+ Set<MethodDescriptor> toSort = new HashSet<MethodDescriptor>();
setupToAnalyze();
MethodDescriptor md = toAnalyzeMethodNext();
if ((!visited.contains(md))
&& (ssjava.needTobeAnnotated(md) || reachableCallee.contains(md))) {
- if (state.SSJAVADEBUG) {
- System.out.println();
- System.out.println("SSJAVA: Constructing a flow graph: " + md);
- }
// creates a mapping from a method descriptor to virtual methods
Set<MethodDescriptor> setPossibleCallees = new HashSet<MethodDescriptor>();
mapMethodToCalleeSet.put(md, needToAnalyzeCalleeSet);
- // creates a mapping from a parameter descriptor to its index
- Map<Descriptor, Integer> mapParamDescToIdx = new HashMap<Descriptor, Integer>();
- int offset = md.isStatic() ? 0 : 1;
- for (int i = 0; i < md.numParameters(); i++) {
- Descriptor paramDesc = (Descriptor) md.getParameter(i);
- mapParamDescToIdx.put(paramDesc, new Integer(i + offset));
- }
-
- FlowGraph fg = new FlowGraph(md, mapParamDescToIdx);
- mapMethodDescriptorToFlowGraph.put(md, fg);
-
visited.add(md);
- analyzeMethodBody(cd, md);
+ toSort.add(md);
}
}
}
+ return ssjava.topologicalSort(toSort);
+
+ }
+
+ public void constructFlowGraph() {
+
+ LinkedList<MethodDescriptor> methodDescList = computeMethodList();
+
+ while (!methodDescList.isEmpty()) {
+ MethodDescriptor md = methodDescList.removeLast();
+ if (state.SSJAVADEBUG) {
+ System.out.println();
+ System.out.println("SSJAVA: Constructing a flow graph: " + md);
+
+ // creates a mapping from a parameter descriptor to its index
+ Map<Descriptor, Integer> mapParamDescToIdx = new HashMap<Descriptor, Integer>();
+ int offset = 0;
+ if (!md.isStatic()) {
+ offset = 1;
+ mapParamDescToIdx.put(md.getThis(), 0);
+ }
+
+ for (int i = 0; i < md.numParameters(); i++) {
+ Descriptor paramDesc = (Descriptor) md.getParameter(i);
+ mapParamDescToIdx.put(paramDesc, new Integer(i + offset));
+ }
+
+ FlowGraph fg = new FlowGraph(md, mapParamDescToIdx);
+ mapMethodDescriptorToFlowGraph.put(md, fg);
+
+ analyzeMethodBody(md.getClassDesc(), md);
+ }
+ }
_debug_printGraph();
+
}
private void analyzeMethodBody(ClassDescriptor cd, MethodDescriptor md) {
// annotate the elements of the node set as the return location
for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
NTuple<Descriptor> returnDescTuple = (NTuple<Descriptor>) iterator.next();
- fg.setReturnFlowNode(returnDescTuple);
+ fg.addReturnFlowNode(returnDescTuple);
for (Iterator iterator2 = implicitFlowTupleSet.iterator(); iterator2.hasNext();) {
NTuple<Descriptor> implicitFlowDescTuple = (NTuple<Descriptor>) iterator2.next();
fg.addValueFlowEdge(implicitFlowDescTuple, returnDescTuple);
analyzeFlowExpressionNode(md, nametable, isn.getCondition(), condTupleNode, null,
implicitFlowTupleSet, false);
+// NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+// for (Iterator<NTuple<Descriptor>> idxIter = condTupleNode.iterator(); idxIter.hasNext();) {
+// NTuple<Descriptor> tuple = idxIter.next();
+// addFlowGraphEdge(md, tuple, interTuple);
+// }
+//
+// for (Iterator<NTuple<Descriptor>> idxIter = implicitFlowTupleSet.iterator(); idxIter.hasNext();) {
+// NTuple<Descriptor> tuple = idxIter.next();
+// addFlowGraphEdge(md, tuple, interTuple);
+// }
+//
+// NodeTupleSet newImplicitSet = new NodeTupleSet();
+// newImplicitSet.addTuple(interTuple);
+// analyzeFlowBlockNode(md, nametable, isn.getTrueBlock(), newImplicitSet);
+//
+// if (isn.getFalseBlock() != null) {
+// analyzeFlowBlockNode(md, nametable, isn.getFalseBlock(), newImplicitSet);
+// }
+
// add edges from condNodeTupleSet to all nodes of conditional nodes
condTupleNode.addTupleSet(implicitFlowTupleSet);
analyzeFlowBlockNode(md, nametable, isn.getTrueBlock(), condTupleNode);
break;
case Kind.MethodInvokeNode:
- analyzeFlowMethodInvokeNode(md, nametable, (MethodInvokeNode) en, implicitFlowTupleSet);
+ analyzeFlowMethodInvokeNode(md, nametable, (MethodInvokeNode) en, nodeSet,
+ implicitFlowTupleSet);
break;
case Kind.TertiaryNode:
set.add(min);
}
+ private void addParamNodeFlowingToReturnValue(MethodDescriptor md, FlowNode fn) {
+
+ if (!mapMethodDescToParamNodeFlowsToReturnValue.containsKey(md)) {
+ mapMethodDescToParamNodeFlowsToReturnValue.put(md, new HashSet<FlowNode>());
+ }
+ mapMethodDescToParamNodeFlowsToReturnValue.get(md).add(fn);
+ }
+
+ private Set<FlowNode> getParamNodeFlowingToReturnValue(MethodDescriptor md) {
+ return mapMethodDescToParamNodeFlowsToReturnValue.get(md);
+ }
+
private void analyzeFlowMethodInvokeNode(MethodDescriptor md, SymbolTable nametable,
- MethodInvokeNode min, NodeTupleSet implicitFlowTupleSet) {
+ MethodInvokeNode min, NodeTupleSet nodeSet, NodeTupleSet implicitFlowTupleSet) {
+
+ if (nodeSet == null) {
+ nodeSet = new NodeTupleSet();
+ }
addMapCallerMethodDescToMethodInvokeNodeSet(md, min);
- MethodDescriptor calleeMD = min.getMethod();
+ MethodDescriptor calleeMethodDesc = min.getMethod();
NameDescriptor baseName = min.getBaseName();
boolean isSystemout = false;
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) && !isSystemout) {
+
+ FlowGraph calleeFlowGraph = getFlowGraph(calleeMethodDesc);
+ Set<FlowNode> calleeReturnSet = calleeFlowGraph.getReturnNodeSet();
- // CompositeLocation baseLocation = null;
if (min.getExpression() != null) {
NodeTupleSet baseNodeSet = new NodeTupleSet();
analyzeFlowExpressionNode(md, nametable, min.getExpression(), baseNodeSet, null,
implicitFlowTupleSet, false);
- } else {
- if (min.getMethod().isStatic()) {
- // String globalLocId = ssjava.getMethodLattice(md).getGlobalLoc();
- // if (globalLocId == null) {
- // throw new
- // Error("Method lattice does not define global variable location at "
- // + generateErrorMessage(md.getClassDesc(), min));
- // }
- // baseLocation = new CompositeLocation(new Location(md,
- // globalLocId));
- } else {
- // 'this' var case
- // String thisLocId = ssjava.getMethodLattice(md).getThisLoc();
- // baseLocation = new CompositeLocation(new Location(md, thisLocId));
+ if (!min.getMethod().isStatic()) {
+ addArgIdxMap(min, 0, baseNodeSet);
+
+ for (Iterator iterator = calleeReturnSet.iterator(); iterator.hasNext();) {
+ FlowNode returnNode = (FlowNode) iterator.next();
+ NTuple<Descriptor> returnDescTuple = returnNode.getDescTuple();
+ if (returnDescTuple.startsWith(calleeMethodDesc.getThis())) {
+ // the location type of the return value is started with 'this'
+ // reference
+ for (Iterator<NTuple<Descriptor>> baseIter = baseNodeSet.iterator(); baseIter
+ .hasNext();) {
+ NTuple<Descriptor> baseTuple = baseIter.next();
+ NTuple<Descriptor> inFlowTuple = new NTuple<Descriptor>(baseTuple.getList());
+ inFlowTuple.addAll(returnDescTuple.subList(1, returnDescTuple.size()));
+ nodeSet.addTuple(inFlowTuple);
+ }
+ } else {
+ Set<FlowNode> inFlowSet = calleeFlowGraph.getIncomingFlowNodeSet(returnNode);
+ for (Iterator iterator2 = inFlowSet.iterator(); iterator2.hasNext();) {
+ FlowNode inFlowNode = (FlowNode) iterator2.next();
+ if (inFlowNode.getDescTuple().startsWith(calleeMethodDesc.getThis())) {
+ nodeSet.addTupleSet(baseNodeSet);
+ }
+ }
+ }
+ }
}
}
- // constraint case:
- // 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);
- // }
- // }
+ // analyze parameter flows
- analyzeFlowMethodParameters(md, nametable, min);
+ if (min.numArgs() > 0) {
- // checkCalleeConstraints(md, nametable, min, baseLocation, constraint);
+ int offset;
+ if (min.getMethod().isStatic()) {
+ offset = 0;
+ } else {
+ offset = 1;
+ }
- // checkCallerArgumentLocationConstraints(md, nametable, min,
- // baseLocation, constraint);
+ for (int i = 0; i < min.numArgs(); i++) {
+ ExpressionNode en = min.getArg(i);
+ int idx = i + offset;
+ NodeTupleSet argTupleSet = new NodeTupleSet();
+ analyzeFlowExpressionNode(md, nametable, en, argTupleSet, true);
+ // if argument is liternal node, argTuple is set to NULL.
+ addArgIdxMap(min, idx, argTupleSet);
+ FlowNode paramNode = calleeFlowGraph.getParamFlowNode(idx);
+ if (hasInFlowTo(calleeFlowGraph, paramNode, calleeReturnSet)
+ || calleeMethodDesc.getModifiers().isNative()) {
+ addParamNodeFlowingToReturnValue(calleeMethodDesc, paramNode);
+ nodeSet.addTupleSet(argTupleSet);
+ }
+ }
- if (min.getMethod().getReturnType() != null && !min.getMethod().getReturnType().isVoid()) {
- // If method has a return value, compute the highest possible return
- // location in the caller's perspective
- // CompositeLocation ceilingLoc =
- // computeCeilingLocationForCaller(md, nametable, min, baseLocation,
- // constraint);
- // return ceilingLoc;
}
+
}
- // return new CompositeLocation(Location.createTopLocation(md));
+ }
+ private boolean hasInFlowTo(FlowGraph fg, FlowNode inNode, Set<FlowNode> nodeSet) {
+ // return true if inNode has in-flows to nodeSet
+ Set<FlowNode> reachableSet = fg.getReachableFlowNodeSet(inNode);
+ for (Iterator iterator = reachableSet.iterator(); iterator.hasNext();) {
+ FlowNode fn = (FlowNode) iterator.next();
+ if (nodeSet.contains(fn)) {
+ return true;
+ }
+ }
+ return false;
}
private NodeTupleSet getNodeTupleSetByArgIdx(MethodInvokeNode min, int idx) {
}
private void analyzeFlowMethodParameters(MethodDescriptor callermd, SymbolTable nametable,
- MethodInvokeNode min) {
+ MethodInvokeNode min, NodeTupleSet nodeSet) {
if (min.numArgs() > 0) {
offset = 0;
} else {
offset = 1;
- NTuple<Descriptor> thisArgTuple = new NTuple<Descriptor>();
- thisArgTuple.add(callermd.getThis());
- NodeTupleSet argTupleSet = new NodeTupleSet();
- argTupleSet.addTuple(thisArgTuple);
- addArgIdxMap(min, 0, argTupleSet);
+ // NTuple<Descriptor> thisArgTuple = new NTuple<Descriptor>();
+ // thisArgTuple.add(callermd.getThis());
+ // NodeTupleSet argTupleSet = new NodeTupleSet();
+ // argTupleSet.addTuple(thisArgTuple);
+ // addArgIdxMap(min, 0, argTupleSet);
+ // nodeSet.addTuple(thisArgTuple);
}
for (int i = 0; i < min.numArgs(); i++) {
analyzeFlowExpressionNode(callermd, nametable, en, argTupleSet, false);
// if argument is liternal node, argTuple is set to NULL.
addArgIdxMap(min, i + offset, argTupleSet);
+ nodeSet.addTupleSet(argTupleSet);
}
}
ArrayAccessNode aan, NodeTupleSet nodeSet, boolean isLHS) {
NodeTupleSet expNodeTupleSet = new NodeTupleSet();
- analyzeFlowExpressionNode(md, nametable, aan.getExpression(), expNodeTupleSet, isLHS);
+ NTuple<Descriptor> base =
+ analyzeFlowExpressionNode(md, nametable, aan.getExpression(), expNodeTupleSet, isLHS);
NodeTupleSet idxNodeTupleSet = new NodeTupleSet();
analyzeFlowExpressionNode(md, nametable, aan.getIndex(), idxNodeTupleSet, isLHS);
}
}
-
getFlowGraph(md).createNewFlowNode(base);
return base;
}
NodeTupleSet idxNodeTupleSet = new NodeTupleSet();
+
if (left instanceof ArrayAccessNode) {
ArrayAccessNode aan = (ArrayAccessNode) left;
left = aan.getExpression();
analyzeFlowExpressionNode(md, nametable, aan.getIndex(), idxNodeTupleSet, base,
implicitFlowTupleSet, isLHS);
+
nodeSet.addTupleSet(idxNodeTupleSet);
}
base =
if (an.getOperation().getOp() >= 2 && an.getOperation().getOp() <= 12) {
// if assignment contains OP+EQ operator, creates edges from LHS to LHS
+
for (Iterator<NTuple<Descriptor>> iter = nodeSetLHS.iterator(); iter.hasNext();) {
NTuple<Descriptor> fromTuple = iter.next();
for (Iterator<NTuple<Descriptor>> iter2 = nodeSetLHS.iterator(); iter2.hasNext();) {
}
// creates edges from RHS to LHS
+ NTuple<Descriptor> interTuple = null;
+ if (nodeSetRHS.size() > 1) {
+ interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ }
+
for (Iterator<NTuple<Descriptor>> iter = nodeSetRHS.iterator(); iter.hasNext();) {
NTuple<Descriptor> fromTuple = iter.next();
for (Iterator<NTuple<Descriptor>> iter2 = nodeSetLHS.iterator(); iter2.hasNext();) {
NTuple<Descriptor> toTuple = iter2.next();
- addFlowGraphEdge(md, fromTuple, toTuple);
+ addFlowGraphEdge(md, fromTuple, interTuple, toTuple);
}
}
} else {
// postinc case
+
for (Iterator<NTuple<Descriptor>> iter2 = nodeSetLHS.iterator(); iter2.hasNext();) {
NTuple<Descriptor> tuple = iter2.next();
addFlowGraphEdge(md, tuple, tuple);
private boolean addFlowGraphEdge(MethodDescriptor md, NTuple<Descriptor> from,
NTuple<Descriptor> to) {
- // TODO
- // return true if it adds a new edge
FlowGraph graph = getFlowGraph(md);
graph.addValueFlowEdge(from, to);
return true;
}
+ private void addFlowGraphEdge(MethodDescriptor md, NTuple<Descriptor> from,
+ NTuple<Descriptor> inter, NTuple<Descriptor> to) {
+
+ FlowGraph graph = getFlowGraph(md);
+
+ if (inter != null) {
+ graph.addValueFlowEdge(from, inter);
+ graph.addValueFlowEdge(inter, to);
+ } else {
+ graph.addValueFlowEdge(from, to);
+ }
+
+ }
+
public void _debug_printGraph() {
Set<MethodDescriptor> keySet = mapMethodDescriptorToFlowGraph.keySet();
class CyclicFlowException extends Exception {
}
+
+class InterDescriptor extends Descriptor {
+
+ public InterDescriptor(String name) {
+ super(name);
+ }
+
+}
projects / IRC.git / blobdiff