simplify by using C99

[libfirm] / ir / be / betranshlp.c

diff --git a/ir/be/betranshlp.c b/ir/be/betranshlp.c
index 24feebe..3c4cbd0 100644 (file)
--- a/ir/be/betranshlp.c
+++ b/ir/be/betranshlp.c
@@ -57,8 +57,6 @@ static be_transform_env_t env;
 
 void be_set_transformed_node(ir_node *old_node, ir_node *new_node)
 {
-       ir_graph *irg = get_irn_irg(old_node);
-
        set_irn_link(old_node, new_node);
        mark_irn_visited(old_node);
        hook_dead_node_elim_subst(irg, old_node, new_node);
@@ -81,10 +79,8 @@ static inline ir_node *be_get_transformed_node(ir_node *old_node)
 
 void be_duplicate_deps(ir_node *old_node, ir_node *new_node)
 {
-       int i;
        int deps = get_irn_deps(old_node);
-
-       for (i = 0; i < deps; ++i) {
+       for (int i = 0; i < deps; ++i) {
                ir_node *dep     = get_irn_dep(old_node, i);
                ir_node *new_dep = be_transform_node(dep);
 
@@ -106,12 +102,11 @@ void be_set_transform_function(ir_op *op, be_transform_func func)
  */
 static ir_node *transform_block(ir_node *node)
 {
-       ir_graph *irg  = get_irn_irg(node);
-       dbg_info *dbgi = get_irn_dbg_info(node);
-       ir_node  *block;
-
-       block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), get_irn_mode(node),
-                           get_irn_arity(node), get_irn_in(node) + 1);
+       ir_graph *irg   = get_irn_irg(node);
+       dbg_info *dbgi  = get_irn_dbg_info(node);
+       ir_mode  *mode  = get_irn_mode(node);
+       ir_node  *block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), mode,
+                                     get_irn_arity(node), get_irn_in(node) + 1);
        copy_node_attr(irg, node, block);
        block->node_nr = node->node_nr;
 
@@ -128,13 +123,10 @@ static ir_node *transform_block(ir_node *node)
 static ir_node *transform_end(ir_node *node)
 {
        /* end has to be duplicated manually because we need a dynamic in array */
-       ir_graph *irg   = get_irn_irg(node);
-       dbg_info *dbgi  = get_irn_dbg_info(node);
-       ir_node  *block = be_transform_node(get_nodes_block(node));
-       int      i, arity;
-       ir_node  *new_end;
-
-       new_end = new_ir_node(dbgi, irg, block, op_End, mode_X, -1, NULL);
+       ir_graph *irg     = get_irn_irg(node);
+       dbg_info *dbgi    = get_irn_dbg_info(node);
+       ir_node  *block   = be_transform_node(get_nodes_block(node));
+       ir_node  *new_end = new_ir_node(dbgi, irg, block, op_End, mode_X, -1, NULL);
        copy_node_attr(irg, node, new_end);
        be_duplicate_deps(node, new_end);
 
@@ -142,8 +134,8 @@ static ir_node *transform_end(ir_node *node)
 
        /* do not transform predecessors yet to keep the pre-transform
         * phase from visiting all the graph */
-       arity = get_irn_arity(node);
-       for (i = 0; i < arity; ++i) {
+       int arity = get_irn_arity(node);
+       for (int i = 0; i < arity; ++i) {
                ir_node *in = get_irn_n(node, i);
                add_End_keepalive(new_end, in);
        }
@@ -178,20 +170,19 @@ ir_node *be_duplicate_node(ir_node *node)
        dbg_info *dbgi  = get_irn_dbg_info(node);
        ir_mode  *mode  = get_irn_mode(node);
        ir_op    *op    = get_irn_op(node);
-       ir_node  *new_node;
-       int      i, arity;
 
-       arity = get_irn_arity(node);
+       ir_node *new_node;
+       int      arity = get_irn_arity(node);
        if (op->opar == oparity_dynamic) {
                new_node = new_ir_node(dbgi, irg, block, op, mode, -1, NULL);
-               for (i = 0; i < arity; ++i) {
+               for (int i = 0; i < arity; ++i) {
                        ir_node *in = get_irn_n(node, i);
                        in = be_transform_node(in);
                        add_irn_n(new_node, in);
                }
        } else {
                ir_node **ins = ALLOCAN(ir_node*, arity);
-               for (i = 0; i < arity; ++i) {
+               for (int i = 0; i < arity; ++i) {
                        ir_node *in = get_irn_n(node, i);
                        ins[i] = be_transform_node(in);
                }
@@ -208,20 +199,17 @@ ir_node *be_duplicate_node(ir_node *node)
 
 ir_node *be_transform_node(ir_node *node)
 {
-       ir_op             *op;
-       ir_node           *new_node = be_get_transformed_node(node);
-       be_transform_func *transform;
-
+       ir_node *new_node = be_get_transformed_node(node);
        if (new_node != NULL)
                return new_node;
 
        DEBUG_ONLY(be_set_transformed_node(node, NULL);)
 
-       op = get_irn_op(node);
+       ir_op *op = get_irn_op(node);
        if (op->ops.generic == NULL) {
                panic("No transform function registered for node %+F.", node);
        }
-       transform = (be_transform_func *)op->ops.generic;
+       be_transform_func *transform = (be_transform_func *)op->ops.generic;
 
        new_node = transform(node);
        assert(new_node != NULL);
@@ -232,11 +220,9 @@ ir_node *be_transform_node(ir_node *node)
 
 void be_enqueue_preds(ir_node *node)
 {
-       int i, arity;
-
        /* put the preds in the worklist */
-       arity = get_irn_arity(node);
-       for (i = 0; i < arity; ++i) {
+       int arity = get_irn_arity(node);
+       for (int i = 0; i < arity; ++i) {
                ir_node *pred = get_irn_n(node, i);
                pdeq_putr(env.worklist, pred);
        }
@@ -247,15 +233,12 @@ void be_enqueue_preds(ir_node *node)
  */
 static void fix_loops(ir_node *node)
 {
-       int i, arity;
-       int changed;
-
        assert(node_is_in_irgs_storage(env.irg, node));
 
        if (irn_visited_else_mark(node))
                return;
 
-       changed = 0;
+       bool changed = false;
        if (! is_Block(node)) {
                ir_node *block     = get_nodes_block(node);
                ir_node *new_block = (ir_node*)get_irn_link(block);
@@ -263,21 +246,21 @@ static void fix_loops(ir_node *node)
                if (new_block != NULL) {
                        set_nodes_block(node, new_block);
                        block = new_block;
-                       changed = 1;
+                       changed = true;
                }
 
                fix_loops(block);
        }
 
-       arity = get_irn_arity(node);
-       for (i = 0; i < arity; ++i) {
+       int arity = get_irn_arity(node);
+       for (int i = 0; i < arity; ++i) {
                ir_node *in = get_irn_n(node, i);
                ir_node *nw = (ir_node*)get_irn_link(in);
 
                if (nw != NULL && nw != in) {
                        set_irn_n(node, i, nw);
                        in = nw;
-                       changed = 1;
+                       changed = true;
                }
 
                fix_loops(in);
@@ -285,18 +268,18 @@ static void fix_loops(ir_node *node)
        /* fix proj block */
        if (is_Proj(node)) {
                set_nodes_block(node, get_nodes_block(get_Proj_pred(node)));
-               changed = 1;
+               changed = true;
        }
 
        arity = get_irn_deps(node);
-       for (i = 0; i < arity; ++i) {
+       for (int i = 0; i < arity; ++i) {
                ir_node *in = get_irn_dep(node, i);
                ir_node *nw = (ir_node*)get_irn_link(in);
 
                if (nw != NULL && nw != in) {
                        set_irn_dep(node, i, nw);
                        in = nw;
-                       changed = 1;
+                       changed = true;
                }
 
                fix_loops(in);
@@ -327,9 +310,6 @@ static void pre_transform_anchor(ir_graph *irg, int anchor)
  */
 static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
 {
-       int       i;
-       ir_node  *old_end, *new_anchor;
-
        hook_dead_node_elim(irg, 1);
 
        inc_irg_visited(irg);
@@ -338,10 +318,10 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
        env.worklist   = new_waitq();
        env.old_anchor = irg->anchor;
 
-       old_end = get_irg_end(irg);
+       ir_node *old_end = get_irg_end(irg);
 
        /* put all anchor nodes in the worklist */
-       for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
+       for (int i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
                ir_node *anchor = get_irg_anchor(irg, i);
 
                if (anchor == NULL)
@@ -349,7 +329,7 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
                waitq_put(env.worklist, anchor);
        }
 
-       new_anchor  = new_r_Anchor(irg);
+       ir_node *new_anchor  = new_r_Anchor(irg);
        irg->anchor = new_anchor;
 
        /* pre transform some anchors (so they are available in the other transform
@@ -372,7 +352,7 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
 
        /* fix loops and set new anchors*/
        inc_irg_visited(irg);
-       for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
+       for (int i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
                ir_node *anchor = get_irn_n(env.old_anchor, i);
 
                if (anchor == NULL)
@@ -391,14 +371,11 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform)
 void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func)
 {
        ir_graph *old_current_ir_graph = current_ir_graph;
-       struct obstack *old_obst = NULL;
-       struct obstack *new_obst = NULL;
-
        current_ir_graph = irg;
 
        /* create a new obstack */
-       old_obst = irg->obst;
-       new_obst = XMALLOC(struct obstack);
+       struct obstack *old_obst = irg->obst;
+       struct obstack *new_obst = XMALLOC(struct obstack);
        obstack_init(new_obst);
        irg->obst = new_obst;
        irg->last_node_idx = 0;