X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FAnalysis%2FSSJava%2FLocationInference.java;h=4f24373511871ac8c4af5369f3839d5a643321b0;hb=c8beb00c3d243b803b8b632b5e299f9a5b498f04;hp=916016054b8cfe069e7f276b4db5ec069457c8f2;hpb=e993e72e1d2bfe7921c32573245ad85781dffba3;p=IRC.git diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java index 91601605..4f243735 100644 --- a/Robust/src/Analysis/SSJava/LocationInference.java +++ b/Robust/src/Analysis/SSJava/LocationInference.java @@ -114,12 +114,16 @@ public class LocationInference { private Map mapDescToLocationSummary; + private Map> mapMethodDescToMethodInvokeNodeSet; + // maps a method descriptor to a sub global flow graph that captures all value flows caused by the // set of callees reachable from the method private Map mapMethodDescriptorToSubGlobalFlowGraph; private Map, NTuple>> mapMethodInvokeNodeToMapCallerArgToCalleeArg; + private Map mapMethodDescriptorToCompositeReturnCase; + public static final String GLOBALLOC = "GLOBALLOC"; public static final String INTERLOC = "INTERLOC"; @@ -197,6 +201,11 @@ public class LocationInference { this.arrayAccessNodeStack = new Stack(); + this.mapMethodDescToMethodInvokeNodeSet = + new HashMap>(); + + this.mapMethodDescriptorToCompositeReturnCase = new HashMap(); + } public void setupToAnalyze() { @@ -247,6 +256,8 @@ public class LocationInference { constructGlobalFlowGraph(); + checkReturnNodes(); + assignCompositeLocation(); updateFlowGraph(); calculateExtraLocations(); @@ -286,6 +297,25 @@ public class LocationInference { } + private void checkReturnNodes() { + LinkedList methodDescList = + (LinkedList) toanalyze_methodDescList.clone(); + + while (!methodDescList.isEmpty()) { + MethodDescriptor md = methodDescList.removeLast(); + + if (md.getReturnType() != null && !md.getReturnType().isVoid()) { + checkFlowNodeReturnThisField(md); + } + // // in this case, this method will return the composite location that starts with 'this' + // FlowGraph flowGraph = getFlowGraph(md); + // Set returnNodeSet = flowGraph.getReturnNodeSet(); + // } + + } + + } + private void updateFlowGraph() { LinkedList methodDescList = @@ -328,6 +358,12 @@ public class LocationInference { translateCompositeLocationAssignmentToFlowGraph(methodEventLoopDesc); } + private void translateCompositeLocationAssignmentToFlowGraph2() { + System.out.println("\nSSJAVA: Translate composite location assignments to flow graphs:"); + MethodDescriptor methodEventLoopDesc = ssjava.getMethodContainingSSJavaLoop(); + translateCompositeLocationAssignmentToFlowGraph(methodEventLoopDesc); + } + private void addAdditionalOrderingConstraints() { System.out.println("\nSSJAVA: Add addtional ordering constriants:"); MethodDescriptor methodEventLoopDesc = ssjava.getMethodContainingSSJavaLoop(); @@ -491,8 +527,8 @@ public class LocationInference { + " with baseTuple=" + methodInvokeBaseLocTuple + " calleeParamLocTuple=" + calleeParamFlowNode); - CompositeLocation paramCompLoc = translateArgCompLocToParamCompLoc(min, argCompLoc); - calleeParamFlowNode.setCompositeLocation(paramCompLoc); + // CompositeLocation paramCompLoc = translateArgCompLocToParamCompLoc(min, argCompLoc); + // calleeParamFlowNode.setCompositeLocation(paramCompLoc); // if (baseLocTuple != null && callerCompLoc.getTuple().startsWith(baseLocTuple)) { // @@ -534,15 +570,15 @@ public class LocationInference { translateCompositeLocationAssignmentToFlowGraph(callee); } - for (Iterator iterator = minSet.iterator(); iterator.hasNext();) { - MethodInvokeNode min = (MethodInvokeNode) iterator.next(); - // add an additional ordering constraint - // if the first element of a parameter composite location matches 'this' reference, - // the corresponding argument in the caller is required to be higher than the translated - // parameter location in the caller lattice - // TODO - // addOrderingConstraintFromCompLocParamToArg(mdCaller, min); - } + // for (Iterator iterator = minSet.iterator(); iterator.hasNext();) { + // MethodInvokeNode min = (MethodInvokeNode) iterator.next(); + // // add an additional ordering constraint + // // if the first element of a parameter composite location matches 'this' reference, + // // the corresponding argument in the caller is required to be higher than the translated + // // parameter location in the caller lattice + // // TODO + // // addOrderingConstraintFromCompLocParamToArg(mdCaller, min); + // } } @@ -639,6 +675,21 @@ public class LocationInference { } + private void addMapMethodDescToMethodInvokeNodeSet(MethodInvokeNode min) { + MethodDescriptor md = min.getMethod(); + if (!mapMethodDescToMethodInvokeNodeSet.containsKey(md)) { + mapMethodDescToMethodInvokeNodeSet.put(md, new HashSet()); + } + mapMethodDescToMethodInvokeNodeSet.get(md).add(min); + } + + private Set getMethodInvokeNodeSetByMethodDesc(MethodDescriptor md) { + if (!mapMethodDescToMethodInvokeNodeSet.containsKey(md)) { + mapMethodDescToMethodInvokeNodeSet.put(md, new HashSet()); + } + return mapMethodDescToMethodInvokeNodeSet.get(md); + } + private void addOrderingConstraintFromCompLocParamToArg(MethodDescriptor mdCaller, MethodInvokeNode min) { System.out.println("-addOrderingConstraintFromCompLocParamToArg=" + min.printNode(0)); @@ -805,12 +856,15 @@ public class LocationInference { } else { int paramIdx = getParamIdx(callerCompLoc, mapIdxToArgTuple); if (paramIdx == -1) { + System.out.println("*****key=" + key + " callerCompLoc=" + callerCompLoc); + if (!calleeGlobalGraph.contrainsInferCompositeLocationMapKey(key)) { + calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, callerCompLoc); + } continue; } NTuple argTuple = mapIdxToArgTuple.get(paramIdx); FlowNode paramFlowNode = calleeFlowGraph.getParamFlowNode(paramIdx); - // System.out.println("-----paramIdx=" + paramIdx + " paramFlowNode=" + paramFlowNode); NTuple paramLocTuple = translateToLocTuple(mdCallee, paramFlowNode.getDescTuple()); newCalleeCompLoc = new CompositeLocation(); @@ -821,10 +875,11 @@ public class LocationInference { newCalleeCompLoc.addLocation(callerCompLoc.get(i)); } calleeGlobalGraph.addMapLocationToInferCompositeLocation(key, newCalleeCompLoc); - // System.out.println("---key=" + key + " callerCompLoc=" + callerCompLoc - // + " newCalleeCompLoc=" + newCalleeCompLoc); - // System.out.println("------argTuple=" + argTuple); - // System.out.println("-----caller=" + mdCaller + " callee=" + mdCallee); + System.out.println("---key=" + key + " callerCompLoc=" + callerCompLoc + + " newCalleeCompLoc=" + newCalleeCompLoc); + System.out.println("-----argTuple=" + argTuple + " caller=" + mdCaller + " callee=" + + mdCallee); + System.out.println("-----paramIdx=" + paramIdx + " paramFlowNode=" + paramFlowNode); } @@ -836,6 +891,8 @@ public class LocationInference { // System.out.println("-----*AFTER TRANSLATING COMP LOC MAPPING, CALLEE MAPPING=" // + calleeGlobalGraph.getMapLocationToInferCompositeLocation()); + System.out.println("#ASSIGN COMP LOC TO CALLEE PARAMS: callee=" + mdCallee + " caller=" + + mdCaller); // If the location of an argument has a composite location // need to assign a proper composite location to the corresponding callee parameter Set idxSet = mapIdxToArgTuple.keySet(); @@ -847,6 +904,7 @@ public class LocationInference { } NTuple argTuple = mapIdxToArgTuple.get(idx); + System.out.println("-argTuple=" + argTuple + " idx=" + idx); if (argTuple.size() > 0) { // check if an arg tuple has been already assigned to a composite location NTuple argLocTuple = translateToLocTuple(mdCaller, argTuple); @@ -860,16 +918,23 @@ public class LocationInference { callerCompLoc.addLocation(argLocTuple.get(i)); } - if (baseLocTuple != null && callerCompLoc.getTuple().startsWith(baseLocTuple)) { + System.out.println("---callerCompLoc=" + callerCompLoc); - FlowNode calleeParamFlowNode = calleeFlowGraph.getParamFlowNode(idx); - NTuple calleeParamDescTuple = calleeParamFlowNode.getDescTuple(); - NTuple calleeParamLocTuple = - translateToLocTuple(mdCallee, calleeParamDescTuple); + // if (baseLocTuple != null && callerCompLoc.getTuple().startsWith(baseLocTuple)) { - // System.out.println("---need to translate callerCompLoc=" + callerCompLoc - // + " with baseTuple=" + baseLocTuple + " calleeParamLocTuple=" - // + calleeParamLocTuple); + FlowNode calleeParamFlowNode = calleeFlowGraph.getParamFlowNode(idx); + + NTuple calleeParamDescTuple = calleeParamFlowNode.getDescTuple(); + NTuple calleeParamLocTuple = + translateToLocTuple(mdCallee, calleeParamDescTuple); + + int refParamIdx = getParamIdx(callerCompLoc, mapIdxToArgTuple); + System.out.println("-----paramIdx=" + refParamIdx); + if (refParamIdx == 0 && !mdCallee.isStatic()) { + + System.out.println("-------need to translate callerCompLoc=" + callerCompLoc + + " with baseTuple=" + baseLocTuple + " calleeParamLocTuple=" + + calleeParamLocTuple); CompositeLocation newCalleeCompLoc = translateCompositeLocationToCallee(callerCompLoc, baseLocTuple, mdCallee); @@ -877,11 +942,44 @@ public class LocationInference { calleeGlobalGraph.addMapLocationToInferCompositeLocation(calleeParamLocTuple.get(0), newCalleeCompLoc); - // System.out.println("---callee loc=" + calleeParamLocTuple.get(0) - // + " newCalleeCompLoc=" + newCalleeCompLoc); + System.out.println("---------key=" + calleeParamLocTuple.get(0) + " callerCompLoc=" + + callerCompLoc + " newCalleeCompLoc=" + newCalleeCompLoc); + + } else if (refParamIdx != -1) { + // the first element of an argument composite location matches with one of paramtere + // composite locations + + System.out.println("-------param match case="); + + NTuple argTupleRef = mapIdxToArgTuple.get(refParamIdx); + FlowNode refParamFlowNode = calleeFlowGraph.getParamFlowNode(refParamIdx); + NTuple refParamLocTuple = + translateToLocTuple(mdCallee, refParamFlowNode.getDescTuple()); + + System.out.println("---------refParamLocTuple=" + refParamLocTuple + + " from argTupleRef=" + argTupleRef); + + CompositeLocation newCalleeCompLoc = new CompositeLocation(); + for (int i = 0; i < refParamLocTuple.size(); i++) { + newCalleeCompLoc.addLocation(refParamLocTuple.get(i)); + } + for (int i = argTupleRef.size(); i < callerCompLoc.getSize(); i++) { + newCalleeCompLoc.addLocation(callerCompLoc.get(i)); + } + + calleeGlobalGraph.addMapLocationToInferCompositeLocation(calleeParamLocTuple.get(0), + newCalleeCompLoc); + + System.out.println("-----------key=" + calleeParamLocTuple.get(0) + " callerCompLoc=" + + callerCompLoc + " newCalleeCompLoc=" + newCalleeCompLoc); } + System.out.println("-----------------calleeParamFlowNode=" + + calleeParamFlowNode.getCompositeLocation()); + + // } + } } @@ -1017,10 +1115,15 @@ public class LocationInference { continue next; } - Location targetLocalLoc = node.getLocTuple().get(0); - // CompositeLocation curCompLoc = globalFlowGraph.getCompositeLocation(targetLocalLoc); - // if ((curPrefix.size() + 1) > curCompLoc.getSize()) { + if (!needToGenerateCompositeLocation(node, curPrefix)) { + System.out.println("NO NEED TO GENERATE COMP LOC to " + node + " with prefix=" + + curPrefix); + // System.out.println("prefixList=" + prefixList); + // System.out.println("reachableNodeSet=" + reachableNodeSet); + continue next; + } + Location targetLocalLoc = node.getLocTuple().get(0); CompositeLocation newCompLoc = generateCompositeLocation(curPrefix); System.out.println("NEED TO ASSIGN COMP LOC TO " + node + " with prefix=" + curPrefix); System.out.println("-targetLocalLoc=" + targetLocalLoc + " - newCompLoc=" @@ -1038,9 +1141,205 @@ public class LocationInference { } } - // Set inNodeSet = - // graph.getIncomingNodeSetWithPrefix(prefix); - // System.out.println("inNodeSet=" + inNodeSet + " from=" + node); + } + + private boolean checkFlowNodeReturnThisField(MethodDescriptor md) { + + MethodDescriptor methodDescEventLoop = ssjava.getMethodContainingSSJavaLoop(); + GlobalFlowGraph globalFlowGraph = getSubGlobalFlowGraph(methodDescEventLoop); + + FlowGraph flowGraph = getFlowGraph(md); + + ClassDescriptor enclosingDesc = getClassTypeDescriptor(md.getThis()); + if (enclosingDesc == null) { + return false; + } + + int count = 0; + Set returnNodeSet = flowGraph.getReturnNodeSet(); + Set globalReturnNodeSet = new HashSet(); + for (Iterator iterator = returnNodeSet.iterator(); iterator.hasNext();) { + FlowNode flowNode = (FlowNode) iterator.next(); + NTuple locTuple = translateToLocTuple(md, flowNode.getDescTuple()); + GlobalFlowNode globalReturnNode = globalFlowGraph.getFlowNode(locTuple); + globalReturnNodeSet.add(globalReturnNode); + + List> prefixList = calculatePrefixList(globalFlowGraph, globalReturnNode); + for (int i = 0; i < prefixList.size(); i++) { + NTuple curPrefix = prefixList.get(i); + ClassDescriptor cd = + getClassTypeDescriptor(curPrefix.get(curPrefix.size() - 1).getLocDescriptor()); + if (cd != null && cd.equals(enclosingDesc)) { + count++; + break; + } + } + + } + + if (count == returnNodeSet.size()) { + // in this case, all return nodes in the method returns values coming from a location that + // starts with "this" + + System.out.println("$$$SET RETURN LOC TRUE=" + md); + mapMethodDescriptorToCompositeReturnCase.put(md, Boolean.TRUE); + + // NameDescriptor returnLocDesc = new NameDescriptor("RLOC" + (locSeed++)); + // NTuple rDescTuple = new NTuple(); + // rDescTuple.add(md.getThis()); + // rDescTuple.add(returnLocDesc); + // + // for (Iterator iterator = returnNodeSet.iterator(); iterator.hasNext();) { + // FlowNode rnode = (FlowNode) iterator.next(); + // flowGraph.addValueFlowEdge(rnode.getDescTuple(), rDescTuple); + // } + // + // getMethodSummary(md).setRETURNLoc(new CompositeLocation(translateToLocTuple(md, + // rDescTuple))); + + } else { + mapMethodDescriptorToCompositeReturnCase.put(md, Boolean.FALSE); + } + + return mapMethodDescriptorToCompositeReturnCase.get(md).booleanValue(); + + } + + private boolean needToGenerateCompositeLocation(GlobalFlowNode node, NTuple curPrefix) { + // return true if there is a path between a node to which we want to give a composite location + // and nodes which start with curPrefix + + System.out.println("---needToGenerateCompositeLocation curPrefix=" + curPrefix); + + Location targetLocalLoc = node.getLocTuple().get(0); + + MethodDescriptor md = (MethodDescriptor) targetLocalLoc.getDescriptor(); + FlowGraph flowGraph = getFlowGraph(md); + FlowNode flowNode = flowGraph.getFlowNode(node.getDescTuple()); + Set reachableSet = flowGraph.getReachFlowNodeSetFrom(flowNode); + + if (targetLocalLoc.getLocDescriptor() instanceof InterDescriptor) { + Pair pair = + ((InterDescriptor) targetLocalLoc.getLocDescriptor()).getMethodArgIdxPair(); + + if (pair != null) { + System.out.println("$$$TARGETLOCALLOC HOLDER=" + targetLocalLoc); + + MethodInvokeNode min = pair.getFirst(); + Integer paramIdx = pair.getSecond(); + MethodDescriptor mdCallee = min.getMethod(); + + FlowNode paramNode = getFlowGraph(mdCallee).getParamFlowNode(paramIdx); + if (checkNodeReachToReturnNode(mdCallee, paramNode)) { + return true; + } + + } + + } + + if (mapMethodDescriptorToCompositeReturnCase.containsKey(md)) { + boolean hasCompReturnLocWithThis = + mapMethodDescriptorToCompositeReturnCase.get(md).booleanValue(); + + if (hasCompReturnLocWithThis) { + + if (checkNodeReachToReturnNode(md, flowNode)) { + 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()); + // System.out.println("flowGraph.contains(node.getDescTuple())=" + // + flowGraph.contains(node.getDescTuple()) + " flowGraph.getFlowNode(node.getDescTuple())=" + // + flowGraph.getFlowNode(node.getDescTuple()));reachableSet + + // if (flowGraph.contains(node.getDescTuple()) + // && flowGraph.getReturnNodeSet().contains(flowGraph.getFlowNode(node.getDescTuple()))) { + // // return checkFlowNodeReturnThisField(flowGraph); + // } + + Location lastLocationOfPrefix = curPrefix.get(curPrefix.size() - 1); + // check whether prefix appears in the list of parameters + Set minSet = mapMethodDescToMethodInvokeNodeSet.get(md); + found: for (Iterator iterator = minSet.iterator(); iterator.hasNext();) { + MethodInvokeNode min = (MethodInvokeNode) iterator.next(); + Map> map = mapMethodInvokeNodeToArgIdxMap.get(min); + Set keySet = map.keySet(); + 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; + } + } + } + + 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; + } + } + + return false; + } + + private boolean checkNodeReachToReturnNode(MethodDescriptor md, FlowNode node) { + + FlowGraph flowGraph = getFlowGraph(md); + Set reachableSet = flowGraph.getReachFlowNodeSetFrom(node); + if (mapMethodDescriptorToCompositeReturnCase.containsKey(md)) { + boolean hasCompReturnLocWithThis = + mapMethodDescriptorToCompositeReturnCase.get(md).booleanValue(); + + if (hasCompReturnLocWithThis) { + for (Iterator iterator = flowGraph.getReturnNodeSet().iterator(); iterator.hasNext();) { + FlowNode returnFlowNode = (FlowNode) iterator.next(); + if (reachableSet.contains(returnFlowNode)) { + return true; + } + } + } + } + return false; } private void assignCompositeLocation(CompositeLocation compLocPrefix, GlobalFlowNode node) { @@ -1058,11 +1357,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>(); @@ -1433,11 +1732,11 @@ public class LocationInference { GlobalFlowGraph calleeSubGlobalGraph = getSubGlobalFlowGraph(mdCallee); GlobalFlowGraph callerSubGlobalGraph = getSubGlobalFlowGraph(mdCaller); - System.out.println("$addValueFlowFromCalleeNode calleeSrcNode=" + calleeSrcNode); + // System.out.println("$addValueFlowFromCalleeNode calleeSrcNode=" + calleeSrcNode); NTuple callerSrcNodeLocTuple = translateToCallerLocTuple(min, mdCallee, mdCaller, calleeSrcNode.getLocTuple()); - System.out.println("---callerSrcNodeLocTuple=" + callerSrcNodeLocTuple); + // System.out.println("---callerSrcNodeLocTuple=" + callerSrcNodeLocTuple); if (callerSrcNodeLocTuple != null && callerSrcNodeLocTuple.size() > 0) { @@ -2022,6 +2321,17 @@ public class LocationInference { for (Iterator iterator3 = sourceNodeSet.iterator(); iterator3.hasNext();) { FlowNode srcNode = (FlowNode) iterator3.next(); + NTuple srcNodeTuple = srcNode.getDescTuple(); + Descriptor srcLocalDesc = srcNodeTuple.get(0); + + if (srcLocalDesc instanceof InterDescriptor + && ((InterDescriptor) srcLocalDesc).getMethodArgIdxPair() != null) { + + if (srcNode.getCompositeLocation() == null) { + continue; + } + } + // if the srcNode is started with the global descriptor // need to set as a skeleton node if (!hasGlobalAccess && srcNode.getDescTuple().startsWith(GLOBALDESC)) { @@ -2036,6 +2346,7 @@ 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(); for (Iterator iterator4 = tupleSet.iterator(); iterator4.hasNext();) { NTuple nTuple = (NTuple) iterator4.next(); @@ -2048,8 +2359,16 @@ public class LocationInference { for (Iterator iterator4 = dstNodeSet.iterator(); iterator4.hasNext();) { FlowNode dstNode = (FlowNode) iterator4.next(); - NTuple srcNodeTuple = srcNode.getDescTuple(); NTuple dstNodeTuple = dstNode.getDescTuple(); + Descriptor dstLocalDesc = dstNodeTuple.get(0); + + if (dstLocalDesc instanceof InterDescriptor + && ((InterDescriptor) dstLocalDesc).getMethodArgIdxPair() != null) { + if (dstNode.getCompositeLocation() == null) { + System.out.println("%%%%%%%%%%%%%SKIP=" + dstNode); + continue; + } + } // if (outEdge.getInitTuple().equals(srcNodeTuple) // && outEdge.getEndTuple().equals(dstNodeTuple)) { @@ -2057,7 +2376,7 @@ public class LocationInference { NTuple srcCurTuple = srcNode.getCurrentDescTuple(); NTuple dstCurTuple = dstNode.getCurrentDescTuple(); - // System.out.println("-srcCurTuple=" + srcCurTuple + " dstCurTuple=" + dstCurTuple); + System.out.println("-srcCurTuple=" + srcCurTuple + " dstCurTuple=" + dstCurTuple); if ((srcCurTuple.size() > 1 && dstCurTuple.size() > 1) && srcCurTuple.get(0).equals(dstCurTuple.get(0))) { @@ -2801,14 +3120,18 @@ public class LocationInference { private void calculateRETURNLOC(MethodDescriptor md) { System.out.println("#calculateRETURNLOC= " + md); + // calculate a return location: // the return location type is lower than all parameters and the location of return values MethodSummary methodSummary = getMethodSummary(md); + if (methodSummary.getRETURNLoc() != null) { + return; + } FlowGraph fg = getFlowGraph(md); Map mapParamToLoc = methodSummary.getMapParamIdxToInferLoc(); Set paramIdxSet = mapParamToLoc.keySet(); - if (!md.getReturnType().isVoid()) { + if (md.getReturnType() != null && !md.getReturnType().isVoid()) { // first, generate the set of return value location types that starts // with 'this' reference @@ -2933,9 +3256,9 @@ public class LocationInference { } - String pcLocIdentifier = locNamePrefix + (locSeed++); - NameDescriptor pcLocDesc = new NameDescriptor(pcLocIdentifier); - Location newLoc = new Location(enclosingDesc, pcLocDesc); + String locIdentifier = locNamePrefix + (locSeed++); + NameDescriptor locDesc = new NameDescriptor(locIdentifier); + Location newLoc = new Location(enclosingDesc, locDesc); higherLocTuple.add(newLoc); System.out.println("---new loc tuple=" + higherLocTuple); @@ -3124,6 +3447,7 @@ public class LocationInference { private void propagateFlowsToCallerWithNoCompositeLocation(MethodInvokeNode min, MethodDescriptor mdCaller, MethodDescriptor mdCallee) { + System.out.println("-propagateFlowsToCallerWithNoCompositeLocation=" + min.printNode(0)); // if the parameter A reaches to the parameter B // then, add an edge the argument A -> the argument B to the caller's flow // graph @@ -3147,14 +3471,14 @@ public class LocationInference { // parameters Set localReachSet = calleeFlowGraph.getLocalReachFlowNodeSetFrom(paramNode1); - System.out.println("-param1=" + paramNode1 + " is higher than param2=" + paramNode2); - // System.out.println("-- localReachSet from param1=" + localReachSet); NTuple paramDescTuple1 = paramNode1.getCurrentDescTuple(); NTuple paramDescTuple2 = paramNode2.getCurrentDescTuple(); 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 // it already has been assigned to a composite location @@ -3166,6 +3490,7 @@ public class LocationInference { if (arg1Tuple.size() > 0 && arg2Tuple.size() > 0 && localReachSet.contains(paramNode2)) { // need to propagate an ordering relation s.t. arg1 is higher // than arg2 + System.out.println("-param1=" + paramNode1 + " is higher than param2=" + paramNode2); // add a new flow between the corresponding arguments. callerFlowGraph.addValueFlowEdge(arg1Tuple, arg2Tuple); @@ -3646,7 +3971,6 @@ public class LocationInference { // subGlobalFlowGraph.writeGraph("_SUBGLOBAL"); // // propagateFlowsFromCalleesWithNoCompositeLocation(md); - } } // _debug_printGraph(); @@ -3821,6 +4145,7 @@ public class LocationInference { if (needToGenerateInterLoc(newImplicitTupleSet)) { // need to create an intermediate node for the GLB of conditional // locations & implicit flows + System.out.println("10"); NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter.hasNext();) { @@ -3887,6 +4212,8 @@ public class LocationInference { // System.out.println("---currentFlowTupleSet=" + currentFlowTupleSet); if (needToGenerateInterLoc(currentFlowTupleSet)) { + System.out.println("9"); + FlowNode meetNode = fg.createIntermediateNode(); for (Iterator iterator = currentFlowTupleSet.iterator(); iterator.hasNext();) { NTuple currentFlowTuple = (NTuple) iterator.next(); @@ -3951,6 +4278,7 @@ public class LocationInference { if (needToGenerateInterLoc(newImplicitTupleSet)) { // need to create an intermediate node for the GLB of conditional // locations & implicit flows + System.out.println("6"); NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter @@ -4011,6 +4339,7 @@ public class LocationInference { if (needToGenerateInterLoc(newImplicitTupleSet)) { // need to create an intermediate node for the GLB of conditional // locations & implicit flows + System.out.println("7"); NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter @@ -4074,6 +4403,8 @@ public class LocationInference { // System.out.println("-newImplicitTupleSet=" + newImplicitTupleSet); if (needToGenerateInterLoc(newImplicitTupleSet)) { + System.out.println("5"); + // need to create an intermediate node for the GLB of conditional locations & implicit flows NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter.hasNext();) { @@ -4123,6 +4454,7 @@ public class LocationInference { // creates edges from RHS to LHS NTuple interTuple = null; if (needToGenerateInterLoc(nodeSetRHS)) { + System.out.println("3"); interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); } @@ -4313,6 +4645,8 @@ public class LocationInference { return; } + addMapMethodDescToMethodInvokeNodeSet(min); + Set> pcLocTupleSet = getPCLocTupleSet(min); for (Iterator iterator = implicitFlowTupleSet.iterator(); iterator.hasNext();) { NTuple pcDescTuple = (NTuple) iterator.next(); @@ -4425,8 +4759,11 @@ public class LocationInference { if (argTuple.size() > 0 && (argTuple.get(0).equals(GLOBALDESC) || argTuple.get(0).equals(LITERALDESC))) { System.out.println("***GLOBAL ARG TUPLE CASE=" + argTuple); + System.out.println("8"); + NTuple interTuple = getFlowGraph(mdCaller).createIntermediateNode().getDescTuple(); + ((InterDescriptor) interTuple.get(0)).setMethodArgIdxPair(min, idx); addFlowGraphEdge(mdCaller, argTuple, interTuple); argTuple = interTuple; addArgIdxMap(min, idx, argTuple); @@ -4461,6 +4798,7 @@ public class LocationInference { if (mdCallee.getReturnType() != null && !mdCallee.getReturnType().isVoid()) { FlowReturnNode setNode = getFlowGraph(mdCaller).createReturnNode(min); + setNode.addTupleSet(tupleSet); nodeSet.addTuple(setNode.getDescTuple()); } @@ -4492,6 +4830,8 @@ public class LocationInference { } if (argTupleSetNonLiteral.size() > 1) { + System.out.println("11"); + NTuple interTuple = getFlowGraph(mdCaller).createIntermediateNode().getDescTuple(); for (Iterator> idxIter = argTupleSet.iterator(); idxIter.hasNext();) { @@ -4594,6 +4934,7 @@ public class LocationInference { || !arrayAccessNodeStack.peek().startsWith(currentArrayAccessNodeExpStr)) { if (needToGenerateInterLoc(nodeSetArrayAccessExp)) { + System.out.println("1"); NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); for (Iterator> iter = nodeSetArrayAccessExp.iterator(); iter.hasNext();) { @@ -4850,6 +5191,11 @@ public class LocationInference { nodeSetArrayAccessExp.addTupleSet(idxNodeTupleSet); if (needToGenerateInterLoc(nodeSetArrayAccessExp)) { + System.out.println("4"); + System.out.println("nodeSetArrayAccessExp=" + nodeSetArrayAccessExp); + System.out.println("idxNodeTupleSet.getGlobalLocTupleSet()=" + + idxNodeTupleSet.getGlobalLocTupleSet()); + NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); @@ -4922,6 +5268,8 @@ public class LocationInference { // creates edges from RHS to LHS NTuple interTuple = null; if (needToGenerateInterLoc(nodeSetRHS)) { + System.out.println("2"); + interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); } @@ -5149,8 +5497,18 @@ class CyclicFlowException extends Exception { class InterDescriptor extends Descriptor { + Pair minArgIdxPair; + public InterDescriptor(String name) { super(name); } + public void setMethodArgIdxPair(MethodInvokeNode min, int idx) { + minArgIdxPair = new Pair(min, new Integer(idx)); + } + + public Pair getMethodArgIdxPair() { + return minArgIdxPair; + } + }