Treat the lower word of lowered 64bit operations always as unsigned. Using the same...

[libfirm] / ir / lower / lower_dw.c

diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c
index 25d9d68..0404cfd 100644 (file)
--- a/ir/lower/lower_dw.c
+++ b/ir/lower/lower_dw.c
@@ -171,7 +171,7 @@ static ir_type *get_conv_type(ir_mode *imode, ir_mode *omode, lower_env_t *env)
                /* set param types and result types */
                n_param = 0;
                if (imode == env->params->high_signed) {
-                       set_method_param_type(mtd, n_param++, tp_s);
+                       set_method_param_type(mtd, n_param++, tp_u);
                        set_method_param_type(mtd, n_param++, tp_s);
                } else if (imode == env->params->high_unsigned) {
                        set_method_param_type(mtd, n_param++, tp_u);
@@ -183,7 +183,7 @@ static ir_type *get_conv_type(ir_mode *imode, ir_mode *omode, lower_env_t *env)
 
                n_res = 0;
                if (omode == env->params->high_signed) {
-                       set_method_res_type(mtd, n_res++, tp_s);
+                       set_method_res_type(mtd, n_res++, tp_u);
                        set_method_res_type(mtd, n_res++, tp_s);
                } else if (omode == env->params->high_unsigned) {
                        set_method_res_type(mtd, n_res++, tp_u);
@@ -335,11 +335,12 @@ static void lower_Const(ir_node *node, ir_mode *mode, lower_env_t *env) {
        ir_node  *block = get_nodes_block(node);
        int      idx;
        ir_graph *irg = current_ir_graph;
+       ir_mode  *low_mode = env->params->low_unsigned;
 
        tv   = get_Const_tarval(node);
 
-       tv_l = tarval_convert_to(tv, mode);
-       low  = new_rd_Const(dbg, irg, block, mode, tv_l);
+       tv_l = tarval_convert_to(tv, low_mode);
+       low  = new_rd_Const(dbg, irg, block, low_mode, tv_l);
 
        tv_h = tarval_convert_to(tarval_shrs(tv, env->tv_mode_bits), mode);
        high = new_rd_Const(dbg, irg, block, mode, tv_h);
@@ -424,6 +425,8 @@ static void lower_Store(ir_node *node, ir_mode *mode, lower_env_t *env) {
        dbg_info *dbg;
        int      idx;
        node_entry_t *entry;
+       (void) node;
+       (void) mode;
 
        irn = get_Store_value(node);
        entry = env->entries[get_irn_idx(irn)];
@@ -592,8 +595,8 @@ static void lower_Div(ir_node *node, ir_mode *mode, lower_env_t *env) {
                case pn_Div_res:       /* Result of computation. */
                        idx = get_irn_idx(proj);
                        assert(idx < env->n_entries);
-                       env->entries[idx]->low_word  = new_r_Proj(current_ir_graph, block, irn, mode, 0);
-                       env->entries[idx]->high_word = new_r_Proj(current_ir_graph, block, irn, mode, 1);
+                       env->entries[idx]->low_word  = new_r_Proj(current_ir_graph, block, irn, env->params->low_unsigned, 0);
+                       env->entries[idx]->high_word = new_r_Proj(current_ir_graph, block, irn, mode,                      1);
                        break;
                default:
                        assert(0 && "unexpected Proj number");
@@ -672,8 +675,8 @@ static void lower_Mod(ir_node *node, ir_mode *mode, lower_env_t *env) {
                case pn_Mod_res:       /* Result of computation. */
                        idx = get_irn_idx(proj);
                        assert(idx < env->n_entries);
-                       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-                       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+                       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+                       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
                        break;
                default:
                        assert(0 && "unexpected Proj number");
@@ -779,13 +782,13 @@ static void lower_DivMod(ir_node *node, ir_mode *mode, lower_env_t *env) {
                case pn_DivMod_res_div:   /* Result of Div. */
                        idx = get_irn_idx(proj);
                        assert(idx < env->n_entries);
-                       env->entries[idx]->low_word  = new_r_Proj(irg, block, resDiv, mode, 0);
-                       env->entries[idx]->high_word = new_r_Proj(irg, block, resDiv, mode, 1);
+                       env->entries[idx]->low_word  = new_r_Proj(irg, block, resDiv, env->params->low_unsigned, 0);
+                       env->entries[idx]->high_word = new_r_Proj(irg, block, resDiv, mode,                      1);
                        break;
                case pn_DivMod_res_mod:   /* Result of Mod. */
                        idx = get_irn_idx(proj);
-                       env->entries[idx]->low_word  = new_r_Proj(irg, block, resMod, mode, 0);
-                       env->entries[idx]->high_word = new_r_Proj(irg, block, resMod, mode, 1);
+                       env->entries[idx]->low_word  = new_r_Proj(irg, block, resMod, env->params->low_unsigned, 0);
+                       env->entries[idx]->high_word = new_r_Proj(irg, block, resMod, mode,                      1);
                        break;
                default:
                        assert(0 && "unexpected Proj number");
@@ -849,8 +852,8 @@ static void lower_Binop(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
        idx = get_irn_idx(node);
        assert(idx < env->n_entries);
-       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 }  /* lower_Binop */
 
 /**
@@ -896,8 +899,8 @@ static void lower_Shiftop(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
        idx = get_irn_idx(node);
        assert(idx < env->n_entries);
-       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 }  /* lower_Shiftop */
 
 /**
@@ -1074,8 +1077,8 @@ static void lower_Unop(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
        idx = get_irn_idx(node);
        assert(idx < env->n_entries);
-       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+       env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+       env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 }  /* lower_Unop */
 
 /**
@@ -1174,42 +1177,6 @@ static void lower_Not(ir_node *node, ir_mode *mode, lower_env_t *env) {
        env->entries[idx]->high_word = new_rd_Not(dbg, current_ir_graph, block, op_h, mode);
 }  /* lower_Not */
 
-/**
- * Translate a Minus.
- *
- * Create two Minus'.
- */
-static void lower_Minus(ir_node *node, ir_mode *mode, lower_env_t *env) {
-       ir_node  *block, *irn;
-       ir_node  *op_l, *op_h;
-       dbg_info *dbg;
-       int      idx;
-       ir_graph *irg;
-       node_entry_t *entry;
-
-       irn   = get_Minus_op(node);
-       entry = env->entries[get_irn_idx(irn)];
-       assert(entry);
-
-       if (! entry->low_word) {
-               /* not ready yet, wait */
-               pdeq_putr(env->waitq, node);
-               return;
-       }  /* if */
-
-       op_l = entry->low_word;
-       op_h = entry->high_word;
-
-       dbg   = get_irn_dbg_info(node);
-       block = get_nodes_block(node);
-       irg   = current_ir_graph;
-
-       idx = get_irn_idx(node);
-       assert(idx < env->n_entries);
-       env->entries[idx]->low_word  = new_rd_Minus(dbg, current_ir_graph, block, op_l, mode);
-       env->entries[idx]->high_word = new_rd_Minus(dbg, current_ir_graph, block, op_h, mode);
-}  /* lower_Minus */
-
 /**
  * Translate a Cond.
  */
@@ -1218,6 +1185,7 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) {
        ir_node *sel = get_Cond_selector(node);
        ir_mode *m = get_irn_mode(sel);
        int     idx;
+       (void) mode;
 
        if (m == mode_b) {
                node_entry_t *lentry, *rentry;
@@ -1229,7 +1197,13 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) {
                pn_Cmp   pnc;
                dbg_info *dbg;
 
+               if(!is_Proj(sel))
+                       return;
+
                cmp   = get_Proj_pred(sel);
+               if(!is_Cmp(cmp))
+                       return;
+
                left  = get_Cmp_left(cmp);
                idx   = get_irn_idx(left);
                lentry = env->entries[idx];
@@ -1424,7 +1398,8 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) {
 static void lower_Conv_to_Ls(ir_node *node, lower_env_t *env) {
        ir_node  *op    = get_Conv_op(node);
        ir_mode  *imode = get_irn_mode(op);
-       ir_mode  *dst_mode = env->params->low_signed;
+       ir_mode  *dst_mode_l = env->params->low_unsigned;
+       ir_mode  *dst_mode_h = env->params->low_signed;
        int      idx = get_irn_idx(node);
        ir_graph *irg = current_ir_graph;
        ir_node  *block = get_nodes_block(node);
@@ -1442,16 +1417,21 @@ static void lower_Conv_to_Ls(ir_node *node, lower_env_t *env) {
                                pdeq_putr(env->waitq, node);
                                return;
                        }  /* if */
-                       env->entries[idx]->low_word  = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->low_word, dst_mode);
-                       env->entries[idx]->high_word = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->high_word, dst_mode);
+                       env->entries[idx]->low_word  = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->low_word,  dst_mode_l);
+                       env->entries[idx]->high_word = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->high_word, dst_mode_h);
                } else {
                        /* simple case: create a high word */
-                       if (imode != dst_mode)
-                               op = new_rd_Conv(dbg, irg, block, op, dst_mode);
+                       if (imode != dst_mode_l)
+                               op = new_rd_Conv(dbg, irg, block, op, dst_mode_l);
 
                        env->entries[idx]->low_word  = op;
-                       env->entries[idx]->high_word = new_rd_Shrs(dbg, irg, block, op,
-                               new_Const_long(mode_Iu, get_mode_size_bits(dst_mode) - 1), dst_mode);
+
+                       if (mode_is_signed(imode)) {
+                               env->entries[idx]->high_word = new_rd_Shrs(dbg, irg, block, op,
+                                       new_Const_long(mode_Iu, get_mode_size_bits(dst_mode_h) - 1), dst_mode_h);
+                       } else {
+                               env->entries[idx]->high_word = new_Const(dst_mode_h, get_mode_null(dst_mode_h));
+                       }  /* if */
                }  /* if */
        } else {
                ir_node *irn, *call;
@@ -1463,8 +1443,8 @@ static void lower_Conv_to_Ls(ir_node *node, lower_env_t *env) {
                set_irn_pinned(call, get_irn_pinned(node));
                irn = new_r_Proj(irg, block, call, mode_T, pn_Call_T_result);
 
-               env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, dst_mode, 0);
-               env->entries[idx]->high_word = new_r_Proj(irg, block, irn, dst_mode, 1);
+               env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, dst_mode_l, 0);
+               env->entries[idx]->high_word = new_r_Proj(irg, block, irn, dst_mode_h, 1);
        }  /* if */
 }  /* lower_Conv_to_Ls */
 
@@ -1500,7 +1480,13 @@ static void lower_Conv_to_Lu(ir_node *node, lower_env_t *env) {
                                op = new_rd_Conv(dbg, irg, block, op, dst_mode);
 
                        env->entries[idx]->low_word  = op;
-                       env->entries[idx]->high_word = new_Const(dst_mode, get_mode_null(dst_mode));
+
+                       if (mode_is_signed(imode)) {
+                               env->entries[idx]->high_word = new_rd_Shrs(dbg, irg, block, op,
+                                       new_Const_long(mode_Iu, get_mode_size_bits(dst_mode) - 1), dst_mode);
+                       } else {
+                               env->entries[idx]->high_word = new_Const(dst_mode, get_mode_null(dst_mode));
+                       }  /* if */
                }  /* if */
        } else {
                ir_node *irn, *call;
@@ -1681,7 +1667,7 @@ static ir_type *lower_mtp(ir_type *mtp, lower_env_t *env) {
                                ir_mode *mode = get_type_mode(tp);
 
                                if (mode == env->params->high_signed) {
-                                       set_method_param_type(res, n_param++, tp_s);
+                                       set_method_param_type(res, n_param++, tp_u);
                                        set_method_param_type(res, n_param++, tp_s);
                                } else if (mode == env->params->high_unsigned) {
                                        set_method_param_type(res, n_param++, tp_u);
@@ -1700,7 +1686,7 @@ static ir_type *lower_mtp(ir_type *mtp, lower_env_t *env) {
                                ir_mode *mode = get_type_mode(tp);
 
                                if (mode == env->params->high_signed) {
-                                       set_method_res_type(res, n_res++, tp_s);
+                                       set_method_res_type(res, n_res++, tp_u);
                                        set_method_res_type(res, n_res++, tp_s);
                                } else if (mode == env->params->high_unsigned) {
                                        set_method_res_type(res, n_res++, tp_u);
@@ -1730,6 +1716,7 @@ static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env) {
        ir_node   **in;
        int       i, j, n, idx;
        int       need_conv = 0;
+       (void) mode;
 
        /* check if this return must be lowered */
        for (i = 0, n = get_Return_n_ress(node); i < n; ++i) {
@@ -1788,6 +1775,7 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
        long      *new_projs;
        int       i, j, n_params, rem;
        ir_node   *proj, *args;
+       (void) mode;
 
        if (is_lowered_type(tp)) {
                mtp = get_associated_type(tp);
@@ -1846,6 +1834,8 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
                idx = get_irn_idx(proj);
                if (env->entries[idx]) {
+                       ir_mode *low_mode = env->params->low_unsigned;
+
                        mode = get_irn_mode(proj);
 
                        if (mode == env->params->high_signed) {
@@ -1856,7 +1846,7 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
                        dbg = get_irn_dbg_info(proj);
                        env->entries[idx]->low_word  =
-                               new_rd_Proj(dbg, irg, get_nodes_block(proj), args, mode, new_projs[proj_nr]);
+                               new_rd_Proj(dbg, irg, get_nodes_block(proj), args, low_mode, new_projs[proj_nr]);
                        env->entries[idx]->high_word =
                                new_rd_Proj(dbg, irg, get_nodes_block(proj), args, mode, new_projs[proj_nr] + 1);
                }  /* if */
@@ -1875,6 +1865,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
        int      n_params, n_res, need_lower = 0;
        int      i, j;
        long     *res_numbers = NULL;
+       (void) mode;
 
        if (is_lowered_type(tp)) {
                call_tp = get_associated_type(tp);
@@ -1977,6 +1968,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
                                idx = get_irn_idx(proj);
                                if (env->entries[idx]) {
                                        ir_mode *mode = get_irn_mode(proj);
+                                       ir_mode *low_mode = env->params->low_unsigned;
                                        dbg_info *dbg;
 
                                        if (mode == env->params->high_signed) {
@@ -1987,7 +1979,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
                                        dbg = get_irn_dbg_info(proj);
                                        env->entries[idx]->low_word  =
-                                               new_rd_Proj(dbg, irg, get_nodes_block(proj), results, mode, res_numbers[proj_nr]);
+                                               new_rd_Proj(dbg, irg, get_nodes_block(proj), results, low_mode, res_numbers[proj_nr]);
                                        env->entries[idx]->high_word =
                                                new_rd_Proj(dbg, irg, get_nodes_block(proj), results, mode, res_numbers[proj_nr] + 1);
                                }  /* if */
@@ -2015,8 +2007,11 @@ static void lower_Unknown(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * First step: just create two templates
  */
 static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
+       ir_mode  *mode_l = env->params->low_unsigned;
        ir_graph *irg = current_ir_graph;
-       ir_node  *block, *unk;
+       ir_node  *block;
+       ir_node  *unk_l;
+       ir_node  *unk_h;
        ir_node  **inl, **inh;
        dbg_info *dbg;
        int      idx, i, arity = get_Phi_n_preds(phi);
@@ -2046,7 +2041,8 @@ static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
        /* first create a new in array */
        NEW_ARR_A(ir_node *, inl, arity);
        NEW_ARR_A(ir_node *, inh, arity);
-       unk = new_r_Unknown(irg, mode);
+       unk_l = new_r_Unknown(irg, mode_l);
+       unk_h = new_r_Unknown(irg, mode);
 
        for (i = 0; i < arity; ++i) {
                ir_node *pred = get_Phi_pred(phi, i);
@@ -2056,8 +2052,8 @@ static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
                        inl[i] = env->entries[idx]->low_word;
                        inh[i] = env->entries[idx]->high_word;
                } else {
-                       inl[i] = unk;
-                       inh[i] = unk;
+                       inl[i] = unk_l;
+                       inh[i] = unk_h;
                        enq = 1;
                }  /* if */
        }  /* for */
@@ -2067,7 +2063,7 @@ static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
 
        idx = get_irn_idx(phi);
        assert(idx < env->n_entries);
-       env->entries[idx]->low_word  = new_rd_Phi(dbg, irg, block, arity, inl, mode);
+       env->entries[idx]->low_word  = new_rd_Phi(dbg, irg, block, arity, inl, mode_l);
        env->entries[idx]->high_word = new_rd_Phi(dbg, irg, block, arity, inh, mode);
 
        if (enq) {
@@ -2267,6 +2263,13 @@ static void lower_ops(ir_node *node, void *env)
 
                        DB((dbg, LEVEL_1, "  %+F\n", node));
                        func(node, mode, lenv);
+                       if (entry) {
+                               ir_node *low_node = entry->low_word;
+                               if (low_node && mode_is_signed(get_irn_mode(low_node))) {
+                                       ir_fprintf(stderr, "WARNING: lower mode of %+F of lowered %+F is signed\n",
+                                             low_node, node);
+                               }
+                       }
                }  /* if */
        }  /* if */
 }  /* lower_ops */
@@ -2279,6 +2282,7 @@ static void lower_ops(ir_node *node, void *env)
 static int cmp_op_mode(const void *elt, const void *key, size_t size) {
        const op_mode_entry_t *e1 = elt;
        const op_mode_entry_t *e2 = key;
+       (void) size;
 
        return (e1->op - e2->op) | (e1->imode - e2->imode) | (e1->omode - e2->omode);
 }  /* cmp_op_mode */
@@ -2289,6 +2293,7 @@ static int cmp_op_mode(const void *elt, const void *key, size_t size) {
 static int cmp_conv_tp(const void *elt, const void *key, size_t size) {
        const conv_tp_entry_t *e1 = elt;
        const conv_tp_entry_t *e2 = key;
+       (void) size;
 
        return (e1->imode - e2->imode) | (e1->omode - e2->omode);
 }  /* static int cmp_conv_tp */
@@ -2342,11 +2347,11 @@ void lower_dw_ops(const lwrdw_param_t *param)
        }  /* if */
        if (! binop_tp_s) {
                binop_tp_s = new_type_method(IDENT("binop_s_intrinsic"), 4, 2);
-               set_method_param_type(binop_tp_s, 0, tp_s);
+               set_method_param_type(binop_tp_s, 0, tp_u);
                set_method_param_type(binop_tp_s, 1, tp_s);
-               set_method_param_type(binop_tp_s, 2, tp_s);
+               set_method_param_type(binop_tp_s, 2, tp_u);
                set_method_param_type(binop_tp_s, 3, tp_s);
-               set_method_res_type(binop_tp_s, 0, tp_s);
+               set_method_res_type(binop_tp_s, 0, tp_u);
                set_method_res_type(binop_tp_s, 1, tp_s);
        }  /* if */
        if (! shiftop_tp_u) {
@@ -2359,11 +2364,11 @@ void lower_dw_ops(const lwrdw_param_t *param)
        }  /* if */
        if (! shiftop_tp_s) {
                shiftop_tp_s = new_type_method(IDENT("shiftop_s_intrinsic"), 3, 2);
-               set_method_param_type(shiftop_tp_s, 0, tp_s);
+               set_method_param_type(shiftop_tp_s, 0, tp_u);
                set_method_param_type(shiftop_tp_s, 1, tp_s);
                /* beware: shift count is always mode_Iu */
                set_method_param_type(shiftop_tp_s, 2, tp_u);
-               set_method_res_type(shiftop_tp_s, 0, tp_s);
+               set_method_res_type(shiftop_tp_s, 0, tp_u);
                set_method_res_type(shiftop_tp_s, 1, tp_s);
        }  /* if */
        if (! unop_tp_u) {
@@ -2375,9 +2380,9 @@ void lower_dw_ops(const lwrdw_param_t *param)
        }  /* if */
        if (! unop_tp_s) {
                unop_tp_s = new_type_method(IDENT("unop_s_intrinsic"), 2, 2);
-               set_method_param_type(unop_tp_s, 0, tp_s);
+               set_method_param_type(unop_tp_s, 0, tp_u);
                set_method_param_type(unop_tp_s, 1, tp_s);
-               set_method_res_type(unop_tp_s, 0, tp_s);
+               set_method_res_type(unop_tp_s, 0, tp_u);
                set_method_res_type(unop_tp_s, 1, tp_s);
        }  /* if */
 
@@ -2417,11 +2422,11 @@ void lower_dw_ops(const lwrdw_param_t *param)
        LOWER(Shr);
        LOWER(Shrs);
        LOWER(Rot);
-       LOWER(Minus);
        LOWER(DivMod);
        LOWER(Div);
        LOWER(Mod);
        LOWER_UN(Abs);
+       LOWER_UN(Minus);
 
        LOWER(Conv);
 
@@ -2489,6 +2494,7 @@ ir_entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
        char buf[64];
        ident *id;
        ir_entity *ent;
+       (void) context;
 
        if (imode == omode) {
                snprintf(buf, sizeof(buf), "__l%s%s", get_op_name(op), get_mode_name(imode));