Resolve constness warning.

[libfirm] / ir / lower / lower_hl.c

diff --git a/ir/lower/lower_hl.c b/ir/lower/lower_hl.c
index ca574e1..d767d17 100644 (file)
--- a/ir/lower/lower_hl.c
+++ b/ir/lower/lower_hl.c
@@ -21,7 +21,6 @@
  * @file
  * @brief   Lower some High-level constructs, moved from the firmlower.
  * @author  Boris Boesler, Goetz Lindenmaier, Michael Beck
- * @version $Id$
  */
 #include "config.h"
 
@@ -71,18 +70,18 @@ static void lower_sel(ir_node *sel)
 
                if (is_Array_type(owner)) {
                        ir_type *arr_ty = owner;
-                       int      dims   = get_array_n_dimensions(arr_ty);
-                       int     *map    = ALLOCAN(int, dims);
+                       size_t   dims   = get_array_n_dimensions(arr_ty);
+                       size_t  *map    = ALLOCAN(size_t, dims);
                        ir_mode *mode_Int = get_reference_mode_signed_eq(mode);
                        ir_tarval *tv;
                        ir_node *last_size;
-                       int      i;
+                       size_t   i;
 
-                       assert(dims == get_Sel_n_indexs(sel)
+                       assert(dims == (size_t)get_Sel_n_indexs(sel)
                                && "array dimension must match number of indices of Sel node");
 
                        for (i = 0; i < dims; i++) {
-                               int order = get_array_order(arr_ty, i);
+                               size_t order = get_array_order(arr_ty, i);
 
                                assert(order < dims &&
                                        "order of a dimension must be smaller than the arrays dim");
@@ -104,8 +103,8 @@ static void lower_sel(ir_node *sel)
                         * whereas u_i is the upper bound of the current dimension
                         * and l_i the lower bound of the current dimension.
                         */
-                       for (i = dims - 1; i >= 0; i--) {
-                               int dim = map[i];
+                       for (i = dims; i > 0;) {
+                               size_t dim = map[--i];
                                ir_node *lb, *ub, *elms, *n, *ind;
 
                                elms = NULL;
@@ -213,9 +212,6 @@ static void lower_symconst(ir_node *symc)
        ir_graph      *irg;
 
        switch (get_SymConst_kind(symc)) {
-       case symconst_type_tag:
-               assert(!"SymConst kind symconst_type_tag not implemented");
-               break;
        case symconst_type_size:
                /* rewrite the SymConst node by a Const node */
                irg  = get_irn_irg(symc);
@@ -272,7 +268,7 @@ static void lower_symconst(ir_node *symc)
                assert(!"unknown SymConst kind");
                break;
        }
-}  /* lower_symconst */
+}
 
 /**
  * Checks, whether a size is an integral size
@@ -286,7 +282,7 @@ static int is_integral_size(int size)
                return 0;
        /* must be at least byte size */
        return size >= 8;
-}  /* is_integral_size */
+}
 
 /**
  * lower bitfield load access.
@@ -297,7 +293,7 @@ static int is_integral_size(int size)
 static void lower_bitfields_loads(ir_node *proj, ir_node *load)
 {
        ir_node *sel = get_Load_ptr(load);
-       ir_node *block, *n_proj, *res, *ptr;
+       ir_node *block, *res, *ptr;
        ir_graph *irg;
        ir_entity *ent;
        ir_type *bf_type;
@@ -350,7 +346,7 @@ static void lower_bitfields_loads(ir_node *proj, ir_node *load)
        /* create new proj, switch off CSE or we may get the old one back */
        old_cse = get_opt_cse();
        set_opt_cse(0);
-       res = n_proj = new_r_Proj(load, mode, pn_Load_res);
+       res = new_r_Proj(load, mode, pn_Load_res);
        set_opt_cse(old_cse);
 
        if (mode_is_signed(mode)) { /* signed */
@@ -376,7 +372,7 @@ static void lower_bitfields_loads(ir_node *proj, ir_node *load)
        }
 
        exchange(proj, res);
-}  /* lower_bitfields_loads */
+}
 
 /**
  * lower bitfield store access.
@@ -460,7 +456,7 @@ static void lower_bitfields_stores(ir_node *store)
        set_Store_mem(store, mem);
        set_Store_value(store, value);
        set_Store_ptr(store, ptr);
-}  /* lower_bitfields_stores */
+}
 
 /**
  * lowers IR-nodes, called from walker
@@ -513,9 +509,9 @@ static void lower_bf_access(ir_node *irn, void *env)
  * Replace Sel nodes by address computation.  Also resolves array access.
  * Handle Bitfields by added And/Or calculations.
  */
-void lower_highlevel_graph(ir_graph *irg, int lower_bitfields)
+void lower_highlevel_graph(ir_graph *irg)
 {
-       if (lower_bitfields) {
+       if (is_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING)) {
                /* First step: lower bitfield access: must be run as long as Sels still
                 * exists. */
                irg_walk_graph(irg, NULL, lower_bf_access, NULL);
@@ -523,13 +519,10 @@ void lower_highlevel_graph(ir_graph *irg, int lower_bitfields)
 
        /* Finally: lower SymConst-Size and Sel nodes, Casts, unaligned Load/Stores. */
        irg_walk_graph(irg, NULL, lower_irnode, NULL);
-
-       set_irg_outs_inconsistent(irg);
 }
 
 typedef struct pass_t {
        ir_graph_pass_t pass;
-       int            lower_bitfields;
 } pass_t;
 
 /**
@@ -537,20 +530,19 @@ typedef struct pass_t {
  */
 static int lower_highlevel_graph_wrapper(ir_graph *irg, void *context)
 {
-       pass_t *pass = (pass_t*)context;
+       (void)context;
 
-       lower_highlevel_graph(irg, pass->lower_bitfields);
+       lower_highlevel_graph(irg);
        return 0;
-}  /* lower_highlevel_graph_wrapper */
+}
 
-ir_graph_pass_t *lower_highlevel_graph_pass(const char *name, int lower_bitfields)
+ir_graph_pass_t *lower_highlevel_graph_pass(const char *name)
 {
        pass_t *pass = XMALLOCZ(pass_t);
 
-       pass->lower_bitfields = lower_bitfields;
        return def_graph_pass_constructor(
                &pass->pass, name ? name : "lower_hl", lower_highlevel_graph_wrapper);
-}  /* lower_highlevel_graph_pass */
+}
 
 /*
  * does the same as lower_highlevel() for all nodes on the const code irg
@@ -558,7 +550,7 @@ ir_graph_pass_t *lower_highlevel_graph_pass(const char *name, int lower_bitfield
 void lower_const_code(void)
 {
        walk_const_code(NULL, lower_irnode, NULL);
-}  /* lower_const_code */
+}
 
 ir_prog_pass_t *lower_const_code_pass(const char *name)
 {
@@ -570,14 +562,14 @@ ir_prog_pass_t *lower_const_code_pass(const char *name)
  * Replace Sel nodes by address computation.  Also resolves array access.
  * Handle Bitfields by added And/Or calculations.
  */
-void lower_highlevel(int lower_bitfields)
+void lower_highlevel()
 {
        size_t i, n;
 
        n = get_irp_n_irgs();
        for (i = 0; i < n; ++i) {
                ir_graph *irg = get_irp_irg(i);
-               lower_highlevel_graph(irg, lower_bitfields);
+               lower_highlevel_graph(irg);
        }
        lower_const_code();
-}  /* lower_highlevel */
+}