libFirm
irgmod.h File Reference

Support for ir graph modification. More...

#include "firm_types.h"
#include "begin.h"
#include "end.h"

Go to the source code of this file.

Functions

void exchange (ir_node *old, ir_node *nw)
 Exchanges two nodes by conserving edges leaving old (i.e., pointers pointing to old).
void turn_into_tuple (ir_node *node, int arity)
 Turns a node into a "useless" Tuple.
void collect_phiprojs (ir_graph *irg)
 Walks over the passed IR graph and collects all Phi nodes as a list in their corresponding block (using get_Block_phis() API).
void part_block (ir_node *node)
 Parts a block into two.
ir_nodepart_block_edges (ir_node *node)
 Same as part_block() but works with out-edges so you don't have to call collect_phiprojs.
void kill_node (ir_node *node)
 Kill a node.

Detailed Description

Support for ir graph modification.

Author
Martin Trapp, Christian Schaefer, Goetz Lindenmaier

Definition in file irgmod.h.

Function Documentation

void collect_phiprojs ( ir_graph irg)

Walks over the passed IR graph and collects all Phi nodes as a list in their corresponding block (using get_Block_phis() API).

Further it collects all Proj nodes in a list of the node producing the tuple. In case of nested tuples the Projs are collected in the node producing the outermost Tuple. All other link fields are cleared afterwards.

void exchange ( ir_node old,
ir_node nw 
)

Exchanges two nodes by conserving edges leaving old (i.e., pointers pointing to old).

The nodes op will be changed to op_Deleted and you must not do anything with the node anymore except testing its op.

void kill_node ( ir_node node)

Kill a node.

No other node may have this node as operand.

void part_block ( ir_node node)

Parts a block into two.

This is useful to insert other blocks within a given block.

Adds a new block (new_block) in the control flow before the block (old_block) of node. Moves node and its predecessors from old_block to new_block. Moves all Projs that depend on moved nodes and are in old_block to new_block. Moves all Phi nodes from old_block to new_block. To achieve this the routine assumes that all Phi nodes are in the Phi list (see get_Block_phis()) of old_block. Further it assumes that all Proj nodes are accessible by the link field of the nodes producing the Tuple. This can be established by collect_phiprojs(). part_block() conserves this property. Adds a Jmp node to new_block that jumps to old_block.

Parameters
nodeThe node were to break the block
ir_node* part_block_edges ( ir_node node)

Same as part_block() but works with out-edges so you don't have to call collect_phiprojs.

This variant also removes all predecessors of the old block and returns it. You are responsible to add control flow predecessors to it.

void turn_into_tuple ( ir_node node,
int  arity 
)

Turns a node into a "useless" Tuple.

Turns a node into a "useless" Tuple. The Tuple node just forms a tuple from several inputs. All predecessors of the tuple are set to bad and should be replaced if necssary. The block predecessor remains the same. This is useful if a node returning a tuple is removed, but the Projs extracting values from the tuple are not available.

Parameters
nodeThe node to be turned into a tuple.
arityThe number of values formed into a Tuple.