From 41c64ac01272bd3fca0486e618bd1d1ea14a76bd Mon Sep 17 00:00:00 2001 From: Roger Sayle Date: Fri, 11 Jun 2004 21:34:23 +0000 Subject: [PATCH] expmed.c (synth_mult): Add an additional MODE argument for the machine mode of the multiplication. * expmed.c (synth_mult): Add an additional MODE argument for the machine mode of the multiplication. Update recursive calls. Use mode instead of word_mode for determining operation costs. (choose_mult_variant): Update calls to synth_mult with "mode". From-SVN: r83002 --- gcc/ChangeLog | 7 +++++++ gcc/expmed.c | 40 +++++++++++++++++++++------------------- 2 files changed, 28 insertions(+), 19 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 2490b8cac54..6533e7d6934 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2004-06-11 Roger Sayle + + * expmed.c (synth_mult): Add an additional MODE argument for the + machine mode of the multiplication. Update recursive calls. Use + mode instead of word_mode for determining operation costs. + (choose_mult_variant): Update calls to synth_mult with "mode". + 2004-06-11 Richard Henderson * tree-ssa-operands.c (get_stmt_operands): Clear makes_aliased_loads diff --git a/gcc/expmed.c b/gcc/expmed.c index 96ef1e7d2e5..00df7ce0c7b 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -2153,7 +2153,8 @@ struct algorithm multiplicand should be added to the result. */ enum mult_variant {basic_variant, negate_variant, add_variant}; -static void synth_mult (struct algorithm *, unsigned HOST_WIDE_INT, int); +static void synth_mult (struct algorithm *, unsigned HOST_WIDE_INT, + int, enum machine_mode mode); static bool choose_mult_variant (enum machine_mode, HOST_WIDE_INT, struct algorithm *, enum mult_variant *, int); static rtx expand_mult_const (enum machine_mode, rtx, HOST_WIDE_INT, rtx, @@ -2168,11 +2169,12 @@ static rtx expand_mult_highpart_optab (enum machine_mode, rtx, rtx, rtx, /* Compute and return the best algorithm for multiplying by T. The algorithm must cost less than cost_limit If retval.cost >= COST_LIMIT, no algorithm was found and all - other field of the returned struct are undefined. */ + other field of the returned struct are undefined. + MODE is the machine mode of the multiplication. */ static void synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, - int cost_limit) + int cost_limit, enum machine_mode mode) { int m; struct algorithm *alg_in, *best_alg; @@ -2225,7 +2227,7 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, { q = t >> m; cost = shift_cost[m]; - synth_mult (alg_in, q, cost_limit - cost); + synth_mult (alg_in, q, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2259,8 +2261,8 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, { /* T ends with ...111. Multiply by (T + 1) and subtract 1. */ - cost = add_cost[word_mode]; - synth_mult (alg_in, t + 1, cost_limit - cost); + cost = add_cost[mode]; + synth_mult (alg_in, t + 1, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2276,8 +2278,8 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, { /* T ends with ...01 or ...011. Multiply by (T - 1) and add 1. */ - cost = add_cost[word_mode]; - synth_mult (alg_in, t - 1, cost_limit - cost); + cost = add_cost[mode]; + synth_mult (alg_in, t - 1, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2308,10 +2310,10 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, d = ((unsigned HOST_WIDE_INT) 1 << m) + 1; if (t % d == 0 && t > d && m < BITS_PER_WORD) { - cost = add_cost[word_mode] + shift_cost[m]; + cost = add_cost[mode] + shift_cost[m]; if (shiftadd_cost[m] < cost) cost = shiftadd_cost[m]; - synth_mult (alg_in, t / d, cost_limit - cost); + synth_mult (alg_in, t / d, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2329,10 +2331,10 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, d = ((unsigned HOST_WIDE_INT) 1 << m) - 1; if (t % d == 0 && t > d && m < BITS_PER_WORD) { - cost = add_cost[word_mode] + shift_cost[m]; + cost = add_cost[mode] + shift_cost[m]; if (shiftsub_cost[m] < cost) cost = shiftsub_cost[m]; - synth_mult (alg_in, t / d, cost_limit - cost); + synth_mult (alg_in, t / d, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2357,7 +2359,7 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, if (m >= 0 && m < BITS_PER_WORD) { cost = shiftadd_cost[m]; - synth_mult (alg_in, (t - 1) >> m, cost_limit - cost); + synth_mult (alg_in, (t - 1) >> m, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2376,7 +2378,7 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t, if (m >= 0 && m < BITS_PER_WORD) { cost = shiftsub_cost[m]; - synth_mult (alg_in, (t + 1) >> m, cost_limit - cost); + synth_mult (alg_in, (t + 1) >> m, cost_limit - cost, mode); cost += alg_in->cost; if (cost < cost_limit) @@ -2429,22 +2431,22 @@ choose_mult_variant (enum machine_mode mode, HOST_WIDE_INT val, struct algorithm alg2; *variant = basic_variant; - synth_mult (alg, val, mult_cost); + synth_mult (alg, val, mult_cost, mode); /* This works only if the inverted value actually fits in an `unsigned int' */ if (HOST_BITS_PER_INT >= GET_MODE_BITSIZE (mode)) { - synth_mult (&alg2, -val, MIN (alg->cost, mult_cost) - - neg_cost[mode]); + synth_mult (&alg2, -val, MIN (alg->cost, mult_cost) - neg_cost[mode], + mode); alg2.cost += neg_cost[mode]; if (alg2.cost < alg->cost) *alg = alg2, *variant = negate_variant; } /* This proves very useful for division-by-constant. */ - synth_mult (&alg2, val - 1, MIN (alg->cost, mult_cost) - - add_cost[mode]); + synth_mult (&alg2, val - 1, MIN (alg->cost, mult_cost) - add_cost[mode], + mode); alg2.cost += add_cost[mode]; if (alg2.cost < alg->cost) *alg = alg2, *variant = add_variant; -- 2.30.2