private String getCommaSeparatedPath(DFANode node, DFAGraph graph, List<DFANode> pdtNodeList) {
   LinkedList<DFANode> list = new LinkedList<DFANode>();
   list.add(node);
   Set<DFANode> preds = node.getPreds();
   while (preds != null && preds.size() > 0) {
     DFANode parent = preds.iterator().next();
     list.addFirst(parent);
     preds = parent.getPreds();
   }
   StringBuffer retStr = new StringBuffer();
   for (DFANode dfa : list) {
     retStr.append(pdtNodeList.indexOf(dfa));
     retStr.append(",");
   }
   if (PrintTools.getVerbosity() > 1)
     System.out.println(
         "String: "
             + retStr.toString()
             + ", for node: "
             + ((DFANode) ((DFANode) node.getData("revNode")).getData("cfgNode")).getData("ir")
             + "("
             + ((DFANode) ((DFANode) node.getData("revNode")).getData("cfgNode")).getData("tag")
             + ")");
   return retStr.toString();
 }
 private Set<DFANode> getControlDependentSet(CFGEdge edge, DFANode commonAncestor) {
   Set<DFANode> retSet = new HashSet<DFANode>();
   DFANode pdtHead = edge.head.getData("pdtNode");
   Set<DFANode> preds = pdtHead.getPreds();
   retSet.add(pdtHead);
   while (preds != null && preds.size() > 0) {
     DFANode parent = preds.iterator().next();
     if (parent.equals(commonAncestor)) {
       break;
     }
     retSet.add(parent);
     preds = parent.getPreds();
   }
   return retSet;
 }
 private Set<CFGEdge> extractNonPostdominatingEdges(
     DFAGraph reverseCFG, DFAGraph postDomTree, Procedure proc) {
   if (PrintTools.getVerbosity() > 1)
     System.out.println("[extractNonPostdominatingEdges]Proc: " + proc.getSymbolName());
   Set<CFGEdge> retSet = new HashSet<CFGEdge>();
   // extract all the edges from CFG
   Set<CFGEdge> allEdgeList = new HashSet<CFGEdge>();
   Iterator<DFANode> iter = reverseCFG.iterator();
   while (iter.hasNext()) {
     DFANode currentNode = iter.next();
     Set<DFANode> predSet = currentNode.getPreds();
     for (DFANode pred : predSet) {
       // In the reversed cfg, pred is succ in CFG
       allEdgeList.add(new CFGEdge(currentNode, pred));
     }
   }
   List<DFANode> entryNodes = postDomTree.getEntryNodes();
   if (entryNodes.size() != 1) {
     throw new RuntimeException(
         "Size of Entry node on PD Tree is not 1. Size: " + entryNodes.size());
   }
   DFANode entryNode = entryNodes.get(0);
   // extract edge which head does not postdominate tail
   // (head is not parent of tail on PostDomTree)
   for (CFGEdge edge : allEdgeList) {
     //
     DFANode pdtTail = (DFANode) edge.tail.getData("pdtNode");
     DFANode pdtHead = (DFANode) edge.head.getData("pdtNode");
     Set<DFANode> predSet = pdtTail.getPreds();
     boolean postDom = false;
     while (predSet.size() != 0) {
       if (predSet.size() > 1) {
         throw new RuntimeException("The size of predecessor is expected to be less than 2");
       }
       DFANode pdtNode = predSet.iterator().next();
       if (pdtNode.equals(pdtHead)) {
         postDom = true;
         break;
       }
       predSet = pdtNode.getPreds();
     }
     if (postDom == false) {
       retSet.add(edge);
       if (PrintTools.getVerbosity() > 1)
         System.out.println(
             "Found Edge: "
                 + ((DFANode) edge.tail.getData("cfgNode")).getData("ir")
                 + " --> "
                 + ((DFANode) edge.head.getData("cfgNode")).getData("ir")
                 + "("
                 + ((DFANode) edge.head.getData("cfgNode")).getData("tag")
                 + ")");
     }
   }
   return retSet;
 }
  private void buildCDG() {
    if (this.procSet == null) {
      procSet = cfgMap.keySet();
    }
    for (Procedure proc : procSet) {
      System.out.println(
          "Building Control Dependence Graph for Proc: "
              + proc.getSymbolName()
              + ", time: "
              + (new Date()).toString());
      CFGraph cfg = cfgMap.get(proc);
      // reverse the control flow graph
      DFAGraph reversedCFG = SlicingTools.reverseCFGraph(cfg);
      // add additional start node for connecting multiple return node
      // single return node works fine with this.
      DFANode dummyEntryNode = new DFANode();
      List<DFANode> entryList = reversedCFG.getEntryNodes();
      reversedCFG.addNode(dummyEntryNode);
      for (DFANode entry : entryList) {
        dummyEntryNode.addSucc(entry);
        reversedCFG.addEdge(dummyEntryNode, entry);
      }
      //
      ArrayList<DFANode> nodeList = new ArrayList<DFANode>();

      // extract dominator
      BitSet[] dominator = SlicingTools.getDominators(reversedCFG, nodeList);
      int nodeSize = nodeList.size();
      DFANode[] nodeArray = new DFANode[nodeSize];
      nodeList.toArray(nodeArray);
      Set<Integer> entryIdxSet = SlicingTools.getEntryIdxSet(reversedCFG, nodeList);
      List<DFANode> entryNodeList = reversedCFG.getEntryNodes();

      // print dominator
      //            SlicingTools.printDominator(dominator, nodeArray, proc);

      // extract immediate dominator
      BitSet[] immediateDom =
          SlicingTools.getImmediateDominator(dominator, entryIdxSet, entryNodeList, nodeArray);

      // print immediate dominator
      //            SlicingTools.printDominator(immediateDom, nodeArray, proc);

      // build Post Dominance Tree
      if (PrintTools.getVerbosity() > 1)
        System.out.println(
            "############# build Post Dominace Tree (Graph) for "
                + proc.getSymbolName()
                + " ###########");
      DFAGraph postDomTree =
          SlicingTools.buildImmediateDominanceTree(reversedCFG, immediateDom, nodeArray, nodeList);

      // print post dominance tree
      //            SlicingTools.printDominanceTree(postDomTree, proc);

      // extract edges m --> n such that n does not postdominate(dominate in reversed) m
      // CFGEdge's head and tail are on reversed cfg.
      // can get PDTree node by getData("pdtNode")
      Set<CFGEdge> nonPDEdgeSet = extractNonPostdominatingEdges(reversedCFG, postDomTree, proc);

      List<DFANode> pdtNodeList = new ArrayList<DFANode>();
      Iterator<DFANode> pdtIter = postDomTree.iterator();
      int idx = 0;
      while (pdtIter.hasNext()) {
        DFANode node = pdtIter.next();
        pdtNodeList.add(node);
        //            	System.out.println("[" + idx++ + "]" +
        // ((DFANode)((DFANode)node.getData("revNode")).getData("cfgNode")).getData("ir"));
      }
      for (CFGEdge edge : nonPDEdgeSet) {
        // find lowest common ancestor of m and n (result: l)
        DFANode commonAncestor = getLowestCommonAncestor(edge, postDomTree, pdtNodeList);

        // all nodes in N on the path from l to n in the postdominance tree except l
        // are control dependent on m
        Set<DFANode> cdSet = getControlDependentSet(edge, commonAncestor);
        DFANode controllingNode = edge.tail.getData("cfgNode");
        // TODO: handled some corner cases this way but should be fixed later
        // Some wrong controlling nodes are inserted, maybe due to the problem of control flow graph
        if ((controllingNode.getData("ir") instanceof Expression) == false
            && (controllingNode.getData("ir") instanceof SwitchStatement) == false) {
          // filter if a statement is a controlling node (wrong)
          continue;
          // throw new RuntimeException("controllingNode is not expression: " +
          // controllingNode.getData("ir"));
        } else {
          if (controllingNode.getData("ir") instanceof Expression) {
            // filter a stepping expression in the for loop is a controlling node (wrong)
            Expression exp = controllingNode.getData("ir");
            Traversable parent = exp.getParent();
            if (parent instanceof ForLoop) {
              ForLoop fLoop = (ForLoop) parent;
              if (exp.equals(fLoop.getStep())) {
                continue;
              }
            }
          } else if (controllingNode.getData("ir") instanceof SwitchStatement) {

          } else {
            throw new RuntimeException(
                "controllingNode is unexpected type: " + controllingNode.getData("ir"));
          }
        }
        //
        for (DFANode node : cdSet) {
          DFANode revNode = node.getData("revNode");
          if (revNode == null) {
            continue;
          }
          DFANode controlledNode = revNode.getData("cfgNode");
          controlledNode.putData("controlNode", controllingNode);
          if (PrintTools.getVerbosity() > 1)
            System.out.println(
                "[Node]"
                    + controlledNode.getData("ir")
                    + " == control dependent on == [Node]"
                    + controllingNode.getData("ir"));
        }
      }
      // check inter-dependent node
      // remove the controlling node for coming first node toward coming later node
      Iterator<DFANode> cfgIter = cfg.iterator();
      while (cfgIter.hasNext()) {
        DFANode n = cfgIter.next();
        DFANode cdNode = n.getData("controlNode");
        if (cdNode == null) {
          continue;
        }
        DFANode cdCDNode = cdNode.getData("controlNode");
        if (n.equals(cdCDNode)) {
          n.removeData("controlNode");
          //            		throw new RuntimeException("My contol node is dependent on me. my: " + n +
          // ",\n cd: " + cdNode);
        }
      }
      // check a cyclic dependent node and remove it
      cfgIter = cfg.iterator();
      while (cfgIter.hasNext()) {
        DFANode n = cfgIter.next();
        DFANode cdNode = n.getData("controlNode");
        while (cdNode != null) {
          if (cdNode.equals(n)) {
            cdNode.removeData("controlNode");
            break;
            //            			throw new RuntimeException("Cyclic dependency was found!!");
          } else {
            cdNode = cdNode.getData("controlNode");
          }
        }
      }
    }
  }