Support for ir graph modification. More...

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

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_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.
void	kill_node (ir_node *node)
	Kill a node by setting its predecessors to Bad and finally exchange the node by Bad itself.

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 by setting its predecessors to Bad and finally exchange the node by Bad itself.

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:

node	The 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:

node	The node to be turned into a tuple.
arity	The number of values formed into a Tuple.

Functions

Detailed Description

Function Documentation