HashMutablePDG (Soot API)

java.lang.Object
- soot.toolkits.graph.HashMutableEdgeLabelledDirectedGraph<PDGNode,java.lang.String>
- - soot.toolkits.graph.pdg.HashMutablePDG

All Implemented Interfaces:

java.lang.Iterable<PDGNode>, DirectedGraph<PDGNode>, MutableEdgeLabelledDirectedGraph<PDGNode,java.lang.String>, ProgramDependenceGraph
```
public class HashMutablePDG
extends HashMutableEdgeLabelledDirectedGraph<PDGNode,java.lang.String>
implements ProgramDependenceGraph
```
This class implements a Program Dependence Graph as defined in Ferrante, J., Ottenstein, K. J., and Warren, J. D. 1987. The program dependence graph and its use in optimization. ACM Trans. Program. Lang. Syst. 9, 3 (Jul. 1987), 319-349. DOI= http://doi.acm.org/10.1145/24039.24041 Note: the implementation is not exactly as in the above paper. It first finds the regions of control dependence then uses part of the algorithm given in the above paper to build the graph. The constructor accepts a UnitGraph, which can be a BriefUnitGraph, an ExceptionalUnitGraph, or an EnhancedUnitGraph. At the absence of exception handling constructs in a method, all of these work the same. However, at the presence of exception handling constructs, BriefUnitGraph is multi-headed and potentially multi-tailed which makes the results of RegionAnalysis and PDG construction unreliable (It's not clear if it would be useful anyway); Also, ExceptionalGraph's usefulness when exception handling is present is not so clear since almost every unit can throw exception hence the dependency is affected. Currently, the PDG is based on a UnitGraph (BlockGraph) and does not care whether flow is exceptional or not. The nodes in a PDG are of type PDGNode and the edges can have three labels: "dependency", "dependency-back", and "controlflow"; however, the "controlflow" edges are auxiliary and the dependencies are represented by the labels beginning with "dependency". Other labels can be added later for application or domain-specific cases. To support methods that contain exception-handling and multiple-heads or tails, use EnhancedUnitGraph. It does not represent exceptional flow in the way ExceptionalUnitGraph does, but it integrates them in a concise way. Also, it adds START/STOP nodes to graph if necessary to make the graph single entry single exit.

Author:

Hossein Sadat-Mohtasham Sep 2009

Field Summary

Fields
Modifier and Type	Field and Description
`protected BlockGraph`	`m_blockCFG`
`protected Body`	`m_body`
`protected UnitGraph`	`m_cfg`
`protected SootClass`	`m_class`
`protected java.util.Hashtable<java.lang.Object,PDGNode>`	`m_obj2pdgNode`
`protected java.util.List<PDGRegion>`	`m_pdgRegions`
`protected PDGNode`	`m_startNode`
`protected java.util.List<Region>`	`m_strongRegions`
`protected java.util.List<Region>`	`m_weakRegions`

Fields inherited from class soot.toolkits.graph.HashMutableEdgeLabelledDirectedGraph
edgeToLabels, heads, labelToEdges, nodeToPreds, nodeToSuccs, tails

Constructor Summary

Constructors
Constructor and Description

HashMutablePDG(UnitGraph cfg)

Constructors
Constructor and Description
`HashMutablePDG(UnitGraph cfg)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`constructPDG()` This is the heart of the PDG contruction.
`boolean`	`dependentOn(PDGNode node1, PDGNode node2)` This method determines if node1 is control-dependent on node2 in this PDG.
`BlockGraph`	`getBlockGraph()`
`UnitGraph`	`getCFG()`
`java.util.List<PDGNode>`	`getDependents(PDGNode node)` This method returns the list of all dependents of a node in the PDG.
`PDGNode`	`getPDGNode(java.lang.Object cfgNode)` This method returns the PDGNode in the PDG corresponding to the given CFG node.
`java.util.List<PDGRegion>`	`getPDGRegions()` This method returns the list of PDGRegions computed by the construction method.
`static java.util.List<PDGRegion>`	`getPostorderPDGRegionList(PDGNode r)` This method returns a list of regions obtained by post-order traversal of the region hierarchy.
`static java.util.List<IRegion>`	`getPostorderRegionList(IRegion r)`
`static java.util.List<IRegion>`	`getPreorderRegionList(IRegion r)`
`PDGNode`	`GetStartNode()`
`IRegion`	`GetStartRegion()`
`java.util.List<Region>`	`getStrongRegions()`
`java.util.List<Region>`	`getWeakRegions()`
`void`	`removeAllEdges(PDGNode from, PDGNode to)` The existing removeAllEdges in the parent class seems to be throwing concurrentmodification exception most of the time.
`java.lang.String`	`toString()`

Methods inherited from class soot.toolkits.graph.HashMutableEdgeLabelledDirectedGraph
addEdge, addNode, clearAll, clone, containsAnyEdge, containsAnyEdge, containsEdge, containsNode, getEdgesForLabel, getHeads, getLabelsForEdges, getNodes, getPredsOf, getSuccsOf, getTails, iterator, printGraph, removeAllEdges, removeEdge, removeNode, size

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface soot.toolkits.graph.MutableEdgeLabelledDirectedGraph
addEdge, addNode, containsAnyEdge, containsAnyEdge, containsEdge, containsNode, getEdgesForLabel, getLabelsForEdges, getNodes, removeAllEdges, removeEdge, removeNode

Methods inherited from interface soot.toolkits.graph.DirectedGraph
getHeads, getPredsOf, getSuccsOf, getTails, iterator, size

- Field Detail
  - m_body
```
protected Body m_body
```
  - m_class
```
protected SootClass m_class
```
  - m_cfg
```
protected UnitGraph m_cfg
```
  - m_blockCFG
```
protected BlockGraph m_blockCFG
```
  - m_obj2pdgNode
```
protected java.util.Hashtable<java.lang.Object,PDGNode> m_obj2pdgNode
```
  - m_weakRegions
```
protected java.util.List<Region> m_weakRegions
```
  - m_strongRegions
```
protected java.util.List<Region> m_strongRegions
```
  - m_startNode
```
protected PDGNode m_startNode
```
  - m_pdgRegions
```
protected java.util.List<PDGRegion> m_pdgRegions
```
- Constructor Detail
  - HashMutablePDG
```
public HashMutablePDG(UnitGraph cfg)
```
- Method Detail
  - getBlockGraph
```
public BlockGraph getBlockGraph()
```
    Specified by:
    
    getBlockGraph in interface ProgramDependenceGraph
  - constructPDG
```
protected void constructPDG()
```
    This is the heart of the PDG contruction. It is huge and definitely needs some refactorings, but since it's been evlovong to cover some boundary cases it has become hard to rafactor. It uses the list of weak regions, along with the dominator and post-dominator trees to construct the PDG nodes.
  - getCFG
```
public UnitGraph getCFG()
```
    Returns:
    The Corresponding UnitGraph
  - getWeakRegions
```
public java.util.List<Region> getWeakRegions()
```
    Specified by:
    
    getWeakRegions in interface ProgramDependenceGraph
    
    Returns:
    A List of weak regions, generated by RegionAnalysis for the corresponding control flow graph (These are Regions and not PDGRegions.)
  - getStrongRegions
```
public java.util.List<Region> getStrongRegions()
```
    Specified by:
    
    getStrongRegions in interface ProgramDependenceGraph
    
    Returns:
    A List of strong regions, generated when constructing the program dependence graph (These are Regions and not PDGRegions.)
  - GetStartRegion
```
public IRegion GetStartRegion()
```
    Specified by:
    
    GetStartRegion in interface ProgramDependenceGraph
    
    Returns:
    The root region of the PDG.
  - GetStartNode
```
public PDGNode GetStartNode()
```
    Specified by:
    
    GetStartNode in interface ProgramDependenceGraph
    
    Returns:
    The root node of the PDG, which is essentially the same as the start region but packaged in its PDGNode, which can be used to traverse the graph, etc.
  - getPreorderRegionList
```
public static java.util.List<IRegion> getPreorderRegionList(IRegion r)
```
  - getPostorderRegionList
```
public static java.util.List<IRegion> getPostorderRegionList(IRegion r)
```
  - getPDGRegions
```
public java.util.List<PDGRegion> getPDGRegions()
```
    This method returns the list of PDGRegions computed by the construction method.
    
    Specified by:
    
    getPDGRegions in interface ProgramDependenceGraph
    
    Returns:
    The list of PDGRegions
  - getPostorderPDGRegionList
```
public static java.util.List<PDGRegion> getPostorderPDGRegionList(PDGNode r)
```
    This method returns a list of regions obtained by post-order traversal of the region hierarchy. This takes advantage of the hierarchical (parent/child) information encoded within the PDGNodes at construction time; it should be noted that, we have not counted the strong regions that represent the loop header as a separate region; instead, a PDGRegion that represents both the loop header and its body are counted.
    
    Parameters:
    The - root from which the traversal should begin.
    
    Returns:
    The list of regions obtained thru post-order traversal of the region hierarchy.
  - dependentOn
```
public boolean dependentOn(PDGNode node1,
                  PDGNode node2)
```
    This method determines if node1 is control-dependent on node2 in this PDG.
    
    Specified by:
    
    dependentOn in interface ProgramDependenceGraph
    
    Returns:
    returns true if node1 is dependent on node2
  - getDependents
```
public java.util.List<PDGNode> getDependents(PDGNode node)
```
    This method returns the list of all dependents of a node in the PDG.
    
    Specified by:
    
    getDependents in interface ProgramDependenceGraph
    
    Parameters:
    node - is the PDG node whose dependents are desired.
    
    Returns:
    a list of dependent nodes
  - getPDGNode
```
public PDGNode getPDGNode(java.lang.Object cfgNode)
```
    This method returns the PDGNode in the PDG corresponding to the given CFG node. Note that currently the CFG node has to be a Block.
    
    Specified by:
    
    getPDGNode in interface ProgramDependenceGraph
    
    Parameters:
    cfgNode - is expected to be a node in CFG (currently only Block).
    
    Returns:
    The node in PDG corresponding to cfgNode.
  - removeAllEdges
```
public void removeAllEdges(PDGNode from,
                  PDGNode to)
```
    The existing removeAllEdges in the parent class seems to be throwing concurrentmodification exception most of the time. Here is a version that doesn't throw that exception.
    
    Specified by:
    
    removeAllEdges in interface MutableEdgeLabelledDirectedGraph<PDGNode,java.lang.String>
    
    Overrides:
    
    removeAllEdges in class HashMutableEdgeLabelledDirectedGraph<PDGNode,java.lang.String>
    
    Parameters:
    from - out node for the edges to remove.
    to - in node for the edges to remove.
  - toString
```
public java.lang.String toString()
```
    Specified by:
    
    toString in interface ProgramDependenceGraph
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    A human readable description of the PDG.

Class HashMutablePDG

Field Summary

Fields inherited from class soot.toolkits.graph.HashMutableEdgeLabelledDirectedGraph

Constructor Summary

Method Summary

Methods inherited from class soot.toolkits.graph.HashMutableEdgeLabelledDirectedGraph

Methods inherited from class java.lang.Object

Methods inherited from interface soot.toolkits.graph.MutableEdgeLabelledDirectedGraph

Methods inherited from interface soot.toolkits.graph.DirectedGraph

Field Detail

m_body

m_class

m_cfg

m_blockCFG

m_obj2pdgNode

m_weakRegions

m_strongRegions

m_startNode

m_pdgRegions

Constructor Detail

HashMutablePDG

Method Detail

getBlockGraph

constructPDG

getCFG

getWeakRegions

getStrongRegions

GetStartRegion

GetStartNode

getPreorderRegionList

getPostorderRegionList

getPDGRegions

getPostorderPDGRegionList

dependentOn

getDependents

getPDGNode

removeAllEdges

toString