Working with functions and control flow graphs¶

Many of the plugin events are called for each function within the source code being compiled. Each time, the plugin passes a gcc.Function instance as a parameter to your callback, so that you can work on it.

You can get at the control flow graph of a gcc.Function via its cfg attribute. This is an instance of gcc.Cfg.

class gcc.Function¶

Wrapper around one of GCC’s struct function *

cfg¶: An instance of gcc.Cfg for this function (or None during early passes)

decl¶: The declaration of this function, as a gcc.FunctionDecl

local_decls¶

List of gcc.VarDecl for the function’s local variables. It does not contain arguments; for those see the arguments property of the function’s decl.

Note that for locals with initializers, initial only seems to get set on those local_decls that are static variables. For other locals, it appears that you have to go into the gimple representation to locate assignments.

start¶: The gcc.Location of the beginning of the function

end¶: The gcc.Location of the end of the function

funcdef_no¶: Integer: a sequence number for profiling, debugging, etc.

class gcc.Cfg¶

A gcc.Cfg is a wrapper around GCC’s struct control_flow_graph.

basic_blocks¶: List of gcc.BasicBlock, giving all of the basic blocks within this CFG

entry¶: Instance of gcc.BasicBlock: the entrypoint for this CFG

exit¶: Instance of gcc.BasicBlock: the final one within this CFG

get_block_for_label(labeldecl)¶: Given a gcc.LabelDecl, get the corresponding gcc.BasicBlock

You can use gccutils.cfg_to_dot to render a gcc.Cfg as a graphviz diagram. It will render the diagram, showing each basic block, with source code on the left-hand side, interleaved with the “gimple” representation on the right-hand side. Each block is labelled with its index, and edges are labelled with appropriate flags.

For example, given this sample C code:

int
main(int argc, char **argv)
{
    int i;

    printf("argc: %i\n", argc);

    for (i = 0; i < argc; i++) {
        printf("argv[%i]: %s\n", argv[i]);
    }

    helper_function();

    return 0;
}

then the following Python code:

dot = gccutils.cfg_to_dot(fun.cfg)
gccutils.invoke_dot(dot)

will render a CFG bitmap like this:

class gcc.BasicBlock¶

A gcc.BasicBlock is a wrapper around GCC’s basic_block type.

index¶: The index of the block (an int), as seen in the cfg_to_dot rendering.

preds¶: The list of predecessor gcc.Edge instances leading into this block

succs¶: The list of successor gcc.Edge instances leading out of this block

phi_nodes¶: The list of gcc.GimplePhi phoney functions at the top of this block, if appropriate for this pass, or None

gimple¶: The list of gcc.Gimple instructions, if appropriate for this pass, or None

rtl¶: The list of gcc.Rtl expressions, if appropriate for this pass, or None

class gcc.Edge¶

A wrapper around GCC’s edge type.

src¶: The source gcc.BasicBlock of this edge

dest¶: The destination gcc.BasicBlock of this edge

true_value¶: Boolean: True if this edge is taken when a gcc.GimpleCond conditional is true, False otherwise

false_value¶: Boolean: True if this edge is taken when a gcc.GimpleCond conditional is false, False otherwise

complex¶: Boolean: True if this edge is “special” e.g. due to exception-handling, or some other kind of “strange” control flow transfer, False otherwise