fixed some warnings

[libfirm] / ir / ir / irarch.c

diff --git a/ir/ir/irarch.c b/ir/ir/irarch.c
index 4684d50..e6d3aba 100644 (file)
--- a/ir/ir/irarch.c
+++ b/ir/ir/irarch.c
@@ -51,6 +51,7 @@
 #include "irhooks.h"
 #include "ircons.h"
 #include "irarch.h"
+#include "irflag.h"
 
 #undef DEB
 
@@ -107,6 +108,9 @@ void arch_dep_init(arch_dep_params_factory_t factory) {
 
 void arch_dep_set_opts(arch_dep_opts_t the_opts) {
        opts = the_opts;
+
+       if (opts & arch_dep_mul_to_shift)
+               set_opt_arch_dep_running(1);
 }
 
 /** check, whether a mode allows a Mulh instruction. */
@@ -123,7 +127,7 @@ typedef struct instruction instruction;
 struct instruction {
        insn_kind   kind;        /**< the instruction kind */
        instruction *in[2];      /**< the ins */
-       int         shift_count; /**< shift count for LEA and SHIFT */
+       unsigned    shift_count; /**< shift count for LEA and SHIFT */
        ir_node     *irn;        /**< the generated node for this instruction if any. */
        int         costs;       /**< the costs for this instruction */
 };
@@ -134,7 +138,7 @@ struct instruction {
 typedef struct _mul_env {
        struct obstack obst;       /**< an obstack for local space. */
        ir_mode        *mode;      /**< the mode of the multiplication constant */
-       int            bits;       /**< number of bits in the mode */
+       unsigned       bits;       /**< number of bits in the mode */
        unsigned       max_S;      /**< the maximum LEA shift value. */
        instruction    *root;      /**< the root of the instruction tree */
        ir_node        *op;        /**< the operand that is multiplied */
@@ -148,9 +152,12 @@ typedef struct _mul_env {
 } mul_env;
 
 /**
- * Some kind of default evaluator.
+ * Some kind of default evaluator. Return the cost of
+ * instructions.
  */
 static int default_evaluate(insn_kind kind, tarval *tv) {
+       (void) tv;
+
        if (kind == MUL)
                return 13;
        return 1;
@@ -159,7 +166,7 @@ static int default_evaluate(insn_kind kind, tarval *tv) {
 /**
  * emit a LEA (or an Add) instruction
  */
-static instruction *emit_LEA(mul_env *env, instruction *a, instruction *b, int shift) {
+static instruction *emit_LEA(mul_env *env, instruction *a, instruction *b, unsigned shift) {
        instruction *res = obstack_alloc(&env->obst, sizeof(*res));
        res->kind = shift > 0 ? LEA : ADD;
        res->in[0] = a;
@@ -171,11 +178,17 @@ static instruction *emit_LEA(mul_env *env, instruction *a, instruction *b, int s
 }
 
 /**
- * emit a SHIFT (or an Add) instruction
+ * emit a SHIFT (or an Add or a Zero) instruction
  */
-static instruction *emit_SHIFT(mul_env *env, instruction *a, int shift) {
+static instruction *emit_SHIFT(mul_env *env, instruction *a, unsigned shift) {
        instruction *res = obstack_alloc(&env->obst, sizeof(*res));
-       if (shift != 1) {
+       if (shift == env->bits) {
+               /* a 2^bits with bits resolution is a zero */
+               res->kind = ZERO;
+               res->in[0] = NULL;
+               res->in[1] = NULL;
+               res->shift_count = 0;
+       } else if (shift != 1) {
                res->kind = SHIFT;
                res->in[0] = a;
                res->in[1] = NULL;
@@ -338,6 +351,7 @@ static instruction *basic_decompose_mul(mul_env *env, unsigned char *R, int r, t
 static instruction *decompose_simple_cases(mul_env *env, unsigned char *R, int r, tarval *N) {
        instruction *ins, *ins2;
 
+       (void) N;
        if (r == 1) {
                return emit_SHIFT(env, env->root, R[0]);
        } else {
@@ -370,7 +384,7 @@ static instruction *decompose_mul(mul_env *env, unsigned char *R, int r, tarval
                if (gain > 0) {
                        instruction *instr1, *instr2;
                        unsigned char *R1, *R2;
-                       int r1, r2, i, k;
+                       int r1, r2, i, k, j;
 
                        R1 = complement_condensed(env, R, r, gain, &r1);
                        r2 = r - gain + 1;
@@ -382,8 +396,15 @@ static instruction *decompose_mul(mul_env *env, unsigned char *R, int r, tarval
                        }
                        R2[0] = k;
                        R2[1] = R[gain] - 1;
-                       for (i = gain; i < r; ++i) {
-                               R2[i] = R[i];
+                       j = 2;
+                       if (R2[1] == 0) {
+                               /* Two identical bits: normalize */
+                               ++R2[0];
+                               --j;
+                               --r2;
+                       }
+                       for (i = gain + 1; i < r; ++i) {
+                               R2[j++] = R[i];
                        }
 
                        instr1 = decompose_mul(env, R1, r1, NULL);
@@ -414,6 +435,8 @@ static instruction *decompose_mul(mul_env *env, unsigned char *R, int r, tarval
        return basic_decompose_mul(env, R, r, N);
 }
 
+#define IMAX(a,b) ((a) > (b) ? (a) : (b))
+
 /**
  * basic decomposition routine
  */
@@ -422,7 +445,7 @@ static instruction *basic_decompose_mul(mul_env *env, unsigned char *R, int r, t
        unsigned t;
 
        if (R[0] == 0) {                                        /* Case 1 */
-               t = R[1] > max(env->max_S, R[1]);
+               t = R[1] > IMAX(env->max_S, R[1]);
                R[1] -= t;
                Ns = decompose_mul(env, &R[1], r - 1, N);
                return emit_LEA(env, env->root, Ns, t);
@@ -470,6 +493,8 @@ static ir_node *build_graph(mul_env *env, instruction *inst) {
                l = build_graph(env, inst->in[0]);
                r = build_graph(env, inst->in[1]);
                return inst->irn = new_rd_Add(env->dbg, current_ir_graph, env->blk, l, r, env->mode);
+       case ZERO:
+               return inst->irn = new_r_Const(current_ir_graph, env->blk, env->mode, get_mode_null(env->mode));
        default:
                assert(0);
                return NULL;
@@ -508,6 +533,9 @@ static int evaluate_insn(mul_env *env, instruction *inst) {
                costs += env->evaluate(inst->kind, NULL);
                inst->costs = costs;
                return costs;
+       case ZERO:
+               inst->costs = costs = env->evaluate(inst->kind, NULL);
+               return costs;
        default:
                assert(0);
                return 0;
@@ -535,7 +563,7 @@ static ir_node *do_decomposition(ir_node *irn, ir_node *operand, tarval *tv) {
 
        obstack_init(&env.obst);
        env.mode     = get_tarval_mode(tv);
-       env.bits     = get_mode_size_bits(env.mode);
+       env.bits     = (unsigned)get_mode_size_bits(env.mode);
        env.max_S    = 3;
        env.root     = emit_ROOT(&env, operand);
        env.fail     = 0;
@@ -572,7 +600,6 @@ ir_node *arch_dep_replace_mul_with_shifts(ir_node *irn) {
                return irn;
 
        if (is_Mul(irn) && mode_is_int(mode)) {
-               ir_node *block   = get_nodes_block(irn);
                ir_node *left    = get_binop_left(irn);
                ir_node *right   = get_binop_right(irn);
                tarval *tv       = NULL;
@@ -1172,6 +1199,7 @@ static const ir_settings_arch_dep_t default_params = {
        1,  /* also use subs */
        4,  /* maximum shifts */
        31, /* maximum shift amount */
+       default_evaluate,  /* default evaluator */
 
        0,  /* allow Mulhs */
        0,  /* allow Mulus */