From c23b147701988827b3b12133349c649510a04ecf Mon Sep 17 00:00:00 2001 From: yeom Date: Sun, 28 Oct 2012 08:13:39 +0000 Subject: [PATCH] changes. --- Robust/src/Analysis/SSJava/BuildLattice.java | 41 +- Robust/src/Analysis/SSJava/FlowDownCheck.java | 16 +- Robust/src/Analysis/SSJava/FlowGraph.java | 47 +- .../src/Analysis/SSJava/FlowReturnNode.java | 2 +- .../Analysis/SSJava/LocationInference.java | 670 +++++++++++------- .../src/Analysis/SSJava/SSJavaAnalysis.java | 2 +- 6 files changed, 474 insertions(+), 304 deletions(-) diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java index fdf3d89d..5641104a 100644 --- a/Robust/src/Analysis/SSJava/BuildLattice.java +++ b/Robust/src/Analysis/SSJava/BuildLattice.java @@ -160,11 +160,11 @@ public class BuildLattice { Map mapIntermediateLoc = new HashMap(); - System.out.println("*insert=" + desc); - System.out.println("***nodeSet=" + nodeSet); + // System.out.println("*insert=" + desc); + // System.out.println("***nodeSet=" + nodeSet); for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { HNode node = (HNode) iterator.next(); - System.out.println("node=" + node); + // System.out.println("node=" + node); if (node.isSkeleton() && (!visited.contains(node))) { visited.add(node); @@ -259,7 +259,7 @@ public class BuildLattice { HNode sharedNode = (HNode) iterator.next(); TripleItem item = mapSharedNodeToTripleItem.get(sharedNode); String nonSharedLocName = mapIntermediateLoc.get(item); - System.out.println("sharedNode=" + sharedNode + " locName=" + nonSharedLocName); + // System.out.println("sharedNode=" + sharedNode + " locName=" + nonSharedLocName); String newLocName; if (locSummary.getHNodeNameSetByLatticeLoationName(nonSharedLocName) != null @@ -272,8 +272,8 @@ public class BuildLattice { Set belowElementSet = new HashSet(); belowElementSet.addAll(lattice.get(nonSharedLocName)); - System.out.println("nonSharedLocName=" + nonSharedLocName + " belowElementSet=" - + belowElementSet + " newLocName=" + newLocName); + // System.out.println("nonSharedLocName=" + nonSharedLocName + " belowElementSet=" + // + belowElementSet + " newLocName=" + newLocName); lattice.insertNewLocationBetween(nonSharedLocName, belowElementSet, newLocName); } else { @@ -315,7 +315,7 @@ public class BuildLattice { Set visited, Map mapIntermediateLoc, LocationSummary locSummary, HNode cnode) { - System.out.println("expandCombinationNode=" + cnode); + // System.out.println("expandCombinationNode=" + cnode); // expand the combination node 'outNode' // here we need to expand the corresponding combination location in the lattice HNode combinationNodeInSCGraph = getCombinationNodeInSCGraph(desc, cnode); @@ -343,7 +343,7 @@ public class BuildLattice { // follows the straight line up to another skeleton/combination node if (endCombNodeSet.size() > 0) { - System.out.println("---endCombNodeSet=" + endCombNodeSet); + // System.out.println("---endCombNodeSet=" + endCombNodeSet); endCombNodeSet = removeTransitivelyReachToNode(desc, combinationNodeInSCGraph, endCombNodeSet); @@ -392,8 +392,9 @@ public class BuildLattice { private HNode getDirectlyReachableSCNodeFromEndNode(HierarchyGraph scGraph, HNode startNode, Set endNodeSet) { - System.out.println("getDirectlyReachableSCNodeFromEndNode start=" + startNode + " endNodeSet=" - + endNodeSet); + // System.out.println("getDirectlyReachableSCNodeFromEndNode start=" + startNode + + // " endNodeSet=" + // + endNodeSet); Set newStartNodeSet = new HashSet(); for (Iterator iterator = endNodeSet.iterator(); iterator.hasNext();) { @@ -408,7 +409,7 @@ public class BuildLattice { } } - System.out.println("newStartNodeSet=" + newStartNodeSet); + // System.out.println("newStartNodeSet=" + newStartNodeSet); if (newStartNodeSet.size() == 0) { newStartNodeSet.add(startNode); @@ -438,14 +439,14 @@ public class BuildLattice { private HNode getDirectlyReachableNodeFromStartNodeReachToEndNode(HierarchyGraph scGraph, HNode startNode, HNode endNode) { - System.out.println("getDirectlyReachableNodeFromStartNodeReachToEndNode start=" + startNode - + " end=" + endNode); + // System.out.println("getDirectlyReachableNodeFromStartNodeReachToEndNode start=" + startNode + // + " end=" + endNode); Set connected = new HashSet(); recurDirectlyReachableNodeFromStartNodeReachToEndNode(scGraph, startNode, endNode, connected); if (connected.size() == 0) { connected.add(endNode); } - System.out.println("connected=" + connected); + // System.out.println("connected=" + connected); return connected.iterator().next(); } @@ -514,9 +515,9 @@ public class BuildLattice { locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName); } - System.out.println("-TripleItem=" + item); - System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() - + " locName=" + locName); + // System.out.println("-TripleItem=" + item); + // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() + // + " locName=" + locName); Set outSet = graph.getOutgoingNodeSet(curNode); for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) { @@ -584,9 +585,9 @@ public class BuildLattice { locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName); } - System.out.println("-TripleItem=" + item); - System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() - + " locName=" + locName); + // System.out.println("-TripleItem=" + item); + // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() + // + " locName=" + locName); Set outSet = graph.getOutgoingNodeSet(curNode); for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) { diff --git a/Robust/src/Analysis/SSJava/FlowDownCheck.java b/Robust/src/Analysis/SSJava/FlowDownCheck.java index eb7cf77b..4dd4eaf2 100644 --- a/Robust/src/Analysis/SSJava/FlowDownCheck.java +++ b/Robust/src/Analysis/SSJava/FlowDownCheck.java @@ -1032,7 +1032,7 @@ public class FlowDownCheck { if (!argLocation.get(0).isTop() && CompositeLattice.compare(argLocation, constraint, true, - generateErrorMessage(cd, min)) == ComparisonResult.LESS) { + generateErrorMessage(cd, min)) == ComparisonResult.GREATER) { CompositeLocation paramLocation = calleeParamList.get(idx); @@ -1054,16 +1054,16 @@ public class FlowDownCheck { + " paramCompareResult=" + paramCompareResult); if (!(paramLocation.get(0).equals(calleePCLOC.get(0)) && calleePCLOC.getSize() > 1) - && paramCompareResult != ComparisonResult.LESS) { + && paramCompareResult != ComparisonResult.GREATER) { throw new Error( - "The program counter location " - + constraint - + " is lower than the argument(idx=" + "The argument(idx=" + idx + ") location " + argLocation + + "is higher than the caller program counter location " + + constraint + ". Need to specify that the initial PC location of the callee, which is currently set to " - + calleePCLOC + ", is lower than " + paramLocation + " in the method " + + calleePCLOC + ", is not higher than " + paramLocation + " in the method " + calleeMethodDesc.getSymbol() + ":" + min.getNumLine()); } @@ -1367,11 +1367,11 @@ public class FlowDownCheck { SymbolTable nametable, ArrayAccessNode aan, CompositeLocation constraint, boolean isLHS) { System.out.println("aan=" + aan.printNode(0) + " line#=" + aan.getNumLine()); ClassDescriptor cd = md.getClassDesc(); - System.out.println("aan.getExpression()=" +aan.getExpression().getClass()); + System.out.println("aan.getExpression()=" + aan.getExpression().getClass()); CompositeLocation arrayLoc = checkLocationFromExpressionNode(md, nametable, aan.getExpression(), new CompositeLocation(), constraint, isLHS); -System.out.println("HERE?"); + System.out.println("HERE?"); // addTypeLocation(aan.getExpression().getType(), arrayLoc); CompositeLocation indexLoc = checkLocationFromExpressionNode(md, nametable, aan.getIndex(), new CompositeLocation(), diff --git a/Robust/src/Analysis/SSJava/FlowGraph.java b/Robust/src/Analysis/SSJava/FlowGraph.java index f553fccf..f71b82d0 100644 --- a/Robust/src/Analysis/SSJava/FlowGraph.java +++ b/Robust/src/Analysis/SSJava/FlowGraph.java @@ -383,12 +383,28 @@ public class FlowGraph { Set outEdgeSet = getOutEdgeSet(fn); for (Iterator iterator = outEdgeSet.iterator(); iterator.hasNext();) { FlowEdge edge = (FlowEdge) iterator.next(); - FlowNode dstNode = edge.getDst(); + FlowNode originalDstNode = edge.getDst(); + + Set dstNodeSet = new HashSet(); + if (originalDstNode instanceof FlowReturnNode) { + FlowReturnNode rnode = (FlowReturnNode) originalDstNode; + Set> rtupleSet = rnode.getReturnTupleSet(); + for (Iterator iterator2 = rtupleSet.iterator(); iterator2.hasNext();) { + NTuple rtuple = (NTuple) iterator2.next(); + dstNodeSet.add(getFlowNode(rtuple)); + } + } else { + dstNodeSet.add(originalDstNode); + } - if (!visited.contains(dstNode)) { - visited.add(dstNode); - recurLocalReachFlowNodeSet(dstNode, visited); + for (Iterator iterator2 = dstNodeSet.iterator(); iterator2.hasNext();) { + FlowNode dstNode = (FlowNode) iterator2.next(); + if (!visited.contains(dstNode)) { + visited.add(dstNode); + recurLocalReachFlowNodeSet(dstNode, visited); + } } + } } @@ -421,10 +437,25 @@ public class FlowGraph { Set nodeSet = getNodeSet(); for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { - FlowNode flowNode = (FlowNode) iterator.next(); - if (flowNode.getCurrentDescTuple().startsWith(prefix)) { - recurReachableSetFrom(flowNode, reachableSet); + FlowNode originalSrcNode = (FlowNode) iterator.next(); + + Set srcNodeSet = new HashSet(); + if (originalSrcNode instanceof FlowReturnNode) { + FlowReturnNode rnode = (FlowReturnNode) originalSrcNode; + Set> rtupleSet = rnode.getReturnTupleSet(); + for (Iterator iterator2 = rtupleSet.iterator(); iterator2.hasNext();) { + NTuple rtuple = (NTuple) iterator2.next(); + if (rtuple.startsWith(prefix)) { + System.out.println("rtuple=" + rtuple + " give it to recur=" + originalSrcNode); + recurReachableSetFrom(originalSrcNode, reachableSet); + } + } + } else { + if (originalSrcNode.getCurrentDescTuple().startsWith(prefix)) { + recurReachableSetFrom(originalSrcNode, reachableSet); + } } + } return reachableSet; @@ -566,7 +597,7 @@ public class FlowGraph { if (incomingNode instanceof FlowReturnNode) { FlowReturnNode rnode = (FlowReturnNode) incomingNode; - Set> nodeTupleSet = rnode.getTupleSet(); + Set> nodeTupleSet = rnode.getReturnTupleSet(); for (Iterator iterator3 = nodeTupleSet.iterator(); iterator3.hasNext();) { NTuple nodeTuple = (NTuple) iterator3.next(); FlowNode fn = getFlowNode(nodeTuple); diff --git a/Robust/src/Analysis/SSJava/FlowReturnNode.java b/Robust/src/Analysis/SSJava/FlowReturnNode.java index a2807802..b14d0d5c 100644 --- a/Robust/src/Analysis/SSJava/FlowReturnNode.java +++ b/Robust/src/Analysis/SSJava/FlowReturnNode.java @@ -35,7 +35,7 @@ public class FlowReturnNode extends FlowNode { returnTupleSet.add(in); } - public Set> getTupleSet() { + public Set> getReturnTupleSet() { return returnTupleSet; } diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java index a3bee185..2e7e9004 100644 --- a/Robust/src/Analysis/SSJava/LocationInference.java +++ b/Robust/src/Analysis/SSJava/LocationInference.java @@ -271,6 +271,8 @@ public class LocationInference { debug_writeHierarchyDotFiles(); + // System.exit(0); + simplifyHierarchyGraph(); debug_writeSimpleHierarchyDotFiles(); @@ -479,14 +481,14 @@ public class LocationInference { translateMapLocationToInferCompositeLocationToCalleeGraph(callerGlobalFlowGraph, min); MethodDescriptor mdCallee = min.getMethod(); calleeSet.add(mdCallee); - - FlowGraph calleeFlowGraph = getFlowGraph(mdCallee); - - NTuple methodInvokeBaseDescTuple = mapMethodInvokeNodeToBaseTuple.get(min); - NTuple methodInvokeBaseLocTuple = null; - if (methodInvokeBaseDescTuple != null) { - methodInvokeBaseLocTuple = translateToLocTuple(mdCaller, methodInvokeBaseDescTuple); - } + // + // FlowGraph calleeFlowGraph = getFlowGraph(mdCallee); + // + // NTuple methodInvokeBaseDescTuple = mapMethodInvokeNodeToBaseTuple.get(min); + // NTuple methodInvokeBaseLocTuple = null; + // if (methodInvokeBaseDescTuple != null) { + // methodInvokeBaseLocTuple = translateToLocTuple(mdCaller, methodInvokeBaseDescTuple); + // } // //////////////// // //////////////// @@ -495,72 +497,74 @@ public class LocationInference { // need to assign a proper composite location to the corresponding callee parameter // System.out.println("---translate arg composite location to callee param. min=" // + min.printNode(0)); - Map> mapIdxToArgTuple = mapMethodInvokeNodeToArgIdxMap.get(min); - Set idxSet = mapIdxToArgTuple.keySet(); - for (Iterator iterator2 = idxSet.iterator(); iterator2.hasNext();) { - Integer idx = (Integer) iterator2.next(); - - if (idx == 0 && !min.getMethod().isStatic()) { - continue; - } - - NTuple argTuple = mapIdxToArgTuple.get(idx); - if (argTuple.size() > 0) { - // check if an arg tuple has been already assigned to a composite location - NTuple argLocTuple = translateToLocTuple(mdCaller, argTuple); - Location argLocalLoc = argLocTuple.get(0); - - // if (!isPrimitiveType(argTuple)) { - if (callerMapLocToCompLoc.containsKey(argLocalLoc)) { - - CompositeLocation argLocalCompositeLocation = callerMapLocToCompLoc.get(argLocalLoc); - CompositeLocation argCompLoc = argLocalCompositeLocation.clone(); - for (int i = 1; i < argLocTuple.size(); i++) { - argCompLoc.addLocation(argLocTuple.get(i)); - } - - FlowNode calleeParamFlowNode = calleeFlowGraph.getParamFlowNode(idx); - - System.out - .println("----- argLocTuple=" + argLocTuple + " argLocalLoc=+" + argLocalLoc); - System.out.println("-------need to translate argCompLoc=" + argCompLoc - + " with baseTuple=" + methodInvokeBaseLocTuple + " calleeParamLocTuple=" - + calleeParamFlowNode); - - // CompositeLocation paramCompLoc = translateArgCompLocToParamCompLoc(min, argCompLoc); - // calleeParamFlowNode.setCompositeLocation(paramCompLoc); - - // if (baseLocTuple != null && callerCompLoc.getTuple().startsWith(baseLocTuple)) { - // - // FlowNode calleeParamFlowNode = calleeFlowGraph.getParamFlowNode(idx); - // NTuple calleeParamDescTuple = calleeParamFlowNode.getDescTuple(); - // NTuple calleeParamLocTuple - // =###translateCompositeLocationAssignmentToFlowGraph mdCaller=public static void - // huffcodetab.huffman_decoder(int htIdx, int x, BitReserve br) - - // translateToLocTuple(mdCallee, calleeParamDescTuple); - // - // System.out.println("---need to translate callerCompLoc=" + callerCompLoc - // + " with baseTuple=" + baseLocTuple + " calleeParamLocTuple=" - // + calleeParamLocTuple); - // - // CompositeLocation newCalleeCompLoc = - // translateCompositeLocationToCallee(callerCompLoc, baseLocTuple, mdCallee); - // - // calleeGlobalGraph.addMapLocationToInferCompositeLocation(calleeParamLocTuple.get(0), - // newCalleeCompLoc); - // - // System.out.println("---callee loc=" + calleeParamLocTuple.get(0) - // + " newCalleeCompLoc=" + newCalleeCompLoc); - // - // // System.out.println("###need to assign composite location to=" + - // // calleeParamDescTuple - // // + " with baseTuple=" + baseLocTuple); - // } + // Map> mapIdxToArgTuple = + // mapMethodInvokeNodeToArgIdxMap.get(min); + // Set idxSet = mapIdxToArgTuple.keySet(); + // for (Iterator iterator2 = idxSet.iterator(); iterator2.hasNext();) { + // Integer idx = (Integer) iterator2.next(); + // + // if (idx == 0 && !min.getMethod().isStatic()) { + // continue; + // } + // + // NTuple argTuple = mapIdxToArgTuple.get(idx); + // if (argTuple.size() > 0) { + // // check if an arg tuple has been already assigned to a composite location + // NTuple argLocTuple = translateToLocTuple(mdCaller, argTuple); + // Location argLocalLoc = argLocTuple.get(0); + // + // // if (!isPrimitiveType(argTuple)) { + // if (callerMapLocToCompLoc.containsKey(argLocalLoc)) { + // + // CompositeLocation argLocalCompositeLocation = callerMapLocToCompLoc.get(argLocalLoc); + // CompositeLocation argCompLoc = argLocalCompositeLocation.clone(); + // for (int i = 1; i < argLocTuple.size(); i++) { + // argCompLoc.addLocation(argLocTuple.get(i)); + // } + // + // FlowNode calleeParamFlowNode = calleeFlowGraph.getParamFlowNode(idx); + // + // System.out + // .println("----- argLocTuple=" + argLocTuple + " argLocalLoc=+" + argLocalLoc); + // System.out.println("-------need to translate argCompLoc=" + argCompLoc + // + " with baseTuple=" + methodInvokeBaseLocTuple + " calleeParamLocTuple=" + // + calleeParamFlowNode); + // + // // CompositeLocation paramCompLoc = translateArgCompLocToParamCompLoc(min, argCompLoc); + // // calleeParamFlowNode.setCompositeLocation(paramCompLoc); + // + // // if (baseLocTuple != null && callerCompLoc.getTuple().startsWith(baseLocTuple)) { + // // + // // FlowNode calleeParamFlowNode = calleeFlowGraph.getParamFlowNode(idx); + // // NTuple calleeParamDescTuple = calleeParamFlowNode.getDescTuple(); + // // NTuple calleeParamLocTuple + // // =###translateCompositeLocationAssignmentToFlowGraph mdCaller=public static void + // // huffcodetab.huffman_decoder(int htIdx, int x, BitReserve br) + // + // // translateToLocTuple(mdCallee, calleeParamDescTuple); + // // + // // System.out.println("---need to translate callerCompLoc=" + callerCompLoc + // // + " with baseTuple=" + baseLocTuple + " calleeParamLocTuple=" + // // + calleeParamLocTuple); + // // + // // CompositeLocation newCalleeCompLoc = + // // translateCompositeLocationToCallee(callerCompLoc, baseLocTuple, mdCallee); + // // + // // calleeGlobalGraph.addMapLocationToInferCompositeLocation(calleeParamLocTuple.get(0), + // // newCalleeCompLoc); + // // + // // System.out.println("---callee loc=" + calleeParamLocTuple.get(0) + // // + " newCalleeCompLoc=" + newCalleeCompLoc); + // // + // // // System.out.println("###need to assign composite location to=" + + // // // calleeParamDescTuple + // // // + " with baseTuple=" + baseLocTuple); + // // } + // + // } + // } + // } - } - } - } } // //////////////// // //////////////// @@ -831,10 +835,14 @@ public class LocationInference { translateCompositeLocationToCallee(callerCompLoc, baseLocTuple, mdCallee); calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, newCalleeCompLoc); - // System.out.println("---key=" + key + " callerCompLoc=" + callerCompLoc - // + " newCalleeCompLoc=" + newCalleeCompLoc); + System.out.println("1---key=" + key + " callerCompLoc=" + callerCompLoc + + " newCalleeCompLoc=" + newCalleeCompLoc); + System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); + if (!newCalleeCompLoc.get(0).getDescriptor().equals(mdCallee)) { + System.exit(0); + } + // System.out.println("-----baseLoctuple=" + baseLocTuple); - // System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); } else { // check if it is the global access Location compLocFirstElement = callerCompLoc.getTuple().get(0); @@ -849,16 +857,22 @@ public class LocationInference { newCalleeCompLoc.addLocation(callerCompLoc.get(i)); } calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, newCalleeCompLoc); - // System.out.println("---key=" + key + " callerCompLoc=" + callerCompLoc - // + " newCalleeCompLoc=" + newCalleeCompLoc); - // System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); + System.out.println("2---key=" + key + " callerCompLoc=" + callerCompLoc + + " newCalleeCompLoc=" + newCalleeCompLoc); + System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); } else { int paramIdx = getParamIdx(callerCompLoc, mapIdxToArgTuple); if (paramIdx == -1) { - System.out.println("*****key=" + key + " callerCompLoc=" + callerCompLoc); + // System.out.println("*****key=" + key + " callerCompLoc=" + callerCompLoc); if (!calleeGlobalGraph.contrainsInferCompositeLocationMapKey(key)) { - calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, callerCompLoc); + // calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, callerCompLoc); + System.out.println("3---key=" + key + " callerCompLoc=" + callerCompLoc + + " newCalleeCompLoc=" + callerCompLoc); + System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); + if (!callerCompLoc.get(0).getDescriptor().equals(mdCallee)) { + System.exit(0); + } } continue; } @@ -875,11 +889,14 @@ public class LocationInference { newCalleeCompLoc.addLocation(callerCompLoc.get(i)); } calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, newCalleeCompLoc); - System.out.println("---key=" + key + " callerCompLoc=" + callerCompLoc + System.out.println("4---key=" + key + " callerCompLoc=" + callerCompLoc + " newCalleeCompLoc=" + newCalleeCompLoc); - System.out.println("-----argTuple=" + argTuple + " caller=" + mdCaller + " callee=" - + mdCallee); - System.out.println("-----paramIdx=" + paramIdx + " paramFlowNode=" + paramFlowNode); + System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); + + // System.out.println("-----argTuple=" + argTuple + " caller=" + mdCaller + + // " callee=" + // + mdCallee); + // System.out.println("-----paramIdx=" + paramIdx + " paramFlowNode=" + paramFlowNode); } @@ -970,9 +987,18 @@ public class LocationInference { calleeGlobalGraph.addMapLocationToInferCompositeLocation(calleeParamLocTuple.get(0), newCalleeCompLoc); + calleeParamFlowNode.setCompositeLocation(newCalleeCompLoc); System.out.println("-----------key=" + calleeParamLocTuple.get(0) + " callerCompLoc=" + callerCompLoc + " newCalleeCompLoc=" + newCalleeCompLoc); + } else { + CompositeLocation newCalleeCompLoc = + calculateCompositeLocationFromSubGlobalGraph(mdCallee, calleeParamFlowNode); + if (newCalleeCompLoc != null) { + calleeGlobalGraph.addMapLocationToInferCompositeLocation(calleeParamLocTuple.get(0), + newCalleeCompLoc); + calleeParamFlowNode.setCompositeLocation(newCalleeCompLoc); + } } System.out.println("-----------------calleeParamFlowNode=" @@ -987,6 +1013,101 @@ public class LocationInference { } + private CompositeLocation calculateCompositeLocationFromSubGlobalGraph(MethodDescriptor md, + FlowNode paramNode) { + + System.out.println("#############################################################"); + System.out.println("calculateCompositeLocationFromSubGlobalGraph=" + paramNode); + + GlobalFlowGraph subGlobalFlowGraph = getSubGlobalFlowGraph(md); + NTuple paramLocTuple = translateToLocTuple(md, paramNode.getDescTuple()); + GlobalFlowNode paramGlobalNode = subGlobalFlowGraph.getFlowNode(paramLocTuple); + + List> prefixList = calculatePrefixList(subGlobalFlowGraph, paramGlobalNode); + + Location prefixLoc = paramLocTuple.get(0); + + Set reachableNodeSet = + subGlobalFlowGraph.getReachableNodeSetByPrefix(paramGlobalNode.getLocTuple().get(0)); + // Set reachNodeSet = globalFlowGraph.getReachableNodeSetFrom(node); + + // System.out.println("node=" + node + " prefixList=" + prefixList); + + for (int i = 0; i < prefixList.size(); i++) { + NTuple curPrefix = prefixList.get(i); + Set> reachableCommonPrefixSet = new HashSet>(); + + for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) { + GlobalFlowNode reachNode = (GlobalFlowNode) iterator2.next(); + if (reachNode.getLocTuple().startsWith(curPrefix)) { + reachableCommonPrefixSet.add(reachNode.getLocTuple()); + } + } + // System.out.println("reachableCommonPrefixSet=" + reachableCommonPrefixSet); + + if (!reachableCommonPrefixSet.isEmpty()) { + + MethodDescriptor curPrefixFirstElementMethodDesc = + (MethodDescriptor) curPrefix.get(0).getDescriptor(); + + MethodDescriptor nodePrefixLocFirstElementMethodDesc = + (MethodDescriptor) prefixLoc.getDescriptor(); + + // System.out.println("curPrefixFirstElementMethodDesc=" + + // curPrefixFirstElementMethodDesc); + // System.out.println("nodePrefixLocFirstElementMethodDesc=" + // + nodePrefixLocFirstElementMethodDesc); + + if (curPrefixFirstElementMethodDesc.equals(nodePrefixLocFirstElementMethodDesc) + || isTransitivelyCalledFrom(nodePrefixLocFirstElementMethodDesc, + curPrefixFirstElementMethodDesc)) { + + // TODO + // if (!node.getLocTuple().startsWith(curPrefix.get(0))) { + + Location curPrefixLocalLoc = curPrefix.get(0); + if (subGlobalFlowGraph.mapLocationToInferCompositeLocation.containsKey(curPrefixLocalLoc)) { + // in this case, the local variable of the current prefix has already got a composite + // location + // so we just ignore the current composite location. + + // System.out.println("HERE WE DO NOT ASSIGN A COMPOSITE LOCATION TO =" + node + // + " DUE TO " + curPrefix); + return null; + } + + if (!needToGenerateCompositeLocation(paramGlobalNode, curPrefix)) { + System.out.println("NO NEED TO GENERATE COMP LOC to " + paramGlobalNode + + " with prefix=" + curPrefix); + // System.out.println("prefixList=" + prefixList); + // System.out.println("reachableNodeSet=" + reachableNodeSet); + return null; + } + + Location targetLocalLoc = paramGlobalNode.getLocTuple().get(0); + CompositeLocation newCompLoc = generateCompositeLocation(curPrefix); + System.out.println("NEED TO ASSIGN COMP LOC TO " + paramGlobalNode + " with prefix=" + + curPrefix); + System.out.println("-targetLocalLoc=" + targetLocalLoc + " - newCompLoc=" + newCompLoc); + + // makes sure that a newly generated location appears in the hierarchy graph + for (int compIdx = 0; compIdx < newCompLoc.getSize(); compIdx++) { + Location curLoc = newCompLoc.get(compIdx); + getHierarchyGraph(curLoc.getDescriptor()).getHNode(curLoc.getLocDescriptor()); + } + + subGlobalFlowGraph.addMapLocationToInferCompositeLocation(targetLocalLoc, newCompLoc); + + return newCompLoc; + + } + + } + + } + return null; + } + private int getParamIdx(CompositeLocation compLoc, Map> mapIdxToArgTuple) { @@ -1070,9 +1191,11 @@ public class LocationInference { // Set reachNodeSet = globalFlowGraph.getReachableNodeSetFrom(node); // System.out.println("node=" + node + " prefixList=" + prefixList); + System.out.println("---prefixList=" + prefixList); - for (int i = 0; i < prefixList.size(); i++) { + nextprefix: for (int i = 0; i < prefixList.size(); i++) { NTuple curPrefix = prefixList.get(i); + System.out.println("---curPrefix=" + curPrefix); Set> reachableCommonPrefixSet = new HashSet>(); for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) { @@ -1120,7 +1243,7 @@ public class LocationInference { + curPrefix); // System.out.println("prefixList=" + prefixList); // System.out.println("reachableNodeSet=" + reachableNodeSet); - continue next; + continue nextprefix; } Location targetLocalLoc = node.getLocTuple().get(0); @@ -1218,6 +1341,15 @@ public class LocationInference { FlowNode flowNode = flowGraph.getFlowNode(node.getDescTuple()); Set reachableSet = flowGraph.getReachFlowNodeSetFrom(flowNode); + Set paramNodeSet = flowGraph.getParamFlowNodeSet(); + for (Iterator iterator = paramNodeSet.iterator(); iterator.hasNext();) { + FlowNode paramFlowNode = (FlowNode) iterator.next(); + if (curPrefix.startsWith(translateToLocTuple(md, paramFlowNode.getDescTuple()))) { + System.out.println("here1?!"); + return true; + } + } + if (targetLocalLoc.getLocDescriptor() instanceof InterDescriptor) { Pair pair = ((InterDescriptor) targetLocalLoc.getLocDescriptor()).getMethodArgIdxPair(); @@ -1231,6 +1363,7 @@ public class LocationInference { FlowNode paramNode = getFlowGraph(mdCallee).getParamFlowNode(paramIdx); if (checkNodeReachToReturnNode(mdCallee, paramNode)) { + System.out.println("here2?!"); return true; } @@ -1238,24 +1371,37 @@ public class LocationInference { } - if (mapMethodDescriptorToCompositeReturnCase.containsKey(md)) { - boolean hasCompReturnLocWithThis = - mapMethodDescriptorToCompositeReturnCase.get(md).booleanValue(); + GlobalFlowGraph subGlobalFlowGraph = getSubGlobalFlowGraph(md); + Set subGlobalReachableSet = subGlobalFlowGraph.getReachableNodeSetFrom(node); - if (hasCompReturnLocWithThis) { + if (!md.isStatic()) { + ClassDescriptor currentMethodThisType = getClassTypeDescriptor(md.getThis()); + for (int i = 0; i < curPrefix.size(); i++) { + ClassDescriptor prefixType = getClassTypeDescriptor(curPrefix.get(i).getLocDescriptor()); + if (prefixType != null && prefixType.equals(currentMethodThisType)) { + System.out.println("PREFIX TYPE MATCHES WITH=" + currentMethodThisType); + + if (mapMethodDescriptorToCompositeReturnCase.containsKey(md)) { + boolean hasCompReturnLocWithThis = + mapMethodDescriptorToCompositeReturnCase.get(md).booleanValue(); + if (hasCompReturnLocWithThis) { + if (checkNodeReachToReturnNode(md, flowNode)) { + System.out.println("here3?!"); + return true; + } + } + } - if (checkNodeReachToReturnNode(md, flowNode)) { - return true; + for (Iterator iterator3 = subGlobalReachableSet.iterator(); iterator3.hasNext();) { + GlobalFlowNode subGlobalReachalbeNode = (GlobalFlowNode) iterator3.next(); + if (subGlobalReachalbeNode.getLocTuple().get(0).getLocDescriptor().equals(md.getThis())) { + System.out.println("PREFIX FOUND=" + subGlobalReachalbeNode); + System.out.println("here4?!"); + return true; + } + } } - - // for (Iterator iterator = flowGraph.getReturnNodeSet().iterator(); iterator.hasNext();) { - // FlowNode returnFlowNode = (FlowNode) iterator.next(); - // if (reachableSet.contains(returnFlowNode)) { - // return true; - // } - // } } - } // System.out.println("flowGraph.getReturnNodeSet()=" + flowGraph.getReturnNodeSet()); @@ -1275,49 +1421,91 @@ public class LocationInference { MethodInvokeNode min = (MethodInvokeNode) iterator.next(); Map> map = mapMethodInvokeNodeToArgIdxMap.get(min); Set keySet = map.keySet(); - System.out.println("min=" + min.printNode(0)); + // System.out.println("min=" + min.printNode(0)); + for (Iterator iterator2 = keySet.iterator(); iterator2.hasNext();) { Integer argIdx = (Integer) iterator2.next(); NTuple argTuple = map.get(argIdx); - if (argTuple.get(argTuple.size() - 1).equals(lastLocationOfPrefix.getLocDescriptor())) { - NTuple locTuple = - translateToLocTuple(md, flowGraph.getParamFlowNode(argIdx).getDescTuple()); - lastLocationOfPrefix = locTuple.get(0); - break found; + // System.out.println("argTuple=" + argTuple); + // if (argIdx == 0 && !min.getMethod().isStatic()) { + // ClassDescriptor currentMethodThisType = getClassTypeDescriptor(argTuple.get(0)); + // + // for (int i = 0; i < curPrefix.size(); i++) { + // ClassDescriptor prefixType = + // getClassTypeDescriptor(curPrefix.get(i).getLocDescriptor()); + // if (prefixType != null && prefixType.equals(currentMethodThisType)) { + // System.out.println("PREFIX TYPE MATCHES WITH=" + currentMethodThisType); + // for (Iterator iterator3 = subGlobalReachableSet.iterator(); iterator3.hasNext();) { + // GlobalFlowNode subGlobalReachalbeNode = (GlobalFlowNode) iterator3.next(); + // if (subGlobalReachalbeNode.getLocTuple().get(0).getLocDescriptor() + // .equals(md.getThis())) { + // System.out.println("PREFIX FOUND=" + subGlobalReachalbeNode); + // System.out.println("here4?!"); + // + // return true; + // } + // } + // } + // } + // + // } + if (!(!md.isStatic() && argIdx == 0)) { + if (argTuple.get(argTuple.size() - 1).equals(lastLocationOfPrefix.getLocDescriptor())) { + NTuple locTuple = + translateToLocTuple(md, flowGraph.getParamFlowNode(argIdx).getDescTuple()); + lastLocationOfPrefix = locTuple.get(0); + System.out.println("ARG CASE=" + locTuple); + for (Iterator iterator3 = subGlobalReachableSet.iterator(); iterator3.hasNext();) { + GlobalFlowNode subGlobalReachalbeNode = (GlobalFlowNode) iterator3.next(); + // NTuple locTuple = translateToLocTuple(md, reachalbeNode.getDescTuple()); + NTuple globalReachlocTuple = subGlobalReachalbeNode.getLocTuple(); + for (int i = 0; i < globalReachlocTuple.size(); i++) { + if (globalReachlocTuple.get(i).equals(lastLocationOfPrefix)) { + System.out.println("ARG " + argTuple + " IS MATCHED WITH=" + + lastLocationOfPrefix); + System.out.println("here5?!"); + + return true; + } + } + } + } } } } - ClassDescriptor cd; - if (lastLocationOfPrefix.getLocDescriptor() instanceof VarDescriptor) { - cd = ((VarDescriptor) lastLocationOfPrefix.getLocDescriptor()).getType().getClassDesc(); - } else { - // it is a field descriptor - cd = ((FieldDescriptor) lastLocationOfPrefix.getLocDescriptor()).getType().getClassDesc(); - } - - GlobalFlowGraph subGlobalFlowGraph = getSubGlobalFlowGraph(md); - Set subGlobalReachableSet = subGlobalFlowGraph.getReachableNodeSetFrom(node); - - for (Iterator iterator2 = subGlobalReachableSet.iterator(); iterator2.hasNext();) { - GlobalFlowNode subGlobalReachalbeNode = (GlobalFlowNode) iterator2.next(); - // NTuple locTuple = translateToLocTuple(md, reachalbeNode.getDescTuple()); - NTuple locTuple = subGlobalReachalbeNode.getLocTuple(); - - for (int i = 0; i < locTuple.size(); i++) { - if (locTuple.get(i).equals(lastLocationOfPrefix)) { - return true; - } - } - Location lastLoc = locTuple.get(locTuple.size() - 1); - Descriptor enclosingDescriptor = lastLoc.getDescriptor(); - - if (enclosingDescriptor != null && enclosingDescriptor.equals(cd)) { - System.out.println("# WHY HERE?"); - System.out.println("subGlobalReachalbeNode="+subGlobalReachalbeNode); - return true; - } - } + // ClassDescriptor cd; + // if (lastLocationOfPrefix.getLocDescriptor() instanceof VarDescriptor) { + // cd = ((VarDescriptor) lastLocationOfPrefix.getLocDescriptor()).getType().getClassDesc(); + // } else { + // // it is a field descriptor + // cd = ((FieldDescriptor) lastLocationOfPrefix.getLocDescriptor()).getType().getClassDesc(); + // } + // + // GlobalFlowGraph subGlobalFlowGraph = getSubGlobalFlowGraph(md); + // Set subGlobalReachableSet = subGlobalFlowGraph.getReachableNodeSetFrom(node); + // + // System.out.println("TRY TO FIND lastLocationOfPrefix=" + lastLocationOfPrefix); + // for (Iterator iterator2 = subGlobalReachableSet.iterator(); iterator2.hasNext();) { + // GlobalFlowNode subGlobalReachalbeNode = (GlobalFlowNode) iterator2.next(); + // // NTuple locTuple = translateToLocTuple(md, reachalbeNode.getDescTuple()); + // NTuple locTuple = subGlobalReachalbeNode.getLocTuple(); + // + // for (int i = 0; i < locTuple.size(); i++) { + // if (locTuple.get(i).equals(lastLocationOfPrefix)) { + // return true; + // } + // } + // + // Location lastLoc = locTuple.get(locTuple.size() - 1); + // Descriptor enclosingDescriptor = lastLoc.getDescriptor(); + // + // if (enclosingDescriptor != null && enclosingDescriptor.equals(cd)) { + // System.out.println("# WHY HERE?"); + // System.out.println("subGlobalReachalbeNode=" + subGlobalReachalbeNode); + // return true; + // } + // } return false; } @@ -1357,11 +1545,11 @@ public class LocationInference { Set incomingNodeSetPrefix = graph.getIncomingNodeSetByPrefix(node.getLocTuple().get(0)); - System.out.println("---incomingNodeSetPrefix=" + incomingNodeSetPrefix); + // System.out.println("---incomingNodeSetPrefix=" + incomingNodeSetPrefix); Set reachableNodeSetPrefix = graph.getReachableNodeSetByPrefix(node.getLocTuple().get(0)); - System.out.println("---reachableNodeSetPrefix=" + reachableNodeSetPrefix); + // System.out.println("---reachableNodeSetPrefix=" + reachableNodeSetPrefix); List> prefixList = new ArrayList>(); @@ -1607,6 +1795,7 @@ public class LocationInference { for (Iterator iterator = calleeNodeSet.iterator(); iterator.hasNext();) { GlobalFlowNode calleeNode = (GlobalFlowNode) iterator.next(); if (calleeNode.isParamNodeWithIncomingFlows()) { + System.out.println("calleeNode.getLocTuple()" + calleeNode.getLocTuple()); NTuple callerSrcNodeLocTuple = translateToCallerLocTuple(min, possibleMdCallee, mdCaller, calleeNode.getLocTuple()); System.out.println("---callerSrcNodeLocTuple=" + callerSrcNodeLocTuple); @@ -1622,110 +1811,6 @@ public class LocationInference { } - private void addValueFlowBetweenParametersToCaller(MethodInvokeNode min, - MethodDescriptor mdCaller, MethodDescriptor mdCallee) { - - System.out.println("***addValueFlowBetweenParametersToCaller from mdCallee=" + mdCallee); - - Set> PCLocTupleSet = mapMethodInvokeNodeToPCLocTupleSet.get(min); - System.out.println("-PCLocTupleSet=" + PCLocTupleSet); - - GlobalFlowGraph calleeSubGlobalGraph = getSubGlobalFlowGraph(mdCallee); - GlobalFlowGraph callerSubGlobalGraph = getSubGlobalFlowGraph(mdCaller); - - // if the parameter A reaches to the parameter B - // then, add an edge the argument A -> the argument B to the global flow graph - FlowGraph calleeFlowGraph = getFlowGraph(mdCallee); - FlowGraph callerFlowGraph = getFlowGraph(mdCaller); - int numParam = calleeFlowGraph.getNumParameters(); - - for (int i = 0; i < numParam; i++) { - for (int k = 0; k < numParam; k++) { - - if (i != k) { - - System.out.println("i=" + i + " k=" + k); - - FlowNode paramNode1 = calleeFlowGraph.getParamFlowNode(i); - FlowNode paramNode2 = calleeFlowGraph.getParamFlowNode(k); - - NTuple arg1Tuple = getNodeTupleByArgIdx(min, i); - NTuple arg2Tuple = getNodeTupleByArgIdx(min, k); - - NTuple paramDescTuple1 = paramNode1.getCurrentDescTuple(); - NTuple paramDescTuple2 = paramNode2.getCurrentDescTuple(); - - if (paramDescTuple1.get(0).equals(paramDescTuple2.get(0))) { - // if two parameters share the same prefix - // it already has been assigned to a composite location - // so we don't need to add an additional ordering relation caused by these two - // paramters. - continue; - } - - NTuple paramLocTuple1 = translateToLocTuple(mdCallee, paramDescTuple1); - NTuple paramLocTuple2 = translateToLocTuple(mdCallee, paramDescTuple2); - - // check if the callee propagates an ordering constraints through - // parameters - - // Set localReachSet = calleeFlowGraph.getLocalReachFlowNodeSetFrom(paramNode1); - - Set reachToParam1Set = - calleeSubGlobalGraph.getIncomingNodeSetByPrefix(paramLocTuple1.get(0)); - - // System.out.println("-- localReachSet from param1=" + localReachSet); - - GlobalFlowNode globalFlowNodeParam1 = calleeSubGlobalGraph.getFlowNode(paramLocTuple1); - GlobalFlowNode globalFlowNodeParam2 = calleeSubGlobalGraph.getFlowNode(paramLocTuple2); - - System.out.println("-param1CurTuple=" + paramDescTuple1 + " param2CurTuple=" - + paramDescTuple2); - - System.out.println("arg1Tuple=" + arg1Tuple + " arg2Tuple=" + arg2Tuple); - // System.out.println("-reachToParam1Set=" + reachToParam1Set); - - if (arg1Tuple.size() > 0 && arg2Tuple.size() > 0 - && reachToParam1Set.contains(globalFlowNodeParam2)) { - // need to propagate an ordering relation s.t. arg1 is higher - // than arg2 - System.out.println("---param1=" + paramNode1 + " is higher than param2=" + paramNode2); - - NTuple callerSrcNodeLocTuple = - translateToCallerLocTuple(min, mdCallee, mdCaller, paramLocTuple1); - - NTuple callerDstNodeLocTuple = - translateToCallerLocTuple(min, mdCallee, mdCaller, paramLocTuple2); - - System.out.println("---callerSrcNodeLocTuple=" + callerSrcNodeLocTuple); - System.out.println("---callerDstNodeLocTuple=" + callerDstNodeLocTuple); - - System.out.println("-----add global value flow :" + callerSrcNodeLocTuple + "->" - + callerDstNodeLocTuple); - callerSubGlobalGraph.addValueFlowEdge(callerSrcNodeLocTuple, callerDstNodeLocTuple); - for (Iterator iterator = PCLocTupleSet.iterator(); iterator.hasNext();) { - NTuple pcLocTuple = (NTuple) iterator.next(); - System.out.println("-----add global value flow PC :" + pcLocTuple + "->" - + callerSrcNodeLocTuple); - callerSubGlobalGraph.addValueFlowEdge(pcLocTuple, callerSrcNodeLocTuple); - } - - // add a new flow between the corresponding arguments. - callerFlowGraph.addValueFlowEdge(arg1Tuple, arg2Tuple); - System.out.println("arg1=" + arg1Tuple + " arg2=" + arg2Tuple); - - // System.out - // .println("-arg1Tuple=" + arg1Tuple + " is higher than arg2Tuple=" + arg2Tuple); - - } - - System.out.println(); - } - } - } - - } - private void addValueFlowFromCalleeNode(MethodInvokeNode min, MethodDescriptor mdCaller, MethodDescriptor mdCallee, GlobalFlowNode calleeSrcNode) { @@ -1772,7 +1857,7 @@ public class LocationInference { // // the type of argument is primitive. // return nodeLocTuple.clone(); // } - System.out.println("paramIdx=" + paramIdx + " argDescTuple=" + argDescTuple); + // System.out.println("paramIdx=" + paramIdx + " argDescTuple=" + argDescTuple); NTuple argLocTuple = translateToLocTuple(mdCaller, argDescTuple); NTuple callerLocTuple = new NTuple(); @@ -2313,7 +2398,8 @@ public class LocationInference { Set sourceNodeSet = new HashSet(); if (originalSrcNode instanceof FlowReturnNode) { FlowReturnNode rnode = (FlowReturnNode) originalSrcNode; - Set> tupleSet = rnode.getTupleSet(); + System.out.println("rnode=" + rnode); + Set> tupleSet = rnode.getReturnTupleSet(); for (Iterator iterator2 = tupleSet.iterator(); iterator2.hasNext();) { NTuple nTuple = (NTuple) iterator2.next(); sourceNodeSet.add(fg.getFlowNode(nTuple)); @@ -2323,8 +2409,8 @@ public class LocationInference { sourceNodeSet.add(originalSrcNode); } - System.out.println("---sourceNodeSet=" + sourceNodeSet + " from originalSrcNode=" - + originalSrcNode); + // System.out.println("---sourceNodeSet=" + sourceNodeSet + " from originalSrcNode=" + // + originalSrcNode); for (Iterator iterator3 = sourceNodeSet.iterator(); iterator3.hasNext();) { FlowNode srcNode = (FlowNode) iterator3.next(); @@ -2355,16 +2441,17 @@ public class LocationInference { Set dstNodeSet = new HashSet(); if (originalDstNode instanceof FlowReturnNode) { FlowReturnNode rnode = (FlowReturnNode) originalDstNode; - System.out.println("\n-returnNode=" + rnode); - Set> tupleSet = rnode.getTupleSet(); + // System.out.println("\n-returnNode=" + rnode); + Set> tupleSet = rnode.getReturnTupleSet(); for (Iterator iterator4 = tupleSet.iterator(); iterator4.hasNext();) { NTuple nTuple = (NTuple) iterator4.next(); dstNodeSet.add(fg.getFlowNode(nTuple)); + System.out.println("&&&DST fg.getFlowNode(nTuple)=" + fg.getFlowNode(nTuple)); } } else { dstNodeSet.add(originalDstNode); } - System.out.println("---dstNodeSet=" + dstNodeSet); + // System.out.println("---dstNodeSet=" + dstNodeSet); for (Iterator iterator4 = dstNodeSet.iterator(); iterator4.hasNext();) { FlowNode dstNode = (FlowNode) iterator4.next(); @@ -3077,16 +3164,47 @@ public class LocationInference { if (curPCLoc.get(0).isTop() || pcLocTuple.size() > curPCLoc.getSize()) { methodSummary.setPCLoc(new CompositeLocation(pcLocTuple)); + Set flowNodeLowerthanPCLocSet = new HashSet(); + GlobalFlowGraph subGlobalFlowGraph = getSubGlobalFlowGraph(md); // add ordering relations s.t. PCLOC is higher than all flow nodes except the set of // parameters that do not have incoming flows for (Iterator iterator = fg.getNodeSet().iterator(); iterator.hasNext();) { FlowNode node = (FlowNode) iterator.next(); - if (!paramDescNOTHavingInFlowSet.contains(node.getCurrentDescTuple().get(0))) { - fg.addValueFlowEdge(pcDescTuple, node.getDescTuple()); + if (!(node instanceof FlowReturnNode)) { + if (!paramDescNOTHavingInFlowSet.contains(node.getCurrentDescTuple().get(0))) { + flowNodeLowerthanPCLocSet.add(node); + fg.addValueFlowEdge(pcDescTuple, node.getDescTuple()); + subGlobalFlowGraph.addValueFlowEdge(pcLocTuple, + translateToLocTuple(md, node.getDescTuple())); + } + } else { + System.out.println("***SKIP PCLOC -> RETURNLOC=" + node); } + } fg.getFlowNode(translateToDescTuple(pcLocTuple)).setSkeleton(true); + + if (pcLocTuple.get(0).getLocDescriptor().equals(md.getThis())) { + System.out.println("#########################################"); + for (Iterator iterator = flowNodeLowerthanPCLocSet.iterator(); iterator.hasNext();) { + FlowNode lowerNode = (FlowNode) iterator.next(); + if (lowerNode.getCompositeLocation() == null) { + NTuple lowerLocTuple = translateToLocTuple(md, lowerNode.getDescTuple()); + CompositeLocation newComp = + calculateCompositeLocationFromSubGlobalGraph(md, lowerNode); + if (newComp != null) { + subGlobalFlowGraph.addMapLocationToInferCompositeLocation(lowerLocTuple.get(0), + newComp); + lowerNode.setCompositeLocation(newComp); + System.out.println("NEW COMP LOC=" + newComp + " to lowerNode=" + lowerNode); + } + + } + + } + } + } } @@ -3483,14 +3601,16 @@ public class LocationInference { // check if the callee propagates an ordering constraints through // parameters - Set localReachSet = calleeFlowGraph.getLocalReachFlowNodeSetFrom(paramNode1); + // Set localReachSet = calleeFlowGraph.getLocalReachFlowNodeSetFrom(paramNode1); + Set localReachSet = + calleeFlowGraph.getReachableSetFrom(paramNode1.getDescTuple()); NTuple paramDescTuple1 = paramNode1.getCurrentDescTuple(); NTuple paramDescTuple2 = paramNode2.getCurrentDescTuple(); - System.out.println("-param1CurTuple=" + paramDescTuple1 + " param2CurTuple=" - + paramDescTuple2); - System.out.println("-- localReachSet from param1=" + localReachSet); + // System.out.println("-param1CurTuple=" + paramDescTuple1 + " param2CurTuple=" + // + paramDescTuple2); + // System.out.println("-- localReachSet from param1=" + localReachSet); if (paramDescTuple1.get(0).equals(paramDescTuple2.get(0))) { // if two parameters share the same prefix @@ -3500,21 +3620,22 @@ public class LocationInference { continue; } - if (arg1Tuple.size() > 0 && arg2Tuple.size() > 0 && localReachSet.contains(paramNode2)) { + if (arg1Tuple.size() > 0 && arg2Tuple.size() > 0 + && containsPrefix(paramNode2.getDescTuple().get(0), localReachSet)) { // need to propagate an ordering relation s.t. arg1 is higher // than arg2 - System.out.println("-param1=" + paramNode1 + " is higher than param2=" + paramNode2); + // System.out.println("-param1=" + paramNode1 + " is higher than param2=" + paramNode2); // add a new flow between the corresponding arguments. callerFlowGraph.addValueFlowEdge(arg1Tuple, arg2Tuple); - System.out.println("arg1=" + arg1Tuple + " arg2=" + arg2Tuple); + // System.out.println("arg1=" + arg1Tuple + " arg2=" + arg2Tuple); // System.out // .println("-arg1Tuple=" + arg1Tuple + " is higher than arg2Tuple=" + arg2Tuple); } - System.out.println(); + // System.out.println(); } } } @@ -3546,6 +3667,18 @@ public class LocationInference { } + private boolean containsPrefix(Descriptor prefixDesc, Set set) { + + for (Iterator iterator = set.iterator(); iterator.hasNext();) { + FlowNode flowNode = (FlowNode) iterator.next(); + if (flowNode.getDescTuple().startsWith(prefixDesc)) { + System.out.println("FOUND=" + flowNode); + return true; + } + } + return false; + } + private NTuple translateCompositeLocationToCaller(int idx, MethodInvokeNode min, CompositeLocation compLocForParam1) { @@ -3854,9 +3987,13 @@ public class LocationInference { Descriptor srcFieldDesc = srcCurTuple.get(idx); Descriptor dstFieldDesc = dstCurTuple.get(idx); + System.out.println("srcFieldDesc=" + srcFieldDesc + " dstFieldDesc=" + dstFieldDesc + + " idx=" + idx); if (!srcFieldDesc.equals(dstFieldDesc)) { // add a new edge getHierarchyGraph(cd).addEdge(srcFieldDesc, dstFieldDesc); + } else if (isPrimitive(srcFieldDesc) && isPrimitive(dstFieldDesc)) { + getHierarchyGraph(cd).addEdge(srcFieldDesc, dstFieldDesc); } } @@ -3904,7 +4041,8 @@ public class LocationInference { for (Iterator iterator = calleeSet.iterator(); iterator.hasNext();) { MethodDescriptor calleemd = (MethodDescriptor) iterator.next(); if ((!ssjava.isTrustMethod(calleemd)) - && (!ssjava.isSSJavaUtil(calleemd.getClassDesc()))) { + && (!ssjava.isSSJavaUtil(calleemd.getClassDesc())) + && (!calleemd.getModifiers().isNative())) { if (!visited.contains(calleemd)) { temp_toanalyzeMethodList.add(calleemd); } @@ -4603,7 +4741,7 @@ public class LocationInference { private void analyzeFlowTertiaryNode(MethodDescriptor md, SymbolTable nametable, TertiaryNode tn, NodeTupleSet nodeSet, NodeTupleSet implicitFlowTupleSet) { - System.out.println("analyzeFlowTertiaryNode=" + tn.printNode(0)); + // System.out.println("analyzeFlowTertiaryNode=" + tn.printNode(0)); NodeTupleSet tertiaryTupleNode = new NodeTupleSet(); analyzeFlowExpressionNode(md, nametable, tn.getCond(), tertiaryTupleNode, null, @@ -4613,10 +4751,10 @@ public class LocationInference { newImplicitTupleSet.addTupleSet(implicitFlowTupleSet); newImplicitTupleSet.addTupleSet(tertiaryTupleNode); - System.out.println("$$$GGGcondTupleNode=" + tertiaryTupleNode.getGlobalLocTupleSet()); - System.out.println("-tertiaryTupleNode=" + tertiaryTupleNode); - System.out.println("-implicitFlowTupleSet=" + implicitFlowTupleSet); - System.out.println("-newImplicitTupleSet=" + newImplicitTupleSet); + // System.out.println("$$$GGGcondTupleNode=" + tertiaryTupleNode.getGlobalLocTupleSet()); + // System.out.println("-tertiaryTupleNode=" + tertiaryTupleNode); + // System.out.println("-implicitFlowTupleSet=" + implicitFlowTupleSet); + // System.out.println("-newImplicitTupleSet=" + newImplicitTupleSet); if (needToGenerateInterLoc(newImplicitTupleSet)) { System.out.println("15"); diff --git a/Robust/src/Analysis/SSJava/SSJavaAnalysis.java b/Robust/src/Analysis/SSJava/SSJavaAnalysis.java index adf303d5..a39fd014 100644 --- a/Robust/src/Analysis/SSJava/SSJavaAnalysis.java +++ b/Robust/src/Analysis/SSJava/SSJavaAnalysis.java @@ -96,7 +96,7 @@ public class SSJavaAnalysis { // keep the field ownership from the linear type checking Hashtable> mapMethodToOwnedFieldSet; - + Set sameHeightWriteFlatNodeSet; CallGraph callgraph; -- 2.34.1