fixed some warnings

[libfirm] / ir / ir / irgopt.c

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 819e80b..971e0c1 100644 (file)
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -35,7 +35,7 @@
 #include "irprog_t.h"
 
 #include "iroptimize.h"
-#include "ircons.h"
+#include "ircons_t.h"
 #include "iropt_t.h"
 #include "irgopt.h"
 #include "irgmod.h"
@@ -68,7 +68,11 @@
  */
 static void optimize_in_place_wrapper (ir_node *n, void *env) {
        ir_node *optimized = optimize_in_place_2(n);
-       if (optimized != n) exchange (n, optimized);
+       (void) env;
+
+       if (optimized != n) {
+               exchange (n, optimized);
+       }
 }
 
 /**
@@ -111,6 +115,8 @@ void local_optimize_node(ir_node *n) {
  * Block-Walker: uses dominance depth to mark dead blocks.
  */
 static void kill_dead_blocks(ir_node *block, void *env) {
+       (void) env;
+
        if (get_Block_dom_depth(block) < 0) {
                /*
                 * Note that the new dominance code correctly handles
@@ -357,10 +363,10 @@ static void copy_node(ir_node *n, void *env) {
  * Copies new predecessors of old node to new node remembered in link.
  * Spare the Bad predecessors of Phi and Block nodes.
  */
-void
-copy_preds(ir_node *n, void *env) {
+static void copy_preds(ir_node *n, void *env) {
        ir_node *nn, *block;
        int i, j, irn_arity;
+       (void) env;
 
        nn = get_new_node(n);
 
@@ -490,8 +496,8 @@ static void copy_graph(ir_graph *irg, int copy_node_nr) {
        /* Note: from yet, the visited flag of the graph is equal to vfl + 1 */
 
        /* visit the anchors as well */
-       for (i = anchor_max - 1; i >= 0; --i) {
-               ir_node *n = irg->anchors[i];
+       for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
+               ir_node *n = get_irg_anchor(irg, i);
 
                if (n && (get_irn_visited(n) <= vfl)) {
                        set_irg_visited(irg, vfl);
@@ -548,7 +554,7 @@ static void copy_graph(ir_graph *irg, int copy_node_nr) {
 static void
 copy_graph_env(int copy_node_nr) {
        ir_graph *irg = current_ir_graph;
-       ir_node *old_end, *n;
+       ir_node *old_end, *new_anchor;
        int i;
 
        /* remove end_except and end_reg nodes */
@@ -559,9 +565,10 @@ copy_graph_env(int copy_node_nr) {
        /* Not all nodes remembered in irg might be reachable
           from the end node.  Assure their link is set to NULL, so that
           we can test whether new nodes have been computed. */
-       for (i = anchor_max - 1; i >= 0; --i) {
-               if (irg->anchors[i])
-                       set_new_node(irg->anchors[i], NULL);
+       for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
+               ir_node *n = get_irg_anchor(irg, i);
+               if (n != NULL)
+                       set_new_node(n, NULL);
        }
        /* we use the block walk flag for removing Bads from Blocks ins. */
        inc_irg_block_visited(irg);
@@ -569,14 +576,20 @@ copy_graph_env(int copy_node_nr) {
        /* copy the graph */
        copy_graph(irg, copy_node_nr);
 
-       /* fix the fields in irg */
-       old_end = get_irg_end(irg);
-       for (i = anchor_max - 1; i >= 0; --i) {
-               n = irg->anchors[i];
+       /* fix the anchor */
+       old_end    = get_irg_end(irg);
+       new_anchor = new_Anchor(irg);
+
+       for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) {
+               ir_node *n = get_irg_anchor(irg, i);
                if (n)
-                       irg->anchors[i] = get_new_node(n);
+                       set_irn_n(new_anchor, i, get_new_node(n));
        }
        free_End(old_end);
+       irg->anchor = new_anchor;
+
+       /* ensure the new anchor is placed in the endblock */
+       set_irn_n(new_anchor, -1, get_irg_end_block(irg));
 }
 
 /**
@@ -655,6 +668,7 @@ dead_node_elimination(ir_graph *irg) {
 static void relink_bad_block_predecessors(ir_node *n, void *env) {
        ir_node **new_in, *irn;
        int i, new_irn_n, old_irn_arity, new_irn_arity = 0;
+       (void) env;
 
        /* if link field of block is NULL, look for bad predecessors otherwise
           this is already done */
@@ -775,6 +789,7 @@ typedef struct _survive_dce_list_t {
 
 static void dead_node_hook(void *context, ir_graph *irg, int start) {
        survive_dce_t *sd = context;
+       (void) irg;
 
        /* Create a new map before the dead node elimination is performed. */
        if (start) {
@@ -793,6 +808,7 @@ static void dead_node_hook(void *context, ir_graph *irg, int start) {
 static void dead_node_subst_hook(void *context, ir_graph *irg, ir_node *old, ir_node *nw) {
        survive_dce_t *sd = context;
        survive_dce_list_t *list = pmap_get(sd->places, old);
+       (void) irg;
 
        /* If the node is to be patched back, write the new address to all registered locations. */
        if (list) {
@@ -2124,10 +2140,10 @@ static void place_floats_late(ir_node *n, pdeq *worklist) {
                                ir_node *dca = get_deepest_common_ancestor(n, NULL);
                                if (dca != NULL) {
                                        set_nodes_block(n, dca);
+                                       move_out_of_loops(n, early_blk);
                                        if(get_irn_mode(n) == mode_T) {
-                                               set_projs_block(n, dca);
+                                               set_projs_block(n, get_nodes_block(n));
                                        }
-                                       move_out_of_loops(n, early_blk);
                                }
                        }
                }