From 13a63ea76172e2fd0ce7987bf81845c44c839d55 Mon Sep 17 00:00:00 2001 From: yeom Date: Wed, 3 Oct 2012 02:18:21 +0000 Subject: [PATCH] major revisions on FlowGraph to have more precise information --- Robust/src/Analysis/SSJava/FlowGraph.java | 66 +++++- Robust/src/Analysis/SSJava/FlowNode.java | 73 +++--- Robust/src/Analysis/SSJava/Location.java | 6 + .../Analysis/SSJava/LocationInference.java | 224 +++++++++++++----- 4 files changed, 269 insertions(+), 100 deletions(-) diff --git a/Robust/src/Analysis/SSJava/FlowGraph.java b/Robust/src/Analysis/SSJava/FlowGraph.java index c8914f14..e81fe7d0 100644 --- a/Robust/src/Analysis/SSJava/FlowGraph.java +++ b/Robust/src/Analysis/SSJava/FlowGraph.java @@ -95,13 +95,18 @@ public class FlowGraph { return mapParamDescToIdx; } - public FlowNode createIntermediateNode() { + public FlowNode createIntermediateNode(MethodDescriptor md) { + NTuple tuple = new NTuple(); Descriptor interDesc = new InterDescriptor(LocationInference.INTERLOC + interseed); tuple.add(interDesc); interseed++; - FlowNode newNode = new FlowNode(tuple); + NTuple locTuple = new NTuple(); + Location interLoc = new Location(md, interDesc); + locTuple.add(interLoc); + + FlowNode newNode = new FlowNode(locTuple); newNode.setIntermediate(true); mapDescTupleToInferNode.put(tuple, newNode); @@ -274,8 +279,10 @@ public class FlowGraph { public FlowNode createNewFlowNode(NTuple tuple) { + NTuple locTuple = translateToLocationTuple(tuple); if (!mapDescTupleToInferNode.containsKey(tuple)) { - FlowNode node = new FlowNode(tuple); + + FlowNode node = new FlowNode(locTuple); mapDescTupleToInferNode.put(tuple, node); // nodeSet.add(node); @@ -380,7 +387,7 @@ public class FlowGraph { for (Iterator iterator = outEdgeSet.iterator(); iterator.hasNext();) { FlowEdge edge = (FlowEdge) iterator.next(); - if (fn.getDescTuple().equals(edge.getInitTuple())) { + if (fn.getLocTuple().equals(edge.getInitTuple())) { FlowNode dstNode = getFlowNode(edge.getEndTuple()); NTuple dstTuple = getLocationTuple(dstNode); @@ -398,6 +405,51 @@ public class FlowGraph { return getLocationTuple(getFlowNode(descTuple)); } + public NTuple translateToLocationTuple(NTuple descTuple) { + + NTuple locTuple = new NTuple(); + ClassDescriptor cd = null; + + Descriptor localDesc = descTuple.get(0); + + if (localDesc instanceof InterDescriptor) { + Location interLoc = new Location(md, localDesc); + locTuple.add(interLoc); + } else if (localDesc.getSymbol().equals(LocationInference.TOPLOC)) { + Location topLoc = new Location(md, Location.TOP); + topLoc.setLocDescriptor(LocationInference.TOPDESC); + locTuple.add(topLoc); + } else if (localDesc.getSymbol().equals(LocationInference.GLOBALLOC)) { + Location globalLoc = new Location(md, LocationInference.GLOBALLOC); + globalLoc.setLocDescriptor(LocationInference.GLOBALDESC); + locTuple.add(globalLoc); + } else { + // normal case + for (int i = 0; i < descTuple.size(); i++) { + Descriptor curDesc = descTuple.get(i); + Location loc; + if (i == 0) { + loc = new Location(md, curDesc.getSymbol()); + loc.setLocDescriptor(curDesc); + cd = ((VarDescriptor) curDesc).getType().getClassDesc(); + } else { + loc = new Location(cd, curDesc.getSymbol()); + loc.setLocDescriptor(curDesc); + + if (curDesc instanceof FieldDescriptor) { + cd = ((FieldDescriptor) curDesc).getType().getClassDesc(); + } else { + cd = ((LocationDescriptor) curDesc).getEnclosingClassDesc(); + } + + } + locTuple.add(loc); + } + } + + return locTuple; + } + public NTuple getLocationTuple(FlowNode fn) { if (!mapFlowNodeToLocTuple.containsKey(fn)) { @@ -571,8 +623,8 @@ public class FlowGraph { FlowNode u = flowEdge.getSrc(); FlowNode v = flowEdge.getDst(); - if (u.getDescTuple().equals(flowEdge.getInitTuple()) - && v.getDescTuple().equals(flowEdge.getEndTuple())) { + if (u.getLocTuple().equals(flowEdge.getInitTuple()) + && v.getLocTuple().equals(flowEdge.getEndTuple())) { // only draw an edge of the actual value flow if (!addedEdgeSet.contains(flowEdge)) { @@ -623,7 +675,7 @@ public class FlowGraph { while (iter.hasNext()) { FlowNode node = iter.next(); - if (node.getDescTuple().size() == 1) { + if (node.getLocTuple().size() == 1) { // here, we just care about the local variable if (node.getFieldNodeSet().size() > 0) { drawSubgraph(node, bw, addedEdgeSet); diff --git a/Robust/src/Analysis/SSJava/FlowNode.java b/Robust/src/Analysis/SSJava/FlowNode.java index cdd9bd47..45de718a 100644 --- a/Robust/src/Analysis/SSJava/FlowNode.java +++ b/Robust/src/Analysis/SSJava/FlowNode.java @@ -11,7 +11,7 @@ import IR.VarDescriptor; public class FlowNode { // descriptor tuple is a unique identifier of the flow node - private NTuple descTuple; + private NTuple locTuple; // if the infer node represents the base type of field access, // this set contains fields of the base type @@ -40,26 +40,26 @@ public class FlowNode { return fieldNodeSet; } - public FlowNode(NTuple tuple) { + public FlowNode(NTuple tuple) { this.isSkeleton = false; this.isIntermediate = false; - NTuple base = null; - Descriptor desc = null; + NTuple base = null; + Location loc = null; if (tuple.size() > 1) { base = tuple.subList(0, tuple.size() - 1); - desc = tuple.get(tuple.size() - 1); + loc = tuple.get(tuple.size() - 1); } else { base = tuple; } fieldNodeSet = new HashSet(); - descTuple = new NTuple(); + locTuple = new NTuple(); if (base != null) { - descTuple.addAll(base); + locTuple.addAll(base); } - if (desc != null) { - descTuple.add(desc); + if (loc != null) { + locTuple.add(loc); } } @@ -76,12 +76,8 @@ public class FlowNode { fieldNodeSet.add(node); } - public NTuple getDescTuple() { - return descTuple; - } - - public Descriptor getOwnDescriptor() { - return descTuple.get(descTuple.size() - 1); + public NTuple getLocTuple() { + return locTuple; } public boolean isReturn() { @@ -92,35 +88,24 @@ public class FlowNode { this.isReturn = isReturn; } - public boolean isPrimitiveType() { - Descriptor desc = descTuple.get(descTuple.size() - 1); - if (desc instanceof VarDescriptor) { - return ((VarDescriptor) desc).getType().isPrimitive(); - } else if (desc instanceof FieldDescriptor) { - return ((FieldDescriptor) desc).getType().isPrimitive(); - } - return false; - } - public String toString() { String rtr = "[FlowNode]:"; if (isSkeleton()) { rtr += "SKELETON:"; } - rtr += ":" + descTuple; + rtr += ":" + locTuple; return rtr; } - public int hashCode() { - return 7 + descTuple.hashCode(); + return 7 + locTuple.hashCode(); } public boolean equals(Object obj) { if (obj instanceof FlowNode) { FlowNode in = (FlowNode) obj; - if (descTuple.equals(in.getDescTuple())) { + if (locTuple.equals(in.getLocTuple())) { return true; } } @@ -131,8 +116,8 @@ public class FlowNode { public String getID() { String id = ""; - for (int i = 0; i < descTuple.size(); i++) { - id += descTuple.get(i).getSymbol(); + for (int i = 0; i < locTuple.size(); i++) { + id += locTuple.get(i).getSymbol(); } return id; } @@ -140,11 +125,11 @@ public class FlowNode { public String getPrettyID() { String id = "<"; String property = ""; - for (int i = 0; i < descTuple.size(); i++) { + for (int i = 0; i < locTuple.size(); i++) { if (i != 0) { id += ","; } - id += descTuple.get(i).getSymbol(); + id += locTuple.get(i).getSymbol(); } id += ">"; @@ -175,10 +160,22 @@ public class FlowNode { return isDeclarationNode; } + public NTuple getCurrentLocTuple() { + if (compLoc == null) { + return locTuple; + } + NTuple curLocTuple = new NTuple(); + for (int i = 0; i < compLoc.getSize(); i++) { + Location locElement = compLoc.get(i); + curLocTuple.add(locElement); + } + return curLocTuple; + } + public NTuple getCurrentDescTuple() { if (compLoc == null) { - return descTuple; + return getDescTuple(); } NTuple curDescTuple = new NTuple(); @@ -197,4 +194,12 @@ public class FlowNode { this.isSkeleton = isSkeleton; } + public NTuple getDescTuple() { + NTuple descTuple = new NTuple(); + for (int i = 0; i < locTuple.size(); i++) { + descTuple.add(locTuple.get(i).getLocDescriptor()); + } + return descTuple; + } + } diff --git a/Robust/src/Analysis/SSJava/Location.java b/Robust/src/Analysis/SSJava/Location.java index 98a05497..c91b472f 100644 --- a/Robust/src/Analysis/SSJava/Location.java +++ b/Robust/src/Analysis/SSJava/Location.java @@ -14,6 +14,12 @@ public class Location implements TypeExtension { String loc; Descriptor locDesc; + public Location(Descriptor enclosingDesc, Descriptor locDescriptor) { + this.d = enclosingDesc; + this.locDesc = locDescriptor; + this.loc = locDescriptor.getSymbol(); + } + public Location(Descriptor d, String loc) { this.d = d; this.loc = loc; diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java index dfa8e0e7..36645aa1 100644 --- a/Robust/src/Analysis/SSJava/LocationInference.java +++ b/Robust/src/Analysis/SSJava/LocationInference.java @@ -293,10 +293,157 @@ public class LocationInference { } } + + // DEBUG: write a global flow graph + MethodDescriptor mdContainingSSJavaLoop = ssjava.getMethodContainingSSJavaLoop(); + FlowGraph globalFlowGraph = getSubGlobalFlowGraph(mdContainingSSJavaLoop); + // System.out.println("GLOBAL NODE SET=" + globalFlowGraph.getNodeSet()); + assignCompositeLocation(globalFlowGraph); + try { + globalFlowGraph.writeGraph("_GLOBAL"); + } catch (IOException e) { + e.printStackTrace(); + } // _debug_printGraph(); } + private void assignCompositeLocation(FlowGraph globalFlowGraph) { + Set nodeSet = globalFlowGraph.getNodeSet(); + + for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { + FlowNode flowNode = (FlowNode) iterator.next(); + Set inNodeSet = globalFlowGraph.getIncomingFlowNodeSet(flowNode); + Set reachableNodeSet = globalFlowGraph.getReachFlowNodeSetFrom(flowNode); + + // System.out.println("flowNode=" + flowNode + " incoming=" + inNodeSet); + // System.out.println("reachableNodeSet=" + reachableNodeSet); + + Map, Set>> mapPrefixToIncomingLocTupleSet = + new HashMap, Set>>(); + + List> prefixList = new ArrayList>(); + + for (Iterator iterator2 = inNodeSet.iterator(); iterator2.hasNext();) { + FlowNode inNode = (FlowNode) iterator2.next(); + + NTuple inNodeTuple = inNode.getCurrentDescTuple(); + + // CompositeLocation inNodeInferredLoc = + // generateInferredCompositeLocation(methodInfo, inNodeTuple); + // NTuple inNodeInferredLocTuple = inNodeInferredLoc.getTuple(); + + for (int i = 1; i < inNodeTuple.size(); i++) { + NTuple prefix = inNodeTuple.subList(0, i); + if (!prefixList.contains(prefix)) { + prefixList.add(prefix); + } + } + } + + Collections.sort(prefixList, new Comparator>() { + public int compare(NTuple arg0, NTuple arg1) { + int s0 = arg0.size(); + int s1 = arg1.size(); + if (s0 > s1) { + return -1; + } else if (s0 == s1) { + return 0; + } else { + return 1; + } + } + }); + + // find out reachable nodes that have the longest common prefix + for (int i = 0; i < prefixList.size(); i++) { + NTuple curPrefix = prefixList.get(i); + Set> reachableCommonPrefixSet = new HashSet>(); + + for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) { + FlowNode reachableNode = (FlowNode) iterator2.next(); + NTuple reachLocTuple = reachableNode.getCurrentDescTuple(); + if (reachLocTuple.startsWith(curPrefix)) { + reachableCommonPrefixSet.add(reachLocTuple); + } + } + + if (!reachableCommonPrefixSet.isEmpty()) { + // found reachable nodes that start with the prefix curPrefix + // need to assign a composite location + // System.out.println("-prefixList=" + prefixList); + // System.out.println("-reachableCommonPrefixSet=" + reachableCommonPrefixSet); + // System.out.println("-curPrefix=" + curPrefix); + + // first, check if there are more than one the set of locations that has + // the same length of the longest reachable prefix, no way to assign + // a composite location to the input local var + prefixSanityCheck(prefixList, i, globalFlowGraph, reachableNodeSet); + + MethodDescriptor topMethodDesc = globalFlowGraph.getMethodDescriptor(); + CompositeLocation newCompLoc = generateCompositeLocation(curPrefix, topMethodDesc); + + System.out.println("SET COMPOSITE LOCATION=" + newCompLoc + " to " + flowNode); + flowNode.setCompositeLocation(newCompLoc); + } + } + + } + + } + + private CompositeLocation generateCompositeLocation(NTuple curPrefix, + MethodDescriptor md) { + CompositeLocation newCompLoc = new CompositeLocation(); + + Descriptor enclosingDesc = md; + for (int i = 0; i < curPrefix.size(); i++) { + Descriptor curDesc = curPrefix.get(i); + Location loc = new Location(enclosingDesc, curDesc.getSymbol()); + newCompLoc.addLocation(loc); + if (i == 0) { + VarDescriptor varDesc = (VarDescriptor) curDesc; + enclosingDesc = varDesc.getType().getClassDesc(); + } else { + FieldDescriptor fieldDesc = (FieldDescriptor) curDesc; + enclosingDesc = fieldDesc.getType().getClassDesc(); + } + } + + LocationDescriptor newLocDescriptor = generateNewLocationDescriptor(); + newLocDescriptor.setEnclosingClassDesc((ClassDescriptor) enclosingDesc); + + Location newLoc = new Location(enclosingDesc, newLocDescriptor.getSymbol()); + newLoc.setLocDescriptor(newLocDescriptor); + newCompLoc.addLocation(newLoc); + + return newCompLoc; + } + + private void prefixSanityCheck(List> prefixList, int curIdx, + FlowGraph globalFlowGraph, Set reachableNodeSet) { + + NTuple curPrefix = prefixList.get(curIdx); + + for (int i = curIdx + 1; i < prefixList.size(); i++) { + NTuple prefixTuple = prefixList.get(i); + + if (curPrefix.startsWith(prefixTuple)) { + continue; + } + + for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) { + FlowNode reachableNode = (FlowNode) iterator2.next(); + NTuple reachLocTuple = reachableNode.getCurrentDescTuple(); + if (reachLocTuple.startsWith(prefixTuple)) { + throw new Error( + "Failed to generate a composite location because there is more than one prefix which is reach to the current node."); + } + } + } + + } + private void addValueFlowsFromCalleeSubGlobalFlowGraph(MethodDescriptor mdCaller, FlowGraph subGlobalFlowGraph) { @@ -420,22 +567,6 @@ public class LocationInference { return callerTuple; } - private NTuple traslateToCalleeParamTupleToCallerArgTuple( - NTuple calleeInitTuple, NTuple callerSrcTuple) { - - NTuple callerInitTuple = new NTuple(); - - for (int i = 0; i < callerSrcTuple.size(); i++) { - callerInitTuple.add(callerSrcTuple.get(i)); - } - - for (int i = 1; i < calleeInitTuple.size(); i++) { - callerInitTuple.add(calleeInitTuple.get(i)); - } - - return callerInitTuple; - } - private NTuple translateToCaller(NTuple dstDescTuple, NTuple baseTuple) { NTuple callerDescTuple = new NTuple(); @@ -475,16 +606,14 @@ public class LocationInference { for (int paramIdx = 0; paramIdx < flowGraph.getNumParameters(); paramIdx++) { FlowNode flowNode = flowGraph.getParamFlowNode(paramIdx); - NTuple descTuple = flowNode.getDescTuple(); + NTuple locTuple = flowNode.getLocTuple(); CompositeLocation assignedCompLoc = flowNode.getCompositeLocation(); CompositeLocation inferredCompLoc; if (assignedCompLoc != null) { inferredCompLoc = translateCompositeLocation(assignedCompLoc); } else { - Descriptor locDesc = descTuple.get(0); - Location loc = new Location(md, locDesc.getSymbol()); - loc.setLocDescriptor(locDesc); + Location loc = locTuple.get(0); inferredCompLoc = new CompositeLocation(loc); } System.out.println("-paramIdx=" + paramIdx + " infer=" + inferredCompLoc); @@ -1157,7 +1286,7 @@ public class LocationInference { Set nodeSet = fg.getNodeSet(); for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { FlowNode flowNode = (FlowNode) iterator.next(); - if (flowNode.getDescTuple().get(0).equals(md.getThis())) { + if (flowNode.getLocTuple().get(0).equals(md.getThis())) { return true; } } @@ -2736,7 +2865,7 @@ public class LocationInference { CompositeLocation inferSrcLoc; CompositeLocation inferDstLoc = methodInfo.getInferLocation(dstDesc); - if (srcNode.getDescTuple().size() > 1) { + if (srcNode.getLocTuple().size() > 1) { // field access inferSrcLoc = new CompositeLocation(); @@ -2749,7 +2878,7 @@ public class LocationInference { inferSrcLoc = methodInfo.getInferLocation(srcDesc); } - if (dstNode.getDescTuple().size() > 1) { + if (dstNode.getLocTuple().size() > 1) { // field access inferDstLoc = new CompositeLocation(); @@ -2850,7 +2979,7 @@ public class LocationInference { // first, check if there are more than one the set of locations that has // the same length of the longest reachable prefix, no way to assign // a composite location to the input local var - prefixSanityCheck(prefixList, i, flowGraph, reachableNodeSet); + // prefixSanityCheck(prefixList, i, flowGraph, reachableNodeSet); Set> incomingCommonPrefixSet = mapPrefixToIncomingLocTupleSet.get(curPrefix); @@ -2889,7 +3018,7 @@ public class LocationInference { methodInfo.removeMaplocalVarToLocSet(srcLocalVar); // add the field/var descriptor to the set of the location symbol - int lastIdx = srcNode.getDescTuple().size() - 1; + int lastIdx = srcNode.getLocTuple().size() - 1; Descriptor lastFlowNodeDesc = srcNode.getDescTuple().get(lastIdx); NTuple srcNodelocTuple = flowGraph.getLocationTuple(srcNode); Descriptor enclosinglastLastFlowNodeDesc = srcNodelocTuple.get(lastIdx).getDescriptor(); @@ -2931,7 +3060,7 @@ public class LocationInference { methodInfo.removeMaplocalVarToLocSet(localVarDesc); // add the field/var descriptor to the set of the location symbol - int lastIdx = flowNode.getDescTuple().size() - 1; + int lastIdx = flowNode.getLocTuple().size() - 1; Descriptor lastFlowNodeDesc = flowNode.getDescTuple().get(lastIdx); Descriptor enclosinglastLastFlowNodeDesc = flowNodelocTuple.get(lastIdx).getDescriptor(); @@ -3129,29 +3258,6 @@ public class LocationInference { } - private void prefixSanityCheck(List> prefixList, int curIdx, - FlowGraph flowGraph, Set reachableNodeSet) { - - NTuple curPrefix = prefixList.get(curIdx); - - for (int i = curIdx + 1; i < prefixList.size(); i++) { - NTuple prefixTuple = prefixList.get(i); - - if (curPrefix.startsWith(prefixTuple)) { - continue; - } - - for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) { - FlowNode reachableNode = (FlowNode) iterator2.next(); - NTuple reachLocTuple = flowGraph.getLocationTuple(reachableNode); - if (reachLocTuple.startsWith(prefixTuple)) { - // TODO - throw new Error("Failed to generate a composite location"); - } - } - } - } - public boolean isPrimitiveLocalVariable(FlowNode node) { VarDescriptor varDesc = (VarDescriptor) node.getDescTuple().get(0); return varDesc.getType().isPrimitive(); @@ -3213,8 +3319,8 @@ public class LocationInference { private void extractRelationFromFieldFlows(ClassDescriptor cd, FlowNode srcNode, FlowNode dstNode, int idx) throws CyclicFlowException { - if (srcNode.getDescTuple().get(idx).equals(dstNode.getDescTuple().get(idx)) - && srcNode.getDescTuple().size() > (idx + 1) && dstNode.getDescTuple().size() > (idx + 1)) { + if (srcNode.getLocTuple().get(idx).equals(dstNode.getLocTuple().get(idx)) + && srcNode.getLocTuple().size() > (idx + 1) && dstNode.getLocTuple().size() > (idx + 1)) { // value flow between fields: we don't need to add a binary relation // for this case @@ -3582,7 +3688,7 @@ public class LocationInference { if (newImplicitTupleSet.size() > 1) { // need to create an intermediate node for the GLB of conditional locations & implicit flows - NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); + NTuple interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter.hasNext();) { NTuple tuple = idxIter.next(); addFlowGraphEdge(md, tuple, interTuple); @@ -3639,7 +3745,7 @@ public class LocationInference { currentFlowTupleSet.addTupleSet(implicitFlowTupleSet); if (currentFlowTupleSet.size() > 1) { - FlowNode meetNode = fg.createIntermediateNode(); + FlowNode meetNode = fg.createIntermediateNode(md); for (Iterator iterator = currentFlowTupleSet.iterator(); iterator.hasNext();) { NTuple currentFlowTuple = (NTuple) iterator.next(); fg.addValueFlowEdge(currentFlowTuple, meetNode.getDescTuple()); @@ -3670,7 +3776,7 @@ public class LocationInference { if (newImplicitTupleSet.size() > 1) { // need to create an intermediate node for the GLB of conditional locations & implicit flows - NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); + NTuple interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter .hasNext();) { NTuple tuple = idxIter.next(); @@ -3720,7 +3826,7 @@ public class LocationInference { implicitFlowTupleSet, false); // /////////// - NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); + NTuple interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple(); for (Iterator> idxIter = condTupleNode.iterator(); idxIter.hasNext();) { NTuple tuple = idxIter.next(); @@ -3771,7 +3877,7 @@ public class LocationInference { if (newImplicitTupleSet.size() > 1) { // need to create an intermediate node for the GLB of conditional locations & implicit flows - NTuple interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); + NTuple interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple(); for (Iterator> idxIter = newImplicitTupleSet.iterator(); idxIter.hasNext();) { NTuple tuple = idxIter.next(); addFlowGraphEdge(md, tuple, interTuple); @@ -3807,7 +3913,7 @@ public class LocationInference { // creates edges from RHS to LHS NTuple interTuple = null; if (nodeSetRHS.size() > 1) { - interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); + interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple(); } for (Iterator> iter = nodeSetRHS.iterator(); iter.hasNext();) { @@ -4053,7 +4159,7 @@ public class LocationInference { NTuple argTuple = new NTuple(); if (argTupleSet.size() > 1) { NTuple interTuple = - getFlowGraph(md).createIntermediateNode().getDescTuple(); + getFlowGraph(md).createIntermediateNode(md).getDescTuple(); for (Iterator> idxIter = argTupleSet.iterator(); idxIter.hasNext();) { NTuple tuple = idxIter.next(); addFlowGraphEdge(md, tuple, interTuple); @@ -4402,7 +4508,7 @@ public class LocationInference { // creates edges from RHS to LHS NTuple interTuple = null; if (nodeSetRHS.size() > 1) { - interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple(); + interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple(); } for (Iterator> iter = nodeSetRHS.iterator(); iter.hasNext();) { -- 2.34.1