Subversion Repositories openrisc

/* Reassociation for trees.

   Copyright (C) 2005, 2007 Free Software Foundation, Inc.

   Contributed by Daniel Berlin <dan@dberlin.org>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3, or (at your option)

any later version.

GCC is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "errors.h"

#include "ggc.h"

#include "tree.h"

#include "basic-block.h"

#include "diagnostic.h"

#include "tree-inline.h"

#include "tree-flow.h"

#include "tree-gimple.h"

#include "tree-dump.h"

#include "timevar.h"

#include "tree-iterator.h"

#include "tree-pass.h"

#include "alloc-pool.h"

#include "vec.h"

#include "langhooks.h"

/*  This is a simple global reassociation pass.  It is, in part, based

    on the LLVM pass of the same name (They do some things more/less

    than we do, in different orders, etc).

    It consists of five steps:

    1. Breaking up subtract operations into addition + negate, where

    it would promote the reassociation of adds.

    2. Left linearization of the expression trees, so that (A+B)+(C+D)

    becomes (((A+B)+C)+D), which is easier for us to rewrite later.

    During linearization, we place the operands of the binary

    expressions into a vector of operand_entry_t

    3. Optimization of the operand lists, eliminating things like a +

    -a, a & a, etc.

    4. Rewrite the expression trees we linearized and optimized so

    they are in proper rank order.

    5. Repropagate negates, as nothing else will clean it up ATM.

    A bit of theory on #4, since nobody seems to write anything down

    about why it makes sense to do it the way they do it:

    We could do this much nicer theoretically, but don't (for reasons

    explained after how to do it theoretically nice :P).

    In order to promote the most redundancy elimination, you want

    binary expressions whose operands are the same rank (or

    preferably, the same value) exposed to the redundancy eliminator,

    for possible elimination.

    So the way to do this if we really cared, is to build the new op

    tree from the leaves to the roots, merging as you go, and putting the

    new op on the end of the worklist, until you are left with one

    thing on the worklist.

    IE if you have to rewrite the following set of operands (listed with

    rank in parentheses), with opcode PLUS_EXPR:

    a (1),  b (1),  c (1),  d (2), e (2)

    We start with our merge worklist empty, and the ops list with all of

    those on it.

    You want to first merge all leaves of the same rank, as much as

    possible.

    So first build a binary op of

    mergetmp = a + b, and put "mergetmp" on the merge worklist.

    Because there is no three operand form of PLUS_EXPR, c is not going to

    be exposed to redundancy elimination as a rank 1 operand.

    So you might as well throw it on the merge worklist (you could also

    consider it to now be a rank two operand, and merge it with d and e,

    but in this case, you then have evicted e from a binary op. So at

    least in this situation, you can't win.)

    Then build a binary op of d + e

    mergetmp2 = d + e

    and put mergetmp2 on the merge worklist.

    so merge worklist = {mergetmp, c, mergetmp2}

    Continue building binary ops of these operations until you have only

    one operation left on the worklist.

    So we have

    build binary op

    mergetmp3 = mergetmp + c

    worklist = {mergetmp2, mergetmp3}

    mergetmp4 = mergetmp2 + mergetmp3

    worklist = {mergetmp4}

    because we have one operation left, we can now just set the original

    statement equal to the result of that operation.

    This will at least expose a + b  and d + e to redundancy elimination

    as binary operations.

    For extra points, you can reuse the old statements to build the

    mergetmps, since you shouldn't run out.

    So why don't we do this?

    Because it's expensive, and rarely will help.  Most trees we are

    reassociating have 3 or less ops.  If they have 2 ops, they already

    will be written into a nice single binary op.  If you have 3 ops, a

    single simple check suffices to tell you whether the first two are of the

    same rank.  If so, you know to order it

    mergetmp = op1 + op2

    newstmt = mergetmp + op3

    instead of

    mergetmp = op2 + op3

    newstmt = mergetmp + op1

    If all three are of the same rank, you can't expose them all in a

    single binary operator anyway, so the above is *still* the best you

    can do.

    Thus, this is what we do.  When we have three ops left, we check to see

    what order to put them in, and call it a day.  As a nod to vector sum

    reduction, we check if any of ops are a really a phi node that is a

    destructive update for the associating op, and keep the destructive

    update together for vector sum reduction recognition.  */

/* Statistics */

static struct

{

  int linearized;

  int constants_eliminated;

  int ops_eliminated;

  int rewritten;

} reassociate_stats;

/* Operator, rank pair.  */

typedef struct operand_entry

{

  unsigned int rank;

  tree op;

} *operand_entry_t;

static alloc_pool operand_entry_pool;

/* Starting rank number for a given basic block, so that we can rank

   operations using unmovable instructions in that BB based on the bb

   depth.  */

static unsigned int *bb_rank;

/* Operand->rank hashtable.  */

static htab_t operand_rank;

/* Look up the operand rank structure for expression E.  */

static operand_entry_t

find_operand_rank (tree e)

{

  void **slot;

  struct operand_entry vrd;

  vrd.op = e;

  slot = htab_find_slot (operand_rank, &vrd, NO_INSERT);

  if (!slot)

    return NULL;

  return ((operand_entry_t) *slot);

}

/* Insert {E,RANK} into the operand rank hashtable.  */

static void

insert_operand_rank (tree e, unsigned int rank)

{

  void **slot;

  operand_entry_t new_pair = pool_alloc (operand_entry_pool);

  new_pair->op = e;

  new_pair->rank = rank;

  slot = htab_find_slot (operand_rank, new_pair, INSERT);

  gcc_assert (*slot == NULL);

  *slot = new_pair;

}

/* Return the hash value for a operand rank structure  */

static hashval_t

operand_entry_hash (const void *p)

{

  const operand_entry_t vr = (operand_entry_t) p;

  return iterative_hash_expr (vr->op, 0);

}

/* Return true if two operand rank structures are equal.  */

static int

operand_entry_eq (const void *p1, const void *p2)

{

  const operand_entry_t vr1 = (operand_entry_t) p1;

  const operand_entry_t vr2 = (operand_entry_t) p2;

  return vr1->op == vr2->op;

}

/* Given an expression E, return the rank of the expression.  */

static unsigned int

get_rank (tree e)

{

  operand_entry_t vr;

  /* Constants have rank 0.  */

  if (is_gimple_min_invariant (e))

    return 0;

  /* SSA_NAME's have the rank of the expression they are the result

     of.

     For globals and uninitialized values, the rank is 0.

     For function arguments, use the pre-setup rank.

     For PHI nodes, stores, asm statements, etc, we use the rank of

     the BB.

     For simple operations, the rank is the maximum rank of any of

     its operands, or the bb_rank, whichever is less.

     I make no claims that this is optimal, however, it gives good

     results.  */

  if (TREE_CODE (e) == SSA_NAME)

    {

      tree stmt;

      tree rhs;

      unsigned int rank, maxrank;

      int i;

      if (TREE_CODE (SSA_NAME_VAR (e)) == PARM_DECL

          && e == default_def (SSA_NAME_VAR (e)))

        return find_operand_rank (e)->rank;

      stmt = SSA_NAME_DEF_STMT (e);

      if (bb_for_stmt (stmt) == NULL)

        return 0;

      if (TREE_CODE (stmt) != MODIFY_EXPR

          || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))

        return bb_rank[bb_for_stmt (stmt)->index];

      /* If we already have a rank for this expression, use that.  */

      vr = find_operand_rank (e);

      if (vr)

        return vr->rank;

      /* Otherwise, find the maximum rank for the operands, or the bb

         rank, whichever is less.   */

      rank = 0;

      maxrank = bb_rank[bb_for_stmt(stmt)->index];

      rhs = TREE_OPERAND (stmt, 1);

      if (TREE_CODE_LENGTH (TREE_CODE (rhs)) == 0)

        rank = MAX (rank, get_rank (rhs));

      else

        {

          for (i = 0;

               i < TREE_CODE_LENGTH (TREE_CODE (rhs))

                 && TREE_OPERAND (rhs, i)

                 && rank != maxrank;

               i++)

            rank = MAX(rank, get_rank (TREE_OPERAND (rhs, i)));

        }

      if (dump_file && (dump_flags & TDF_DETAILS))

        {

          fprintf (dump_file, "Rank for ");

          print_generic_expr (dump_file, e, 0);

          fprintf (dump_file, " is %d\n", (rank + 1));

        }

      /* Note the rank in the hashtable so we don't recompute it.  */

      insert_operand_rank (e, (rank + 1));

      return (rank + 1);

    }

  /* Globals, etc,  are rank 0 */

  return 0;

}

DEF_VEC_P(operand_entry_t);

DEF_VEC_ALLOC_P(operand_entry_t, heap);

/* We want integer ones to end up last no matter what, since they are

   the ones we can do the most with.  */

#define INTEGER_CONST_TYPE 1 << 3

#define FLOAT_CONST_TYPE 1 << 2

#define OTHER_CONST_TYPE 1 << 1

/* Classify an invariant tree into integer, float, or other, so that

   we can sort them to be near other constants of the same type.  */

static inline int

constant_type (tree t)

{

  if (INTEGRAL_TYPE_P (TREE_TYPE (t)))

    return INTEGER_CONST_TYPE;

  else if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (t)))

    return FLOAT_CONST_TYPE;

  else

    return OTHER_CONST_TYPE;

}

/* qsort comparison function to sort operand entries PA and PB by rank

   so that the sorted array is ordered by rank in decreasing order.  */

static int

sort_by_operand_rank (const void *pa, const void *pb)

{

  const operand_entry_t oea = *(const operand_entry_t *)pa;

  const operand_entry_t oeb = *(const operand_entry_t *)pb;

  /* It's nicer for optimize_expression if constants that are likely

     to fold when added/multiplied//whatever are put next to each

     other.  Since all constants have rank 0, order them by type.  */

  if (oeb->rank == 0 &&  oea->rank == 0)

    return constant_type (oeb->op) - constant_type (oea->op);

  /* Lastly, make sure the versions that are the same go next to each

     other.  We use SSA_NAME_VERSION because it's stable.  */

  if ((oeb->rank - oea->rank == 0)

      && TREE_CODE (oea->op) == SSA_NAME

      && TREE_CODE (oeb->op) == SSA_NAME)

    return SSA_NAME_VERSION (oeb->op) - SSA_NAME_VERSION (oea->op);

  return oeb->rank - oea->rank;

}

/* Add an operand entry to *OPS for the tree operand OP.  */

static void

add_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op)

{

  operand_entry_t oe = pool_alloc (operand_entry_pool);

  oe->op = op;

  oe->rank = get_rank (op);

  VEC_safe_push (operand_entry_t, heap, *ops, oe);

}

/* Return true if STMT is reassociable operation containing a binary

   operation with tree code CODE.  */

static bool

is_reassociable_op (tree stmt, enum tree_code code)

{

  if (!IS_EMPTY_STMT (stmt)

      && TREE_CODE (stmt) == MODIFY_EXPR

      && TREE_CODE (TREE_OPERAND (stmt, 1)) == code

      && has_single_use (TREE_OPERAND (stmt, 0)))

    return true;

  return false;

}

/* Given NAME, if NAME is defined by a unary operation OPCODE, return the

   operand of the negate operation.  Otherwise, return NULL.  */

static tree

get_unary_op (tree name, enum tree_code opcode)

{

  tree stmt = SSA_NAME_DEF_STMT (name);

  tree rhs;

  if (TREE_CODE (stmt) != MODIFY_EXPR)

    return NULL_TREE;

  rhs = TREE_OPERAND (stmt, 1);

  if (TREE_CODE (rhs) == opcode)

    return TREE_OPERAND (rhs, 0);

  return NULL_TREE;

}

/* If CURR and LAST are a pair of ops that OPCODE allows us to

   eliminate through equivalences, do so, remove them from OPS, and

   return true.  Otherwise, return false.  */

static bool

eliminate_duplicate_pair (enum tree_code opcode,

                          VEC (operand_entry_t, heap) **ops,

                          bool *all_done,

                          unsigned int i,

                          operand_entry_t curr,

                          operand_entry_t last)

{

  /* If we have two of the same op, and the opcode is & |, min, or max,

     we can eliminate one of them.

     If we have two of the same op, and the opcode is ^, we can

     eliminate both of them.  */

  if (last && last->op == curr->op)

    {

      switch (opcode)

        {

        case MAX_EXPR:

        case MIN_EXPR:

        case BIT_IOR_EXPR:

        case BIT_AND_EXPR:

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

              fprintf (dump_file, "Equivalence: ");

              print_generic_expr (dump_file, curr->op, 0);

              fprintf (dump_file, " [&|minmax] ");

              print_generic_expr (dump_file, last->op, 0);

              fprintf (dump_file, " -> ");

              print_generic_stmt (dump_file, last->op, 0);

            }

          VEC_ordered_remove (operand_entry_t, *ops, i);

          reassociate_stats.ops_eliminated ++;

          return true;

        case BIT_XOR_EXPR:

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

              fprintf (dump_file, "Equivalence: ");

              print_generic_expr (dump_file, curr->op, 0);

              fprintf (dump_file, " ^ ");

              print_generic_expr (dump_file, last->op, 0);

              fprintf (dump_file, " -> nothing\n");

            }

          reassociate_stats.ops_eliminated += 2;

          if (VEC_length (operand_entry_t, *ops) == 2)

            {

              VEC_free (operand_entry_t, heap, *ops);

              *ops = NULL;

              add_to_ops_vec (ops, fold_convert (TREE_TYPE (last->op),

                                                 integer_zero_node));

              *all_done = true;

            }

          else

            {

              VEC_ordered_remove (operand_entry_t, *ops, i-1);

              VEC_ordered_remove (operand_entry_t, *ops, i-1);

            }

          return true;

        default:

          break;

        }

    }

  return false;

}

/* If OPCODE is PLUS_EXPR, CURR->OP is really a negate expression,

   look in OPS for a corresponding positive operation to cancel it

   out.  If we find one, remove the other from OPS, replace

   OPS[CURRINDEX] with 0, and return true.  Otherwise, return

   false. */

static bool

eliminate_plus_minus_pair (enum tree_code opcode,

                           VEC (operand_entry_t, heap) **ops,

                           unsigned int currindex,

                           operand_entry_t curr)

{

  tree negateop;

  unsigned int i;

  operand_entry_t oe;

  if (opcode != PLUS_EXPR || TREE_CODE (curr->op) != SSA_NAME)

    return false;

  negateop = get_unary_op (curr->op, NEGATE_EXPR);

  if (negateop == NULL_TREE)

    return false;

  /* Any non-negated version will have a rank that is one less than

     the current rank.  So once we hit those ranks, if we don't find

     one, we can stop.  */

  for (i = currindex + 1;

       VEC_iterate (operand_entry_t, *ops, i, oe)

       && oe->rank >= curr->rank - 1 ;

       i++)

    {

      if (oe->op == negateop)

        {

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

              fprintf (dump_file, "Equivalence: ");

              print_generic_expr (dump_file, negateop, 0);

              fprintf (dump_file, " + -");

              print_generic_expr (dump_file, oe->op, 0);

              fprintf (dump_file, " -> 0\n");

            }

          VEC_ordered_remove (operand_entry_t, *ops, i);

          add_to_ops_vec (ops, fold_convert(TREE_TYPE (oe->op),

                                            integer_zero_node));

          VEC_ordered_remove (operand_entry_t, *ops, currindex);

          reassociate_stats.ops_eliminated ++;

          return true;

        }

    }

  return false;

}

/* If OPCODE is BIT_IOR_EXPR, BIT_AND_EXPR, and, CURR->OP is really a

   bitwise not expression, look in OPS for a corresponding operand to

   cancel it out.  If we find one, remove the other from OPS, replace

   OPS[CURRINDEX] with 0, and return true.  Otherwise, return

   false. */

static bool

eliminate_not_pairs (enum tree_code opcode,

                     VEC (operand_entry_t, heap) **ops,

                     unsigned int currindex,

                     operand_entry_t curr)

{

  tree notop;

  unsigned int i;

  operand_entry_t oe;

  if ((opcode != BIT_IOR_EXPR && opcode != BIT_AND_EXPR)

      || TREE_CODE (curr->op) != SSA_NAME)

    return false;

  notop = get_unary_op (curr->op, BIT_NOT_EXPR);

  if (notop == NULL_TREE)

    return false;

  /* Any non-not version will have a rank that is one less than

     the current rank.  So once we hit those ranks, if we don't find

     one, we can stop.  */

  for (i = currindex + 1;

       VEC_iterate (operand_entry_t, *ops, i, oe)

       && oe->rank >= curr->rank - 1;

       i++)

    {

      if (oe->op == notop)

        {

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

              fprintf (dump_file, "Equivalence: ");

              print_generic_expr (dump_file, notop, 0);

              if (opcode == BIT_AND_EXPR)

                fprintf (dump_file, " & ~");

              else if (opcode == BIT_IOR_EXPR)

                fprintf (dump_file, " | ~");

              print_generic_expr (dump_file, oe->op, 0);

              if (opcode == BIT_AND_EXPR)

                fprintf (dump_file, " -> 0\n");

              else if (opcode == BIT_IOR_EXPR)

                fprintf (dump_file, " -> -1\n");

            }

          if (opcode == BIT_AND_EXPR)

            oe->op = fold_convert (TREE_TYPE (oe->op), integer_zero_node);

          else if (opcode == BIT_IOR_EXPR)

            oe->op = build_low_bits_mask (TREE_TYPE (oe->op),

                                          TYPE_PRECISION (TREE_TYPE (oe->op)));

          reassociate_stats.ops_eliminated

            += VEC_length (operand_entry_t, *ops) - 1;

          VEC_free (operand_entry_t, heap, *ops);

          *ops = NULL;

          VEC_safe_push (operand_entry_t, heap, *ops, oe);

          return true;

        }

    }

  return false;

}

/* Use constant value that may be present in OPS to try to eliminate

   operands.  Note that this function is only really used when we've

   eliminated ops for other reasons, or merged constants.  Across

   single statements, fold already does all of this, plus more.  There

   is little point in duplicating logic, so I've only included the

   identities that I could ever construct testcases to trigger.  */

static void

eliminate_using_constants (enum tree_code opcode,

                           VEC(operand_entry_t, heap) **ops)

{

  operand_entry_t oelast = VEC_last (operand_entry_t, *ops);

  if (oelast->rank == 0 && INTEGRAL_TYPE_P (TREE_TYPE (oelast->op)))

    {

      switch (opcode)

        {

        case BIT_AND_EXPR:

          if (integer_zerop (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))

                    fprintf (dump_file, "Found & 0, removing all other ops\n");

                  reassociate_stats.ops_eliminated

                    += VEC_length (operand_entry_t, *ops) - 1;

                  VEC_free (operand_entry_t, heap, *ops);

                  *ops = NULL;

                  VEC_safe_push (operand_entry_t, heap, *ops, oelast);

                  return;

                }

            }

          else if (integer_all_onesp (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))

                    fprintf (dump_file, "Found & -1, removing\n");

                  VEC_pop (operand_entry_t, *ops);

                  reassociate_stats.ops_eliminated++;

                }

            }

          break;

        case BIT_IOR_EXPR:

          if (integer_all_onesp (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))

                    fprintf (dump_file, "Found | -1, removing all other ops\n");

                  reassociate_stats.ops_eliminated

                    += VEC_length (operand_entry_t, *ops) - 1;

                  VEC_free (operand_entry_t, heap, *ops);

                  *ops = NULL;

                  VEC_safe_push (operand_entry_t, heap, *ops, oelast);

                  return;

                }

            }

          else if (integer_zerop (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))

                    fprintf (dump_file, "Found | 0, removing\n");

                  VEC_pop (operand_entry_t, *ops);

                  reassociate_stats.ops_eliminated++;

                }

            }

          break;

        case MULT_EXPR:

          if (integer_zerop (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))

                    fprintf (dump_file, "Found * 0, removing all other ops\n");

                  reassociate_stats.ops_eliminated

                    += VEC_length (operand_entry_t, *ops) - 1;

                  VEC_free (operand_entry_t, heap, *ops);

                  *ops = NULL;

                  VEC_safe_push (operand_entry_t, heap, *ops, oelast);

                  return;

                }

            }

          else if (integer_onep (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))

                    fprintf (dump_file, "Found * 1, removing\n");

                  VEC_pop (operand_entry_t, *ops);

                  reassociate_stats.ops_eliminated++;

                  return;

                }

            }

          break;

        case BIT_XOR_EXPR:

        case PLUS_EXPR:

        case MINUS_EXPR:

          if (integer_zerop (oelast->op))

            {

              if (VEC_length (operand_entry_t, *ops) != 1)

                {

                  if (dump_file && (dump_flags & TDF_DETAILS))