CFG

Performance counter reserved for internal use.

Create a CFG using a pre-computed list of partial basic block.

Create a CFG by recursively parsing a list of instructions.

Shallow duplication of the current CFG. The graph is reconstructed; the instructions are not duplicated.

Add a block, does nothing else. The block is not connected, it is up to client code to connect it.

Insert a block, does nothing else. The block is not connected, it is up to client code to connect it.

Append an out-edge. Duplicates are not allowed.

Add an out-edge. Duplicates are allowed.

Connect (irregularly) a source block to destination block. This method allows the addition of duplicate connections.

Connect (irregularly) a source block to destination block. This method does NOT allow the addition of duplicate connections.

This method should not be used. Use addIrregularEdge(BasicBlock, BasicBlock, int) instead.

Get an instruction-with-address iterator. Also see instructions().

Determine whether the CFG contains the provided instruction.

Create an unmanaged data flow analysis object initialized with this CFG's DFA settings. These objects are not managed by this CFG object. For managed DFA objects, clients should use doDataFlowAnalysis() or #getDataFlowAnalysis().

Delete an edge x->y.

Delete an edge x->y. If duplicates exist, the first one in the list of out-edges is deleted.

Delete an irregular edge x->y. If duplicates exist, the first one in the list of irrout-edges is deleted.

Delete an irregular edge x->y.

Delete all irregular output edges for the provided block.

Delete all regular output edges for the provided block.

Create or retrieve a DFA object with current settings.

Create or retrieve a DFA object with current settings.

Create or retrieve a DFA object.

Format the CFG into a printable string.

Format the CFG into a printable string. Instruction addresses are included, edges are appended to the CFG.

Format the edges of this CFG to a string.

(Re-)generate the irregular control flow information present in this CFG.

Retrieve a basic block.

Get a complete map of the basic blocks and their addresses in the CFG. This method is recommended for use when multiple, repeated invocations of #getBlockAt(int) are to be made.

Get the basic block that starts at the provided address or offset.

Get the basic block that contains the provided address.

Note that the address just needs to be in the block address range; it does not need to point to the beginning of an instruction within the block

Get the basic block that ends on the provided address.

Get a copy of the block list of the CFG. The list is ordered by ascending block address. Modifying the list does not impact the CFG.

Get a read-only view of the list of blocks for this CFG. The list is ordered by ascending block address.

Retrieve a list of all managed data flow analysis objects.

Note that the initial value is set to STANDARD_COLLECTION_FLAGS.

Retrieve a valid DFA object done with standard parameters (conservative, with inputs, no copies).

Retrieve a valid DFA object matching the provided parameters.

Calculate the 'effective' size of this CFG, that is, the sum of the size of each basic block.

Routine highest address (exclusive).

Routine entry-point address. Note that this address may not be the lowest one in the CFG.

Get the entry block. The entry block is unique.

Get the ordered list of exit blocks. A CFG may have zero or more exit blocks; CFG representing standard routines will have at least one (generally one) exit block.

Routine lowest address (inclusive). Note that this address may not be the entry-point address for this routine.

Get the a graph representation of the CFG. The list of edges return use a 1-based node numbering scheme.

Get the instruction located at the exact address.

Get the total number of instructions in the CFG. This method sums the number of instructions of each block of the CFG.

Locate an instruction.

Locate an instruction.

Retrieve an ordered dictionary of instructions.

Get the instruction list of this CFG by aggregating each instruction of every block. The list is ordered by ascending address/offset.

Routine highest address (inclusive).

Determine if this CFG has exit blocks, that is, blocks without out-edges.

Determine if this CFG does not have any exit block.

Iterate over a range of instructions of this CFG.

Iterate over all the instructions of this CFG.

Partially invalidate data flow analyses. This method can be used after modifying an instruction of the CFG.

Invalidate all previously performed data flow analyses. This method can be used after a CFG modification that would render DFA objects obsoletes.

Note that the initial value is set to STANDARD_INTEGRATE_INPUTS.

This method reconnects a block x from y to z, i.e. x->y becomes x->z. If z is null, this method deletes the edge x>y.

This method reconnects a block x from y to z, i.e. x->y becomes x->z. Duplicates edges are forbidden.

See reconnectEdge(BasicBlock, BasicBlock, BasicBlock, Integer).

This method irregularly reconnects a block x from y to z, i.e. x->y becomes x->z. If z is null, this method deletes the irregular edge x>y.

This method irregularly reconnects a block x from y to z, i.e. x->y becomes x->z. Duplicates edges are forbidden.

See reconnectIrregularEdge(BasicBlock, BasicBlock, BasicBlock, Integer).

Remove a block, and update the fixtures. This method is content-agnostic.

A CFG should never contain empty blocks. However, when the CFG is optimized, instructions are removed, and some nodes might end up empty. This transient, stale state is fine AS LONG AS the client knows what it is doing and removes the empty block as soon as they're done, before passing it down the processing chain. This method removes empty blocks and updates the edges of connected and connecting blocks.

1st caveat: the empty block's out-degree or in-degree MUST be one. (Otherwise, stitching up the edges would not be possible.)

2nd caveat: duplicate edges can be introduced. The client should remove them if it doesn't like that.

3rd caveat: the fixtures update is instruction-agnostic. This means that the client is solely responsible regarding the decision to remove an empty block. For instance, the last instruction of the predecessor block should be checked and the client should make sure that removing the block and updating the fixtures is an operation compatible with the semantics of that last instruction.

Remove duplicate edges (regular) from a source block to a destination block.

Remove duplicate irregular edges from a source block to a destination block.

Reorganize the input block list so that the fallthrough input block, if any, is placed first.

Note that the initial value is set to STANDARD_COLLECTION_FLAGS.

Note that the initial value is set to STANDARD_INTEGRATE_INPUTS.

Merge the blocks that can be merged, without changing the flow of the graph.

Necessary conditions include: adjacent blocks, first block falls-through the second one, no block shall have irregular outputs, only the first block may have irregular inputs.

Merge blocks that can be merged, taking into accounts irregular flows.
A follow through may be merged with a block inside a try (with irregular outedges) if no instruction within the block can raise.

Get the number of blocks.

Split a block into two blocks. Note that the newly-created block will be set up to have the same irregular outputs as the original block.