Map<Set<HNode>, HNode> mapCombineNodeSetToCombinationNode;
Map<Set<HNode>, Set<HNode>> mapCombineNodeSetToOutgoingNodeSet;
+ Map<HNode, Set<HNode>> mapNormalNodeToSCNodeReachToSet;
+
Set<HNode> nodeSet;
// for the lattice generation
mapHNodeNameToCurrentHNode = new HashMap<String, HNode>();
+ mapNormalNodeToSCNodeReachToSet = new HashMap<HNode, Set<HNode>>();
}
public Descriptor getDesc() {
return;
}
+ System.out.println("--- CYCLIC VALUE FLOW: " + srcHNode + " -> " + dstHNode);
HNode newMergeNode = mergeNodes(possibleCycleSet, false);
newMergeNode.setSharedNode(true);
- System.out.println("### INTRODUCE A NEW MERGE NODE: " + newMergeNode);
- System.out.println("### CYCLIC VALUE FLOW: " + srcHNode + " -> " + dstHNode + "\n");
+
} else {
getIncomingNodeSet(dstHNode).add(srcHNode);
getOutgoingNodeSet(srcHNode).add(dstHNode);
newNode.setSkeleton(true);
}
+ if (d.equals(LocationInference.TOPDESC)) {
+ newNode.setSkeleton(true);
+ }
+
String symbol = d.getSymbol();
if (symbol.startsWith(LocationInference.PCLOC) || symbol.startsWith(LocationInference.RLOC)) {
newNode.setSkeleton(true);
// if the input set contains a skeleton node, need to set a new merge node as skeleton also
boolean hasSkeleton = false;
+ boolean hasShared = false;
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
HNode inNode = (HNode) iterator.next();
if (inNode.isSkeleton()) {
hasSkeleton = true;
- break;
+ }
+ if (inNode.isSharedNode()) {
+ hasShared = true;
}
}
- System.out.println("--Set merging node=" + newMergeNode + " as a skeleton=" + set
- + " hasSkeleton=" + hasSkeleton + " CUR DESC=" + desc);
+ // System.out.println("-----Set merging node=" + newMergeNode + " as a skeleton=" + set
+ // + " hasSkeleton=" + hasSkeleton + " CUR DESC=" + desc);
newMergeNode.setSkeleton(hasSkeleton);
+ newMergeNode.setSharedNode(hasShared);
+
+ System.out.println("-----MERGING NODE=" + set + " new node=" + newMergeNode);
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
HNode node = (HNode) iterator.next();
HNode mergedNode = (HNode) iterator.next();
addMapHNodeToCurrentHNode(mergedNode, newMergeNode);
}
- System.out.println("###mergedSkeletonNode=" + mergedSkeletonNode);
- System.out.println("###MERGING NODE=" + set + " new node=" + newMergeNode);
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
HNode hNode = (HNode) iterator.next();
System.out.println("old=" + hNode + "----->newNode=" + getCurrentHNode(hNode));
}
+ System.out.println();
+
return newMergeNode;
}
if (curNode.isMergeNode()) {
Set<HNode> mergingSet = getMergingSet(curNode);
mergingSet.add(curNode);
- System.out.println("addMapHNodeToCurrentHNode curNode=" + curNode + " meringSet="
- + mergingSet);
+ System.out.println("-------addMapHNodeToCurrentHNode curNode=" + curNode + " meringSet="
+ + mergingSet + " newNode=" + newNode);
for (Iterator iterator = mergingSet.iterator(); iterator.hasNext();) {
HNode mergingNode = (HNode) iterator.next();
mapHNodeToCurrentHNode.put(mergingNode, newNode);
}
+ public Set<HNode> getReachableSCNodeSet(HNode startNode) {
+ // returns the set of hnodes which is reachable from the startNode and is either SC node or a
+ // node which is directly connected to the SC nodes
+ Set<HNode> reachable = new HashSet<HNode>();
+ Set<HNode> visited = new HashSet<HNode>();
+ visited.add(startNode);
+ recurReachableNodeSet(startNode, visited, reachable);
+ return reachable;
+ }
+
+ public Set<HNode> getSCNodeReachToSet(HNode node) {
+ if (!mapNormalNodeToSCNodeReachToSet.containsKey(node)) {
+ mapNormalNodeToSCNodeReachToSet.put(node, new HashSet<HNode>());
+ }
+ return mapNormalNodeToSCNodeReachToSet.get(node);
+ }
+
+ private void recurReachableNodeSet(HNode node, Set<HNode> visited, Set<HNode> reachable) {
+
+ Set<HNode> outSet = getOutgoingNodeSet(node);
+ for (Iterator iterator = outSet.iterator(); iterator.hasNext();) {
+ HNode out = (HNode) iterator.next();
+
+ if (!visited.contains(out)) {
+ visited.add(out);
+ Set<HNode> reachableFromSCNodeSet = reachableFromSCNode(out);
+ mapNormalNodeToSCNodeReachToSet.put(out, reachableFromSCNodeSet);
+ if (out.isSkeleton() || out.isCombinationNode() || reachableFromSCNodeSet.size() > 0) {
+ reachable.add(out);
+ } else {
+ visited.add(out);
+ recurReachableNodeSet(out, visited, reachable);
+ }
+
+ }
+
+ }
+
+ }
+
+ private Set<HNode> reachableFromSCNode(HNode node) {
+ Set<HNode> visited = new HashSet<HNode>();
+ visited.add(node);
+ Set<HNode> reachable = new HashSet<HNode>();
+ recurReachableFromSCNode(node, reachable, visited);
+ return reachable;
+ }
+
+ private void recurReachableFromSCNode(HNode node, Set<HNode> reachable, Set<HNode> visited) {
+ Set<HNode> inNodeSet = getIncomingNodeSet(node);
+ for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
+ HNode inNode = (HNode) iterator.next();
+ if (inNode.isSkeleton() || inNode.isCombinationNode()) {
+ visited.add(inNode);
+ reachable.add(inNode);
+ } else if (!visited.contains(inNode)) {
+ visited.add(inNode);
+ recurReachableFromSCNode(inNode, reachable, visited);
+ }
+ }
+ }
+
public Set<HNode> getDirectlyReachableSkeletonCombinationNodeFrom(HNode node,
Set<HNode> combinationNodeSet) {
Set<HNode> reachable = new HashSet<HNode>();