Subversion Repositories openrisc_2011-10-31

/* Reassociation for trees.

/* Reassociation for trees.

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

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

   Contributed by Daniel Berlin <dan@dberlin.org>

   Contributed by Daniel Berlin <dan@dberlin.org>

This file is part of GCC.

This file is part of GCC.

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

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

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

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

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

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

any later version.

any later version.

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

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

but WITHOUT ANY WARRANTY; without even the implied warranty of

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

GNU General Public License for more details.

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

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

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

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

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

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

#include "config.h"

#include "config.h"

#include "system.h"

#include "system.h"

#include "coretypes.h"

#include "coretypes.h"

#include "tm.h"

#include "tm.h"

#include "errors.h"

#include "errors.h"

#include "ggc.h"

#include "ggc.h"

#include "tree.h"

#include "tree.h"

#include "basic-block.h"

#include "basic-block.h"

#include "diagnostic.h"

#include "diagnostic.h"

#include "tree-inline.h"

#include "tree-inline.h"

#include "tree-flow.h"

#include "tree-flow.h"

#include "tree-gimple.h"

#include "tree-gimple.h"

#include "tree-dump.h"

#include "tree-dump.h"

#include "timevar.h"

#include "timevar.h"

#include "tree-iterator.h"

#include "tree-iterator.h"

#include "tree-pass.h"

#include "tree-pass.h"

#include "alloc-pool.h"

#include "alloc-pool.h"

#include "vec.h"

#include "vec.h"

#include "langhooks.h"

#include "langhooks.h"

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

/*  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

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

    than we do, in different orders, etc).

    than we do, in different orders, etc).

    It consists of five steps:

    It consists of five steps:

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

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

    it would promote the reassociation of adds.

    it would promote the reassociation of adds.

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

    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.

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

    During linearization, we place the operands of the binary

    During linearization, we place the operands of the binary

    expressions into a vector of operand_entry_t

    expressions into a vector of operand_entry_t

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

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

    -a, a & a, etc.

    -a, a & a, etc.

    4. Rewrite the expression trees we linearized and optimized so

    4. Rewrite the expression trees we linearized and optimized so

    they are in proper rank order.

    they are in proper rank order.

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

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

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

    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:

    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

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

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

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

    In order to promote the most redundancy elimination, you want

    In order to promote the most redundancy elimination, you want

    binary expressions whose operands are the same rank (or

    binary expressions whose operands are the same rank (or

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

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

    for possible elimination.

    for possible elimination.

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

    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

    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

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

    thing on the worklist.

    thing on the worklist.

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

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

    rank in parentheses), with opcode PLUS_EXPR:

    rank in parentheses), with opcode PLUS_EXPR:

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

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

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

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

    those on it.

    those on it.

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

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

    possible.

    possible.

    So first build a binary op of

    So first build a binary op of

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

    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

    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.

    be exposed to redundancy elimination as a rank 1 operand.

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

    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,

    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

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

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

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

    Then build a binary op of d + e

    Then build a binary op of d + e

    mergetmp2 = d + e

    mergetmp2 = d + e

    and put mergetmp2 on the merge worklist.

    and put mergetmp2 on the merge worklist.

    so merge worklist = {mergetmp, c, mergetmp2}

    so merge worklist = {mergetmp, c, mergetmp2}

    Continue building binary ops of these operations until you have only

    Continue building binary ops of these operations until you have only

    one operation left on the worklist.

    one operation left on the worklist.

    So we have

    So we have

    build binary op

    build binary op

    mergetmp3 = mergetmp + c

    mergetmp3 = mergetmp + c

    worklist = {mergetmp2, mergetmp3}

    worklist = {mergetmp2, mergetmp3}

    mergetmp4 = mergetmp2 + mergetmp3

    mergetmp4 = mergetmp2 + mergetmp3

    worklist = {mergetmp4}

    worklist = {mergetmp4}

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

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

    statement equal to the result of that operation.

    statement equal to the result of that operation.

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

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

    as binary operations.

    as binary operations.

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

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

    mergetmps, since you shouldn't run out.

    mergetmps, since you shouldn't run out.

    So why don't we do this?

    So why don't we do this?

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

    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

    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

    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

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

    same rank.  If so, you know to order it

    same rank.  If so, you know to order it

    mergetmp = op1 + op2

    mergetmp = op1 + op2

    newstmt = mergetmp + op3

    newstmt = mergetmp + op3

    instead of

    instead of

    mergetmp = op2 + op3

    mergetmp = op2 + op3

    newstmt = mergetmp + op1

    newstmt = mergetmp + op1

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

    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

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

    can do.

    can do.

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

    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

    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

    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

    destructive update for the associating op, and keep the destructive

    update together for vector sum reduction recognition.  */

    update together for vector sum reduction recognition.  */

/* Statistics */

/* Statistics */

static struct

static struct

{

{

  int linearized;

  int linearized;

  int constants_eliminated;

  int constants_eliminated;

  int ops_eliminated;

  int ops_eliminated;

  int rewritten;

  int rewritten;

} reassociate_stats;

} reassociate_stats;

/* Operator, rank pair.  */

/* Operator, rank pair.  */

typedef struct operand_entry

typedef struct operand_entry

{

{

  unsigned int rank;

  unsigned int rank;

  tree op;

  tree op;

} *operand_entry_t;

} *operand_entry_t;

static alloc_pool operand_entry_pool;

static alloc_pool operand_entry_pool;

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

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

   operations using unmovable instructions in that BB based on the bb

   operations using unmovable instructions in that BB based on the bb

   depth.  */

   depth.  */

static unsigned int *bb_rank;

static unsigned int *bb_rank;

/* Operand->rank hashtable.  */

/* Operand->rank hashtable.  */

static htab_t operand_rank;

static htab_t operand_rank;

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

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

static operand_entry_t

static operand_entry_t

find_operand_rank (tree e)

find_operand_rank (tree e)

{

{

  void **slot;

  void **slot;

  struct operand_entry vrd;

  struct operand_entry vrd;

  vrd.op = e;

  vrd.op = e;

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

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

  if (!slot)

  if (!slot)

    return NULL;

    return NULL;

  return ((operand_entry_t) *slot);

  return ((operand_entry_t) *slot);

}

}

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

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

static void

static void

insert_operand_rank (tree e, unsigned int rank)

insert_operand_rank (tree e, unsigned int rank)

{

{

  void **slot;

  void **slot;

  operand_entry_t new_pair = pool_alloc (operand_entry_pool);

  operand_entry_t new_pair = pool_alloc (operand_entry_pool);

  new_pair->op = e;

  new_pair->op = e;

  new_pair->rank = rank;

  new_pair->rank = rank;

  slot = htab_find_slot (operand_rank, new_pair, INSERT);

  slot = htab_find_slot (operand_rank, new_pair, INSERT);

  gcc_assert (*slot == NULL);

  gcc_assert (*slot == NULL);

  *slot = new_pair;

  *slot = new_pair;

}

}

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

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

static hashval_t

static hashval_t

operand_entry_hash (const void *p)

operand_entry_hash (const void *p)

{

{

  const operand_entry_t vr = (operand_entry_t) p;

  const operand_entry_t vr = (operand_entry_t) p;

  return iterative_hash_expr (vr->op, 0);

  return iterative_hash_expr (vr->op, 0);

}

}

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

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

static int

static int

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

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

{

{

  const operand_entry_t vr1 = (operand_entry_t) p1;

  const operand_entry_t vr1 = (operand_entry_t) p1;

  const operand_entry_t vr2 = (operand_entry_t) p2;

  const operand_entry_t vr2 = (operand_entry_t) p2;

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

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

}

}

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

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

static unsigned int

static unsigned int

get_rank (tree e)

get_rank (tree e)

{

{

  operand_entry_t vr;

  operand_entry_t vr;

  /* Constants have rank 0.  */

  /* Constants have rank 0.  */

  if (is_gimple_min_invariant (e))

  if (is_gimple_min_invariant (e))

    return 0;

    return 0;

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

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

     of.

     of.

     For globals and uninitialized values, the rank is 0.

     For globals and uninitialized values, the rank is 0.

     For function arguments, use the pre-setup rank.

     For function arguments, use the pre-setup rank.

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

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

     the BB.

     the BB.

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

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

     its operands, or the bb_rank, whichever is less.

     its operands, or the bb_rank, whichever is less.

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

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

     results.  */

     results.  */

  if (TREE_CODE (e) == SSA_NAME)

  if (TREE_CODE (e) == SSA_NAME)

    {

    {

      tree stmt;

      tree stmt;

      tree rhs;

      tree rhs;

      unsigned int rank, maxrank;

      unsigned int rank, maxrank;

      int i;

      int i;

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

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

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

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

        return find_operand_rank (e)->rank;

        return find_operand_rank (e)->rank;

      stmt = SSA_NAME_DEF_STMT (e);

      stmt = SSA_NAME_DEF_STMT (e);

      if (bb_for_stmt (stmt) == NULL)

      if (bb_for_stmt (stmt) == NULL)

        return 0;

        return 0;

      if (TREE_CODE (stmt) != MODIFY_EXPR

      if (TREE_CODE (stmt) != MODIFY_EXPR

          || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))

          || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))

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

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

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

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

      vr = find_operand_rank (e);

      vr = find_operand_rank (e);

      if (vr)

      if (vr)

        return vr->rank;

        return vr->rank;

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

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

         rank, whichever is less.   */

         rank, whichever is less.   */

      rank = 0;

      rank = 0;

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

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

      rhs = TREE_OPERAND (stmt, 1);

      rhs = TREE_OPERAND (stmt, 1);

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

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

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

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

      else

      else

        {

        {

          for (i = 0;

          for (i = 0;

               i < TREE_CODE_LENGTH (TREE_CODE (rhs))

               i < TREE_CODE_LENGTH (TREE_CODE (rhs))

                 && TREE_OPERAND (rhs, i)

                 && TREE_OPERAND (rhs, i)

                 && rank != maxrank;

                 && rank != maxrank;

               i++)

               i++)

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

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

        }

        }

      if (dump_file && (dump_flags & TDF_DETAILS))

      if (dump_file && (dump_flags & TDF_DETAILS))

        {

        {

          fprintf (dump_file, "Rank for ");

          fprintf (dump_file, "Rank for ");

          print_generic_expr (dump_file, e, 0);

          print_generic_expr (dump_file, e, 0);

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

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

        }

        }

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

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

      insert_operand_rank (e, (rank + 1));

      insert_operand_rank (e, (rank + 1));

      return (rank + 1);

      return (rank + 1);

    }

    }

  /* Globals, etc,  are rank 0 */

  /* Globals, etc,  are rank 0 */

  return 0;

  return 0;

}

}

DEF_VEC_P(operand_entry_t);

DEF_VEC_P(operand_entry_t);

DEF_VEC_ALLOC_P(operand_entry_t, heap);

DEF_VEC_ALLOC_P(operand_entry_t, heap);

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

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

   the ones we can do the most with.  */

   the ones we can do the most with.  */

#define INTEGER_CONST_TYPE 1 << 3

#define INTEGER_CONST_TYPE 1 << 3

#define FLOAT_CONST_TYPE 1 << 2

#define FLOAT_CONST_TYPE 1 << 2

#define OTHER_CONST_TYPE 1 << 1

#define OTHER_CONST_TYPE 1 << 1

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

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

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

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

static inline int

static inline int

constant_type (tree t)

constant_type (tree t)

{

{

  if (INTEGRAL_TYPE_P (TREE_TYPE (t)))

  if (INTEGRAL_TYPE_P (TREE_TYPE (t)))

    return INTEGER_CONST_TYPE;

    return INTEGER_CONST_TYPE;

  else if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (t)))

  else if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (t)))

    return FLOAT_CONST_TYPE;

    return FLOAT_CONST_TYPE;

  else

  else

    return OTHER_CONST_TYPE;

    return OTHER_CONST_TYPE;

}

}

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

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

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

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

static int

static int

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

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

{

{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return oeb->rank - oea->rank;

  return oeb->rank - oea->rank;

}

}

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

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

static void

static void

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

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

{

{

  operand_entry_t oe = pool_alloc (operand_entry_pool);

  operand_entry_t oe = pool_alloc (operand_entry_pool);

  oe->op = op;

  oe->op = op;

  oe->rank = get_rank (op);

  oe->rank = get_rank (op);

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

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

}

}

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

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

   operation with tree code CODE.  */

   operation with tree code CODE.  */

static bool

static bool

is_reassociable_op (tree stmt, enum tree_code code)

is_reassociable_op (tree stmt, enum tree_code code)

{

{

  if (!IS_EMPTY_STMT (stmt)

  if (!IS_EMPTY_STMT (stmt)

      && TREE_CODE (stmt) == MODIFY_EXPR

      && TREE_CODE (stmt) == MODIFY_EXPR

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

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

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

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

    return true;

    return true;

  return false;

  return false;

}

}

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

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

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

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

static tree

static tree

get_unary_op (tree name, enum tree_code opcode)

get_unary_op (tree name, enum tree_code opcode)

{

{

  tree stmt = SSA_NAME_DEF_STMT (name);

  tree stmt = SSA_NAME_DEF_STMT (name);

  tree rhs;

  tree rhs;

  if (TREE_CODE (stmt) != MODIFY_EXPR)

  if (TREE_CODE (stmt) != MODIFY_EXPR)

    return NULL_TREE;

    return NULL_TREE;

  rhs = TREE_OPERAND (stmt, 1);

  rhs = TREE_OPERAND (stmt, 1);

  if (TREE_CODE (rhs) == opcode)

  if (TREE_CODE (rhs) == opcode)

    return TREE_OPERAND (rhs, 0);

    return TREE_OPERAND (rhs, 0);

  return NULL_TREE;

  return NULL_TREE;

}

}

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

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

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

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

   return true.  Otherwise, return false.  */

   return true.  Otherwise, return false.  */

static bool

static bool

eliminate_duplicate_pair (enum tree_code opcode,

eliminate_duplicate_pair (enum tree_code opcode,

                          VEC (operand_entry_t, heap) **ops,

                          VEC (operand_entry_t, heap) **ops,

                          bool *all_done,

                          bool *all_done,

                          unsigned int i,

                          unsigned int i,

                          operand_entry_t curr,

                          operand_entry_t curr,

                          operand_entry_t last)

                          operand_entry_t last)

{

{

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

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

     we can eliminate one of them.

     we can eliminate one of them.

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

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

     eliminate both of them.  */

     eliminate both of them.  */

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

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

    {

    {

      switch (opcode)

      switch (opcode)

        {

        {

        case MAX_EXPR:

        case MAX_EXPR:

        case MIN_EXPR:

        case MIN_EXPR:

        case BIT_IOR_EXPR:

        case BIT_IOR_EXPR:

        case BIT_AND_EXPR:

        case BIT_AND_EXPR:

          if (dump_file && (dump_flags & TDF_DETAILS))

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

            {

              fprintf (dump_file, "Equivalence: ");

              fprintf (dump_file, "Equivalence: ");

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

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

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

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

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

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

              fprintf (dump_file, " -> ");

              fprintf (dump_file, " -> ");

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

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

            }

            }

          VEC_ordered_remove (operand_entry_t, *ops, i);

          VEC_ordered_remove (operand_entry_t, *ops, i);

          reassociate_stats.ops_eliminated ++;

          reassociate_stats.ops_eliminated ++;

          return true;

          return true;

        case BIT_XOR_EXPR:

        case BIT_XOR_EXPR:

          if (dump_file && (dump_flags & TDF_DETAILS))

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

            {

              fprintf (dump_file, "Equivalence: ");

              fprintf (dump_file, "Equivalence: ");

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

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

              fprintf (dump_file, " ^ ");

              fprintf (dump_file, " ^ ");

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

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

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

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

            }

            }

          reassociate_stats.ops_eliminated += 2;

          reassociate_stats.ops_eliminated += 2;

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

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

            {

            {

              VEC_free (operand_entry_t, heap, *ops);

              VEC_free (operand_entry_t, heap, *ops);

              *ops = NULL;

              *ops = NULL;

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

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

                                                 integer_zero_node));

                                                 integer_zero_node));

              *all_done = true;

              *all_done = true;

            }

            }

          else

          else

            {

            {

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

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

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

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

            }

            }

          return true;

          return true;

        default:

        default:

          break;

          break;

        }

        }

    }

    }

  return false;

  return false;

}

}

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

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

   look in OPS for a corresponding positive operation to cancel it

   look in OPS for a corresponding positive operation to cancel it

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

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

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

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

   false. */

   false. */

static bool

static bool

eliminate_plus_minus_pair (enum tree_code opcode,

eliminate_plus_minus_pair (enum tree_code opcode,

                           VEC (operand_entry_t, heap) **ops,

                           VEC (operand_entry_t, heap) **ops,

                           unsigned int currindex,

                           unsigned int currindex,

                           operand_entry_t curr)

                           operand_entry_t curr)

{

{

  tree negateop;

  tree negateop;

  unsigned int i;

  unsigned int i;

  operand_entry_t oe;

  operand_entry_t oe;

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

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

    return false;

    return false;

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

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

  if (negateop == NULL_TREE)

  if (negateop == NULL_TREE)

    return false;

    return false;

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

  /* 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

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

     one, we can stop.  */

     one, we can stop.  */

  for (i = currindex + 1;

  for (i = currindex + 1;

       VEC_iterate (operand_entry_t, *ops, i, oe)

       VEC_iterate (operand_entry_t, *ops, i, oe)

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

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

       i++)

       i++)

    {

    {

      if (oe->op == negateop)

      if (oe->op == negateop)

        {

        {

          if (dump_file && (dump_flags & TDF_DETAILS))

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

            {

              fprintf (dump_file, "Equivalence: ");

              fprintf (dump_file, "Equivalence: ");

              print_generic_expr (dump_file, negateop, 0);

              print_generic_expr (dump_file, negateop, 0);

              fprintf (dump_file, " + -");

              fprintf (dump_file, " + -");

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

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

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

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

            }

            }

          VEC_ordered_remove (operand_entry_t, *ops, i);

          VEC_ordered_remove (operand_entry_t, *ops, i);

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

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

                                            integer_zero_node));

                                            integer_zero_node));

          VEC_ordered_remove (operand_entry_t, *ops, currindex);

          VEC_ordered_remove (operand_entry_t, *ops, currindex);

          reassociate_stats.ops_eliminated ++;

          reassociate_stats.ops_eliminated ++;

          return true;

          return true;

        }

        }

    }

    }

  return false;

  return false;

}

}

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

/* 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

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

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

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

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

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

   false. */

   false. */

static bool

static bool

eliminate_not_pairs (enum tree_code opcode,

eliminate_not_pairs (enum tree_code opcode,

                     VEC (operand_entry_t, heap) **ops,

                     VEC (operand_entry_t, heap) **ops,

                     unsigned int currindex,

                     unsigned int currindex,

                     operand_entry_t curr)

                     operand_entry_t curr)

{

{

  tree notop;

  tree notop;

  unsigned int i;

  unsigned int i;

  operand_entry_t oe;

  operand_entry_t oe;

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

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

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

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

    return false;

    return false;

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

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

  if (notop == NULL_TREE)

  if (notop == NULL_TREE)

    return false;

    return false;

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

  /* 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

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

     one, we can stop.  */

     one, we can stop.  */

  for (i = currindex + 1;

  for (i = currindex + 1;

       VEC_iterate (operand_entry_t, *ops, i, oe)

       VEC_iterate (operand_entry_t, *ops, i, oe)

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

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

       i++)

       i++)

    {

    {

      if (oe->op == notop)

      if (oe->op == notop)

        {

        {

          if (dump_file && (dump_flags & TDF_DETAILS))

          if (dump_file && (dump_flags & TDF_DETAILS))

            {

            {

              fprintf (dump_file, "Equivalence: ");

              fprintf (dump_file, "Equivalence: ");

              print_generic_expr (dump_file, notop, 0);

              print_generic_expr (dump_file, notop, 0);

              if (opcode == BIT_AND_EXPR)

              if (opcode == BIT_AND_EXPR)

                fprintf (dump_file, " & ~");

                fprintf (dump_file, " & ~");

              else if (opcode == BIT_IOR_EXPR)

              else if (opcode == BIT_IOR_EXPR)

                fprintf (dump_file, " | ~");

                fprintf (dump_file, " | ~");

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

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

              if (opcode == BIT_AND_EXPR)

              if (opcode == BIT_AND_EXPR)

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

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

              else if (opcode == BIT_IOR_EXPR)

              else if (opcode == BIT_IOR_EXPR)

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

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

            }

            }

          if (opcode == BIT_AND_EXPR)

          if (opcode == BIT_AND_EXPR)

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

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

          else if (opcode == BIT_IOR_EXPR)

          else if (opcode == BIT_IOR_EXPR)

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

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

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

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

          reassociate_stats.ops_eliminated

          reassociate_stats.ops_eliminated

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

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

          VEC_free (operand_entry_t, heap, *ops);

          VEC_free (operand_entry_t, heap, *ops);

          *ops = NULL;

          *ops = NULL;

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

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

          return true;

          return true;

        }