struct obstack *obst; /**< The obstack to allocate on. */
ir_node *start_block; /**< The start block of the current graph. */
ir_node *end_block; /**< The end block of the current graph */
- block_info *list; /**< Links all block info entires for easier recovery. */
+ block_info *list; /**< Links all block info entries for easier recovery. */
elim_pair *pairs; /**< A list of node pairs that must be eliminated. */
unsigned last_idx; /**< last node index of "old" nodes, all higher indexes are newly created once. */
char changes; /**< Non-zero, if calculation of Antic_in has changed. */
if (v_pred != pred) {
/* must create a new value here */
- v = new_r_Proj(get_nodes_block(v_pred), v_pred, get_irn_mode(v), get_Proj_proj(v));
+ v = new_r_Proj(v_pred, get_irn_mode(v), get_Proj_proj(v));
}
}
v = identify_remember(value_table, v);
*
* @param block the block
*/
-static block_info *get_block_info(ir_node *block) {
+static block_info *get_block_info(ir_node *block)
+{
return get_irn_link(block);
} /* get_block_info */
* @param block the block
* @param env the environment
*/
-static void alloc_blk_info(ir_node *block, pre_env *env) {
+static void alloc_blk_info(ir_node *block, pre_env *env)
+{
block_info *info = OALLOC(env->obst, block_info);
set_irn_link(block, info);
*
* @param n the node
*/
-static int is_nice_value(ir_node *n) {
+static int is_nice_value(ir_node *n)
+{
ir_mode *mode;
while (is_Proj(n))
* @param txt a text to describe the set
* @param block the owner block of the set
*/
-static void dump_value_set(ir_valueset_t *set, char *txt, ir_node *block) {
+static void dump_value_set(ir_valueset_t *set, char *txt, ir_node *block)
+{
ir_valueset_iterator_t iter;
ir_node *value, *expr;
int i;
* Topological walker. Allocates block info for every block and place nodes in topological
* order into the nodes set.
*/
-static void topo_walker(ir_node *irn, void *ctx) {
+static void topo_walker(ir_node *irn, void *ctx)
+{
pre_env *env = ctx;
ir_node *block;
block_info *info;
* @param block the block
* @param set a value set, containing the already processed predecessors
*/
-static int is_clean_in_block(ir_node *n, ir_node *block, ir_valueset_t *set) {
+static int is_clean_in_block(ir_node *n, ir_node *block, ir_valueset_t *set)
+{
int i;
if (is_Phi(n))
get_irn_in(node));
/* We need the attribute copy here, because the Hash value of a
node might depend on that. */
- copy_node_attr(node, nn);
+ copy_node_attr(current_ir_graph, node, nn);
set_nodes_block(nn, get_nodes_block(node));
for (i = 0; i < arity; ++i) {
* @param block the block
* @param ctx the walker environment
*/
-static void compute_antic(ir_node *block, void *ctx) {
+static void compute_antic(ir_node *block, void *ctx)
+{
pre_env *env = ctx;
block_info *succ_info;
block_info *info = get_block_info(block);
mode,
get_irn_arity(pred),
get_irn_in(pred) + 1);
- copy_node_attr(pred, nn);
+ copy_node_attr(current_ir_graph, pred, nn);
DB((dbg, LEVEL_1, "New node %+F in block %+F created\n", nn, pred_blk));
proj_pred = nn;
mode,
get_irn_arity(e_prime),
get_irn_in(e_prime) + 1);
- copy_node_attr(e_prime, nn);
+ copy_node_attr(current_ir_graph, e_prime, nn);
if (proj_pred != NULL) {
set_Proj_pred(nn, proj_pred);
}
* @param irn the node
* @param ctx the walker environment
*/
-static void eliminate(ir_node *irn, void *ctx) {
+static void eliminate(ir_node *irn, void *ctx)
+{
pre_env *env = ctx;
if (is_no_Block(irn)) {
*
* @param pairs list of elimination pairs
*/
-static void eliminate_nodes(elim_pair *pairs) {
+static void eliminate_nodes(elim_pair *pairs)
+{
elim_pair *p;
for (p = pairs; p != NULL; p = p->next) {
* references the origin. These nodes are translated again and again...
*
* The current fix is to use post-dominance. This simple ignores
- * endless loops, ie we cannot optimize them.
+ * endless loops, i.e. we cannot optimize them.
*/
void do_gvn_pre(ir_graph *irg)
{