Fix thinko

[official-gcc.git] / gcc / cfgloopanal.c

/* Natural loop analysis code for GNU compiler.
   Copyright (C) 2002, 2003 Free Software Foundation, Inc.

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 2, 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 COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "cfgloop.h"
#include "expr.h"
#include "output.h"

struct unmark_altered_insn_data;
static void unmark_altered (rtx, rtx, regset);
static void blocks_invariant_registers (basic_block *, int, regset);
static void unmark_altered_insn (rtx, rtx, struct unmark_altered_insn_data *);
static void blocks_single_set_registers (basic_block *, int, rtx *);
static int invariant_rtx_wrto_regs_p_helper (rtx *, regset);
static bool invariant_rtx_wrto_regs_p (rtx, regset);
static rtx test_for_iteration (struct loop_desc *desc, unsigned HOST_WIDE_INT);
static bool constant_iterations (struct loop_desc *, unsigned HOST_WIDE_INT *,
                                 bool *);
static bool simple_loop_exit_p (struct loops *, struct loop *, edge, regset,
                                rtx *, struct loop_desc *);
static rtx variable_initial_value (rtx, regset, rtx, rtx *);
static rtx variable_initial_values (edge, rtx);
static bool simple_condition_p (struct loop *, rtx, regset,
                                struct loop_desc *);
static basic_block simple_increment (struct loops *, struct loop *, rtx *,
                                     struct loop_desc *);
static rtx count_strange_loop_iterations (rtx, rtx, enum rtx_code,
                                          int, rtx, enum machine_mode);

/* Checks whether BB is executed exactly once in each LOOP iteration.  */
bool
just_once_each_iteration_p (struct loops *loops, struct loop *loop, basic_block bb)
{
  /* It must be executed at least once each iteration.  */
  if (!dominated_by_p (loops->cfg.dom, loop->latch, bb))
    return false;

  /* And just once.  */
  if (bb->loop_father != loop)
    return false;

  /* But this was not enough.  We might have some irreducible loop here.  */
  if (bb->flags & BB_IRREDUCIBLE_LOOP)
    return false;

  return true;
}


/* Unmarks modified registers; helper to blocks_invariant_registers.  */
static void
unmark_altered (rtx what, rtx by ATTRIBUTE_UNUSED, regset regs)
{
  if (GET_CODE (what) == SUBREG)
    what = SUBREG_REG (what);
  if (!REG_P (what))
    return;
  CLEAR_REGNO_REG_SET (regs, REGNO (what));
}

/* Marks registers that are invariant inside blocks BBS.  */
static void
blocks_invariant_registers (basic_block *bbs, int nbbs, regset regs)
{
  rtx insn;
  int i;

  for (i = 0; i < max_reg_num (); i++)
    SET_REGNO_REG_SET (regs, i);
  for (i = 0; i < nbbs; i++)
    for (insn = bbs[i]->head;
         insn != NEXT_INSN (bbs[i]->end);
         insn = NEXT_INSN (insn))
      if (INSN_P (insn))
        note_stores (PATTERN (insn),
                     (void (*) (rtx, rtx, void *)) unmark_altered,
                     regs);
}

/* Unmarks modified registers; helper to blocks_single_set_registers.  */
struct unmark_altered_insn_data
{
  rtx *regs;
  rtx insn;
};

static void
unmark_altered_insn (rtx what, rtx by ATTRIBUTE_UNUSED,
                     struct unmark_altered_insn_data *data)
{
  int rn;

  if (GET_CODE (what) == SUBREG)
    what = SUBREG_REG (what);
  if (!REG_P (what))
    return;
  rn = REGNO (what);
  if (data->regs[rn] == data->insn)
    return;
  data->regs[rn] = NULL;
}

/* Marks registers that have just single simple set in BBS; the relevant
   insn is returned in REGS.  */
static void
blocks_single_set_registers (basic_block *bbs, int nbbs, rtx *regs)
{
  rtx insn;
  int i;
  struct unmark_altered_insn_data data;

  for (i = 0; i < max_reg_num (); i++)
    regs[i] = NULL;

  for (i = 0; i < nbbs; i++)
    for (insn = bbs[i]->head;
         insn != NEXT_INSN (bbs[i]->end);
         insn = NEXT_INSN (insn))
      {
        rtx set = single_set (insn);
        if (!set)
          continue;
        if (!REG_P (SET_DEST (set)))
          continue;
        regs[REGNO (SET_DEST (set))] = insn;
      }

  data.regs = regs;
  for (i = 0; i < nbbs; i++)
    for (insn = bbs[i]->head;
         insn != NEXT_INSN (bbs[i]->end);
         insn = NEXT_INSN (insn))
      {
        if (!INSN_P (insn))
          continue;
        data.insn = insn;
        note_stores (PATTERN (insn),
            (void (*) (rtx, rtx, void *)) unmark_altered_insn,
            &data);
      }
}

/* Helper for invariant_rtx_wrto_regs_p.  */
static int
invariant_rtx_wrto_regs_p_helper (rtx *expr, regset invariant_regs)
{
  switch (GET_CODE (*expr))
    {
    case CC0:
    case PC:
    case UNSPEC_VOLATILE:
      return 1;

    case CONST_INT:
    case CONST_DOUBLE:
    case CONST:
    case SYMBOL_REF:
    case LABEL_REF:
      return 0;

    case ASM_OPERANDS:
      return MEM_VOLATILE_P (*expr);

    case MEM:
      /* If the memory is not constant, assume it is modified.  If it is
         constant, we still have to check the address.  */
      return !RTX_UNCHANGING_P (*expr);

    case REG:
      return !REGNO_REG_SET_P (invariant_regs, REGNO (*expr));

    default:
      return 0;
    }
}

/* Checks that EXPR is invariant provided that INVARIANT_REGS are invariant.  */
static bool
invariant_rtx_wrto_regs_p (rtx expr, regset invariant_regs)
{
  return !for_each_rtx (&expr, (rtx_function) invariant_rtx_wrto_regs_p_helper,
                        invariant_regs);
}

/* Checks whether CONDITION is a simple comparison in that one of operands
   is register and the other one is invariant in the LOOP. Fills var, lim
   and cond fields in DESC.  */
static bool
simple_condition_p (struct loop *loop ATTRIBUTE_UNUSED, rtx condition,
                    regset invariant_regs, struct loop_desc *desc)
{
  rtx op0, op1;

  /* Check condition.  */
  switch (GET_CODE (condition))
    {
      case EQ:
      case NE:
      case LE:
      case LT:
      case GE:
      case GT:
      case GEU:
      case GTU:
      case LEU:
      case LTU:
        break;
      default:
        return false;
    }

  /* Of integers or pointers.  */
  if (GET_MODE_CLASS (GET_MODE (XEXP (condition, 0))) != MODE_INT
      && GET_MODE_CLASS (GET_MODE (XEXP (condition, 0))) != MODE_PARTIAL_INT)
    return false;

  /* One of operands must be a simple register.  */
  op0 = XEXP (condition, 0);
  op1 = XEXP (condition, 1);

  /* One of operands must be invariant.  */
  if (invariant_rtx_wrto_regs_p (op0, invariant_regs))
    {
      /* And the other one must be a register.  */
      if (!REG_P (op1))
        return false;
      desc->var = op1;
      desc->lim = op0;

      desc->cond = swap_condition (GET_CODE (condition));
      if (desc->cond == UNKNOWN)
        return false;
      return true;
    }

  /* Check the other operand.  */
  if (!invariant_rtx_wrto_regs_p (op1, invariant_regs))
    return false;
  if (!REG_P (op0))
    return false;

  desc->var = op0;
  desc->lim = op1;

  desc->cond = GET_CODE (condition);

  return true;
}

/* Checks whether DESC->var is incremented/decremented exactly once each
   iteration.  Fills in DESC->stride and returns block in that DESC->var is
   modified.  */
static basic_block
simple_increment (struct loops *loops, struct loop *loop,
                  rtx *simple_increment_regs, struct loop_desc *desc)
{
  rtx mod_insn, set, set_src, set_add;
  basic_block mod_bb;

  /* Find insn that modifies var.  */
  mod_insn = simple_increment_regs[REGNO (desc->var)];
  if (!mod_insn)
    return NULL;
  mod_bb = BLOCK_FOR_INSN (mod_insn);

  /* Check that it is executed exactly once each iteration.  */
  if (!just_once_each_iteration_p (loops, loop, mod_bb))
    return NULL;

  /* mod_insn must be a simple increment/decrement.  */
  set = single_set (mod_insn);
  if (!set)
    abort ();
  if (!rtx_equal_p (SET_DEST (set), desc->var))
    abort ();

  set_src = find_reg_equal_equiv_note (mod_insn);
  if (!set_src)
    set_src = SET_SRC (set);
  if (GET_CODE (set_src) != PLUS)
    return NULL;
  if (!rtx_equal_p (XEXP (set_src, 0), desc->var))
    return NULL;

  /* Set desc->stride.  */
  set_add = XEXP (set_src, 1);
  if (CONSTANT_P (set_add))
    desc->stride = set_add;
  else
    return NULL;

  return mod_bb;
}

/* Tries to find initial value of VAR in INSN.  This value must be invariant
   wrto INVARIANT_REGS.  If SET_INSN is not NULL, insn in that var is set is
   placed here.  */
static rtx
variable_initial_value (rtx insn, regset invariant_regs, rtx var, rtx *set_insn)
{
  basic_block bb;
  rtx set;

  /* Go back through cfg.  */
  bb = BLOCK_FOR_INSN (insn);
  while (1)
    {
      for (; insn != bb->head; insn = PREV_INSN (insn))
        {
          if (INSN_P (insn))
            note_stores (PATTERN (insn),
                (void (*) (rtx, rtx, void *)) unmark_altered,
                invariant_regs);
          if (modified_between_p (var, PREV_INSN (insn), NEXT_INSN (insn)))
            break;
        }

      if (insn != bb->head)
        {
          /* We found place where var is set.  */
          rtx set_dest;
          rtx val;
          rtx note;

          set = single_set (insn);
          if (!set)
            return NULL;
          set_dest = SET_DEST (set);
          if (!rtx_equal_p (set_dest, var))
            return NULL;

          note = find_reg_equal_equiv_note (insn);
          if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
            val = XEXP (note, 0);
          else
            val = SET_SRC (set);
          if (!invariant_rtx_wrto_regs_p (val, invariant_regs))
            return NULL;

          if (set_insn)
            *set_insn = insn;
          return val;
        }


      if (bb->pred->pred_next || bb->pred->src == ENTRY_BLOCK_PTR)
        return NULL;

      bb = bb->pred->src;
      insn = bb->end;
    }

  return NULL;
}

/* Returns list of definitions of initial value of VAR at Edge.  */
static rtx
variable_initial_values (edge e, rtx var)
{
  rtx set_insn, list;
  regset invariant_regs;
  regset_head invariant_regs_head;
  int i;

  invariant_regs = INITIALIZE_REG_SET (invariant_regs_head);
  for (i = 0; i < max_reg_num (); i++)
    SET_REGNO_REG_SET (invariant_regs, i);

  list = alloc_EXPR_LIST (0, copy_rtx (var), NULL);

  if (e->src == ENTRY_BLOCK_PTR)
    return list;

  set_insn = e->src->end;
  while (REG_P (var)
         && (var = variable_initial_value (set_insn, invariant_regs, var, &set_insn)))
    list = alloc_EXPR_LIST (0, copy_rtx (var), list);

  FREE_REG_SET (invariant_regs);
  return list;
}

/* Counts constant number of iterations of the loop described by DESC;
   returns false if impossible.  */
static bool
constant_iterations (struct loop_desc *desc, unsigned HOST_WIDE_INT *niter,
                     bool *may_be_zero)
{
  rtx test, expr;
  rtx ainit, alim;

  test = test_for_iteration (desc, 0);
  if (test == const0_rtx)
    {
      *niter = 0;
      *may_be_zero = false;
      return true;
    }

  *may_be_zero = (test != const_true_rtx);

  /* It would make a little sense to check every with every when we
     know that all but the first alternative are simply registers.  */
  for (ainit = desc->var_alts; ainit; ainit = XEXP (ainit, 1))
    {
      alim = XEXP (desc->lim_alts, 0);
      if (!(expr = count_loop_iterations (desc, XEXP (ainit, 0), alim)))
        continue;
      if (GET_CODE (expr) == CONST_INT)
        {
          *niter = INTVAL (expr);
          return true;
        }
    }
  for (alim = XEXP (desc->lim_alts, 1); alim; alim = XEXP (alim, 1))
    {
      ainit = XEXP (desc->var_alts, 0);
      if (!(expr = count_loop_iterations (desc, ainit, XEXP (alim, 0))))
        continue;
      if (GET_CODE (expr) == CONST_INT)
        {
          *niter = INTVAL (expr);
          return true;
        }
    }

  return false;
}

/* Attempts to determine a number of iterations of a "strange" loop.
   Its induction variable starts with value INIT, is compared by COND
   with LIM.  If POSTINCR, it is incremented after the test.  It is incremented
   by STRIDE each iteration and iterates in MODE.

   By "strange" we mean loops where induction variable increases in the wrong
   direction wrto comparison, i.e. for (i = 6; i > 5; i++).  */
static rtx
count_strange_loop_iterations (rtx init, rtx lim, enum rtx_code cond,
                               int postincr, rtx stride, enum machine_mode mode)
{
  rtx rqmt, n_to_wrap, before_wrap, after_wrap;
  rtx mode_min, mode_max;
  int size;

  if (!postincr)
    init = simplify_gen_binary (PLUS, mode, init, stride);

  /* If we are able to prove that we don't pass the first test, we are
     done.  */
  rqmt = simplify_gen_relational (cond, SImode, mode, init, lim);
  if (rqmt == const0_rtx)
    return const0_rtx;

  /* And if we don't know we pass it, the things are too complicated for us.  */
  if (rqmt != const_true_rtx)
    return NULL_RTX;

  switch (cond)
    {
    case GE:
    case GT:
    case LE:
    case LT:
      size = GET_MODE_BITSIZE (mode);
      mode_min = GEN_INT (-((unsigned HOST_WIDEST_INT) 1 << (size - 1)));
      mode_max = GEN_INT (((unsigned HOST_WIDEST_INT) 1 << (size - 1)) - 1);
                              
      break;

    case GEU:
    case GTU:
    case LEU:
    case LTU:
    case EQ:
      mode_min = const0_rtx;
      mode_max = simplify_gen_binary (MINUS, mode, const0_rtx, const1_rtx);
      break;

    default:
      abort ();
    }

  switch (cond)
    {
    case EQ:
      /* This iterates once, as init == lim.  */
      return const1_rtx;

      /* The behavior is undefined in signed cases.  Never mind, we still
         try to behave sanely.  */
    case GE:
    case GT:
    case GEU:
    case GTU:
      if (INTVAL (stride) <= 0)
        abort ();
      n_to_wrap = simplify_gen_binary (MINUS, mode, mode_max, copy_rtx (init));
      n_to_wrap = simplify_gen_binary (UDIV, mode, n_to_wrap, stride);
      before_wrap = simplify_gen_binary (MULT, mode,
                                         copy_rtx (n_to_wrap), stride);
      before_wrap = simplify_gen_binary (PLUS, mode,
                                         before_wrap, copy_rtx (init));
      after_wrap = simplify_gen_binary (PLUS, mode,
                                        before_wrap, stride);
      if (GET_CODE (after_wrap) != CONST_INT)
        {
          after_wrap = simplify_gen_binary (PLUS, mode, mode_min, stride);
          after_wrap = simplify_gen_binary (MINUS, mode, after_wrap, const1_rtx);
        }
      break;

    case LE:
    case LT:
    case LEU:
    case LTU:
      if (INTVAL (stride) >= 0)
        abort ();
      stride = simplify_gen_unary (NEG, mode, stride, mode);
      n_to_wrap = simplify_gen_binary (MINUS, mode, copy_rtx (init), mode_min);
      n_to_wrap = simplify_gen_binary (UDIV, mode, n_to_wrap, stride);
      before_wrap = simplify_gen_binary (MULT, mode,
                                         copy_rtx (n_to_wrap), stride);
      before_wrap = simplify_gen_binary (MINUS, mode,
                                         copy_rtx (init), before_wrap);
      after_wrap = simplify_gen_binary (MINUS, mode,
                                        before_wrap, stride);
      if (GET_CODE (after_wrap) != CONST_INT)
        {
          after_wrap = simplify_gen_binary (MINUS, mode, mode_max, stride);
          after_wrap = simplify_gen_binary (PLUS, mode, after_wrap, const1_rtx);
        }
      break;
    default:
      abort ();
    }

  /* If this is const_true_rtx and we did not take a conservative approximation
     of after_wrap above, we might iterate the calculation (but of course we
     would have to take care about infinite cases).  Ignore this for now.  */
  rqmt = simplify_gen_relational (cond, SImode, mode, after_wrap, lim);
  if (rqmt != const0_rtx)
    return NULL_RTX;

  return simplify_gen_binary (PLUS, mode, n_to_wrap, const1_rtx);
}

/* Return RTX expression representing number of iterations of loop as bounded
   by test described by DESC (in the case loop really has multiple exit
   edges, fewer iterations may happen in the practice).

   Return NULL if it is unknown.  Additionally the value may be invalid for
   paradoxical loop (lets define paradoxical loops as loops whose test is
   failing at -1th iteration, for instance "for (i=5;i<1;i++);").

   These cases needs to be either cared by copying the loop test in the front
   of loop or keeping the test in first iteration of loop.

   When INIT/LIM are set, they are used instead of var/lim of DESC.  */
rtx
count_loop_iterations (struct loop_desc *desc, rtx init, rtx lim)
{
  enum rtx_code cond = desc->cond;
  rtx stride = desc->stride;
  rtx mod, exp;

  /* Give up on floating point modes and friends.  It can be possible to do
     the job for constant loop bounds, but it is probably not worthwhile.  */
  if (!INTEGRAL_MODE_P (GET_MODE (desc->var)))
    return NULL;

  init = copy_rtx (init ? init : desc->var);
  lim = copy_rtx (lim ? lim : desc->lim);

  /* Ensure that we always handle the condition to stay inside loop.  */
  if (desc->neg)
    cond = reverse_condition (cond);

  /* Compute absolute value of the difference of initial and final value.  */
  if (INTVAL (stride) > 0)
    {
      /* Handle strange tests specially.  */
      if (cond == EQ || cond == GE || cond == GT || cond == GEU
          || cond == GTU)
        return count_strange_loop_iterations (init, lim, cond, desc->postincr,
                                              stride, GET_MODE (desc->var));
      exp = simplify_gen_binary (MINUS, GET_MODE (desc->var),
                                 lim, init);
    }
  else
    {
      /* Bypass nonsensical tests.  */
      if (cond == EQ || cond == LE || cond == LT || cond == LEU
          || cond == LTU)
        return count_strange_loop_iterations (init, lim, cond, desc->postincr,
                                              stride, GET_MODE (desc->var));
      exp = simplify_gen_binary (MINUS, GET_MODE (desc->var),
                                 init, lim);
      stride = simplify_gen_unary (NEG, GET_MODE (desc->var),
                                   stride, GET_MODE (desc->var));
    }

  /* Normalize difference so the value is always first examined
     and later incremented.  */

  if (!desc->postincr)
    exp = simplify_gen_binary (MINUS, GET_MODE (desc->var),
                               exp, stride);

  /* Determine delta caused by exit condition.  */
  switch (cond)
    {
    case NE:
      /* For NE tests, make sure that the iteration variable won't miss
         the final value.  If EXP mod STRIDE is not zero, then the
         iteration variable will overflow before the loop exits, and we
         can not calculate the number of iterations easily.  */
      if (stride != const1_rtx
          && (simplify_gen_binary (UMOD, GET_MODE (desc->var), exp, stride)
              != const0_rtx))
        return NULL;
      break;
    case LT:
    case GT:
    case LTU:
    case GTU:
      break;
    case LE:
    case GE:
    case LEU:
    case GEU:
      exp = simplify_gen_binary (PLUS, GET_MODE (desc->var),
                                 exp, const1_rtx);
      break;
    default:
      abort ();
    }

  if (stride != const1_rtx)
    {
      /* Number of iterations is now (EXP + STRIDE - 1 / STRIDE),
         but we need to take care for overflows.  */

      mod = simplify_gen_binary (UMOD, GET_MODE (desc->var), exp, stride);

      /* This is dirty trick.  When we can't compute number of iterations
         to be constant, we simply ignore the possible overflow, as
         runtime unroller always use power of 2 amounts and does not
         care about possible lost bits.  */

      if (GET_CODE (mod) != CONST_INT)
        {
          rtx stridem1 = simplify_gen_binary (PLUS, GET_MODE (desc->var),
                                              stride, constm1_rtx);
          exp = simplify_gen_binary (PLUS, GET_MODE (desc->var),
                                     exp, stridem1);
          exp = simplify_gen_binary (UDIV, GET_MODE (desc->var), exp, stride);
        }
      else
        {
          exp = simplify_gen_binary (UDIV, GET_MODE (desc->var), exp, stride);
          if (mod != const0_rtx)
            exp = simplify_gen_binary (PLUS, GET_MODE (desc->var),
                                       exp, const1_rtx);
        }
    }

  if (rtl_dump_file)
    {
      fprintf (rtl_dump_file, ";  Number of iterations: ");
      print_simple_rtl (rtl_dump_file, exp);
      fprintf (rtl_dump_file, "\n");
    }

  return exp;
}

/* Return simplified RTX expression representing the value of test
   described of DESC at given iteration of loop.  */

static rtx
test_for_iteration (struct loop_desc *desc, unsigned HOST_WIDE_INT iter)
{
  enum rtx_code cond = desc->cond;
  rtx exp = XEXP (desc->var_alts, 0);
  rtx addval;

  /* Give up on floating point modes and friends.  It can be possible to do
     the job for constant loop bounds, but it is probably not worthwhile.  */
  if (!INTEGRAL_MODE_P (GET_MODE (desc->var)))
    return NULL;

  /* Ensure that we always handle the condition to stay inside loop.  */
  if (desc->neg)
    cond = reverse_condition (cond);

  /* Compute the value of induction variable.  */
  addval = simplify_gen_binary (MULT, GET_MODE (desc->var),
                                desc->stride,
                                gen_int_mode (desc->postincr
                                              ? iter : iter + 1,
                                              GET_MODE (desc->var)));
  exp = simplify_gen_binary (PLUS, GET_MODE (desc->var), exp, addval);
  /* Test at given condition.  */
  exp = simplify_gen_relational (cond, SImode,
                                 GET_MODE (desc->var), exp, desc->lim);

  if (rtl_dump_file)
    {
      fprintf (rtl_dump_file, ";  Conditional to continue loop at "
               HOST_WIDE_INT_PRINT_UNSIGNED "th iteration: ", iter);
      print_simple_rtl (rtl_dump_file, exp);
      fprintf (rtl_dump_file, "\n");
    }
  return exp;
}


/* Tests whether exit at EXIT_EDGE from LOOP is simple.  Returns simple loop
   description joined to it in in DESC.  INVARIANT_REGS and SINGLE_SET_REGS
   are results of blocks_{invariant,single_set}_regs over BODY.  */
static bool
simple_loop_exit_p (struct loops *loops, struct loop *loop, edge exit_edge,
                    regset invariant_regs, rtx *single_set_regs,
                    struct loop_desc *desc)
{
  basic_block mod_bb, exit_bb;
  int fallthru_out;
  rtx condition;
  edge ei, e;

  exit_bb = exit_edge->src;

  fallthru_out = (exit_edge->flags & EDGE_FALLTHRU);

  if (!exit_bb)
    return false;

  /* It must be tested (at least) once during any iteration.  */
  if (!dominated_by_p (loops->cfg.dom, loop->latch, exit_bb))
    return false;

  /* It must end in a simple conditional jump.  */
  if (!any_condjump_p (exit_bb->end))
    return false;

  ei = exit_bb->succ;
  if (ei == exit_edge)
    ei = ei->succ_next;

  desc->out_edge = exit_edge;
  desc->in_edge = ei;

  /* Condition must be a simple comparison in that one of operands
     is register and the other one is invariant.  */
  if (!(condition = get_condition (exit_bb->end, NULL)))
    return false;

  if (!simple_condition_p (loop, condition, invariant_regs, desc))
    return false;

  /*  Var must be simply incremented or decremented in exactly one insn that
     is executed just once every iteration.  */
  if (!(mod_bb = simple_increment (loops, loop, single_set_regs, desc)))
    return false;

  /* OK, it is simple loop.  Now just fill in remaining info.  */
  desc->postincr = !dominated_by_p (loops->cfg.dom, exit_bb, mod_bb);
  desc->neg = !fallthru_out;

  /* Find initial value of var and alternative values for lim.  */
  e = loop_preheader_edge (loop);
  desc->var_alts = variable_initial_values (e, desc->var);
  desc->lim_alts = variable_initial_values (e, desc->lim);

  /* Number of iterations.  */
  desc->const_iter =
    constant_iterations (desc, &desc->niter, &desc->may_be_zero);
  if (!desc->const_iter && !count_loop_iterations (desc, NULL, NULL))
    return false;
  return true;
}

/* Tests whether LOOP is simple for loop.  Returns simple loop description
   in DESC.  */
bool
simple_loop_p (struct loops *loops, struct loop *loop, struct loop_desc *desc)
{
  unsigned i;
  basic_block *body;
  edge e;
  struct loop_desc act;
  bool any = false;
  regset invariant_regs;
  regset_head invariant_regs_head;
  rtx *single_set_regs;
  int n_branches;

  body = get_loop_body (loop);

  invariant_regs = INITIALIZE_REG_SET (invariant_regs_head);
  single_set_regs = xmalloc (max_reg_num () * sizeof (rtx));

  blocks_invariant_registers (body, loop->num_nodes, invariant_regs);
  blocks_single_set_registers (body, loop->num_nodes, single_set_regs);

  n_branches = 0;
  for (i = 0; i < loop->num_nodes; i++)
    {
      for (e = body[i]->succ; e; e = e->succ_next)
        if (!flow_bb_inside_loop_p (loop, e->dest)
            && simple_loop_exit_p (loops, loop, e,
                   invariant_regs, single_set_regs, &act))
          {
            /* Prefer constant iterations; the less the better.  */
            if (!any)
              any = true;
            else if (!act.const_iter
                     || (desc->const_iter && act.niter >= desc->niter))
              continue;
            *desc = act;
          }

      if (body[i]->succ && body[i]->succ->succ_next)
        n_branches++;
    }
  desc->n_branches = n_branches;

  if (rtl_dump_file && any)
    {
      fprintf (rtl_dump_file, "; Simple loop %i\n", loop->num);
      if (desc->postincr)
        fprintf (rtl_dump_file,
                 ";  does postincrement after loop exit condition\n");

      fprintf (rtl_dump_file, ";  Induction variable:");
      print_simple_rtl (rtl_dump_file, desc->var);
      fputc ('\n', rtl_dump_file);

      fprintf (rtl_dump_file, ";  Initial values:");
      print_simple_rtl (rtl_dump_file, desc->var_alts);
      fputc ('\n', rtl_dump_file);

      fprintf (rtl_dump_file, ";  Stride:");
      print_simple_rtl (rtl_dump_file, desc->stride);
      fputc ('\n', rtl_dump_file);

      fprintf (rtl_dump_file, ";  Compared with:");
      print_simple_rtl (rtl_dump_file, desc->lim);
      fputc ('\n', rtl_dump_file);

      fprintf (rtl_dump_file, ";  Alternative values:");
      print_simple_rtl (rtl_dump_file, desc->lim_alts);
      fputc ('\n', rtl_dump_file);

      fprintf (rtl_dump_file, ";  Exit condition:");
      if (desc->neg)
        fprintf (rtl_dump_file, "(negated)");
      fprintf (rtl_dump_file, "%s\n", GET_RTX_NAME (desc->cond));

      fprintf (rtl_dump_file, ";  Number of branches:");
      fprintf (rtl_dump_file, "%d\n", desc->n_branches);

      fputc ('\n', rtl_dump_file);
    }

  free (body);
  FREE_REG_SET (invariant_regs);
  free (single_set_regs);
  return any;
}

/* Marks blocks and edges that are part of non-recognized loops; i.e. we
   throw away all latch edges and mark blocks inside any remaining cycle.
   Everything is a bit complicated due to fact we do not want to do this
   for parts of cycles that only "pass" through some loop -- i.e. for
   each cycle, we want to mark blocks that belong directly to innermost
   loop containing the whole cycle.  */
void
mark_irreducible_loops (struct loops *loops)
{
  int *dfs_in, *closed, *mr, *mri, *n_edges, *stack;
  unsigned i;
  edge **edges, e;
  edge *estack;
  basic_block act;
  int stack_top, tick, depth;
  struct loop *cloop;

  /* Reset the flags.  */
  FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
    {
      act->flags &= ~BB_IRREDUCIBLE_LOOP;
      for (e = act->succ; e; e = e->succ_next)
        e->flags &= ~EDGE_IRREDUCIBLE_LOOP;
    }

  /* The first last_basic_block + 1 entries are for real blocks (including
     entry); then we have loops->num - 1 fake blocks for loops to that we
     assign edges leading from loops (fake loop 0 is not interesting).  */
  dfs_in = xmalloc ((last_basic_block + loops->num) * sizeof (int));
  closed = xmalloc ((last_basic_block + loops->num) * sizeof (int));
  mr = xmalloc ((last_basic_block + loops->num) * sizeof (int));
  mri = xmalloc ((last_basic_block + loops->num) * sizeof (int));
  n_edges = xmalloc ((last_basic_block + loops->num) * sizeof (int));
  edges = xmalloc ((last_basic_block + loops->num) * sizeof (edge *));
  stack = xmalloc ((n_basic_blocks + loops->num) * sizeof (int));
  estack = xmalloc ((n_basic_blocks + loops->num) * sizeof (edge));

  /* Create the edge lists.  */
  for (i = 0; i < last_basic_block + loops->num; i++)
    n_edges[i] = 0;
  FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
    for (e = act->succ; e; e = e->succ_next)
      {
        /* Ignore edges to exit.  */
        if (e->dest == EXIT_BLOCK_PTR)
          continue;
        /* And latch edges.  */
        if (e->dest->loop_father->header == e->dest
            && e->dest->loop_father->latch == act)
          continue;
        /* Edges inside a single loop should be left where they are.  Edges
           to subloop headers should lead to representative of the subloop,
           but from the same place.  */
        if (act->loop_father == e->dest->loop_father
            || act->loop_father == e->dest->loop_father->outer)
          {
            n_edges[act->index + 1]++;
            continue;
          }
        /* Edges exiting loops remain.  They should lead from representative
           of the son of nearest common ancestor of the loops in that
           act lays.  */
        depth = find_common_loop (act->loop_father, e->dest->loop_father)->depth + 1;
        if (depth == act->loop_father->depth)
          cloop = act->loop_father;
        else
          cloop = act->loop_father->pred[depth];
        n_edges[cloop->num + last_basic_block]++;
      }

  for (i = 0; i < last_basic_block + loops->num; i++)
    {
      edges[i] = xmalloc (n_edges[i] * sizeof (edge));
      n_edges[i] = 0;
    }

  FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
    for (e = act->succ; e; e = e->succ_next)
      {
        if (e->dest == EXIT_BLOCK_PTR)
          continue;
        if (e->dest->loop_father->header == e->dest
            && e->dest->loop_father->latch == act)
          continue;
        if (act->loop_father == e->dest->loop_father
            || act->loop_father == e->dest->loop_father->outer)
          {
            edges[act->index + 1][n_edges[act->index + 1]++] = e;
            continue;
          }
        depth = find_common_loop (act->loop_father, e->dest->loop_father)->depth + 1;
        if (depth == act->loop_father->depth)
          cloop = act->loop_father;
        else
          cloop = act->loop_father->pred[depth];
        i = cloop->num + last_basic_block;
        edges[i][n_edges[i]++] = e;
      }

  /* Compute dfs numbering, starting from loop headers, and mark found
     loops.*/
  tick = 0;
  for (i = 0; i < last_basic_block + loops->num; i++)
    {
      dfs_in[i] = -1;
      closed[i] = 0;
      mr[i] = last_basic_block + loops->num;
      mri[i] = -1;
    }

  stack_top = 0;
  for (i = 0; i < loops->num; i++)
    if (loops->parray[i])
      {
        stack[stack_top] = loops->parray[i]->header->index + 1;
        estack[stack_top] = NULL;
        stack_top++;
      }

  while (stack_top)
    {
      int idx, sidx;

      idx = stack[stack_top - 1];
      if (dfs_in[idx] < 0)
        dfs_in[idx] = tick++;

      while (n_edges[idx])
        {
          e = edges[idx][--n_edges[idx]];
          sidx = e->dest->loop_father->header == e->dest
                   ? e->dest->loop_father->num + last_basic_block
                   : e->dest->index + 1;
          if (closed[sidx])
            {
              if (!closed[mri[sidx]])
                {
                  if (mr[sidx] < mr[idx])
                    {
                      mr[idx] = mr[sidx];
                      mri[idx] = mri[sidx];
                    }

                  if (mr[sidx] <= dfs_in[idx])
                    e->flags |= EDGE_IRREDUCIBLE_LOOP;
                }
              continue;
            }
          if (dfs_in[sidx] < 0)
            {
              stack[stack_top] = sidx;
              estack[stack_top] = e;
              stack_top++;
              goto next;
            }
          if (dfs_in[sidx] < mr[idx])
            {
              mr[idx] = dfs_in[sidx];
              mri[idx] = sidx;
            }
          e->flags |= EDGE_IRREDUCIBLE_LOOP;
        }

      /* Return back.  */
      closed[idx] = 1;
      e = estack[stack_top - 1];
      stack_top--;
      if (e)
        {
          /* Propagate information back.  */
          sidx = stack[stack_top - 1];
          if (mr[sidx] > mr[idx])
            {
              mr[sidx] = mr[idx];
              mri[sidx] = mri[idx];
            }
          if (mr[idx] <= dfs_in[sidx])
            e->flags |= EDGE_IRREDUCIBLE_LOOP;
        }
      /* Mark the block if relevant.  */
      if (idx && idx <= last_basic_block && mr[idx] <= dfs_in[idx])
        BASIC_BLOCK (idx - 1)->flags |= BB_IRREDUCIBLE_LOOP;
next:;
    }

  free (stack);
  free (estack);
  free (dfs_in);
  free (closed);
  free (mr);
  free (mri);
  for (i = 0; i < last_basic_block + loops->num; i++)
    free (edges[i]);
  free (edges);
  free (n_edges);
  loops->state |= LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS;
}

/* Counts number of insns inside LOOP.  */
int
num_loop_insns (struct loop *loop)
{
  basic_block *bbs, bb;
  unsigned i, ninsns = 0;
  rtx insn;

  bbs = get_loop_body (loop);
  for (i = 0; i < loop->num_nodes; i++)
    {
      bb = bbs[i];
      ninsns++;
      for (insn = bb->head; insn != bb->end; insn = NEXT_INSN (insn))
        if (INSN_P (insn))
          ninsns++;
    }
  free(bbs);

  return ninsns;
}

/* Counts number of insns executed on average per iteration LOOP.  */
int
average_num_loop_insns (struct loop *loop)
{
  basic_block *bbs, bb;
  unsigned i, binsns, ninsns, ratio;
  rtx insn;

  ninsns = 0;
  bbs = get_loop_body (loop);
  for (i = 0; i < loop->num_nodes; i++)
    {
      bb = bbs[i];

      binsns = 1;
      for (insn = bb->head; insn != bb->end; insn = NEXT_INSN (insn))
        if (INSN_P (insn))
          binsns++;

      ratio = loop->header->frequency == 0
              ? BB_FREQ_MAX
              : (bb->frequency * BB_FREQ_MAX) / loop->header->frequency;
      ninsns += binsns * ratio;
    }
  free(bbs);

  ninsns /= BB_FREQ_MAX;
  if (!ninsns)
    ninsns = 1; /* To avoid division by zero.  */

  return ninsns;
}

/* Returns expected number of LOOP iterations.
   Compute upper bound on number of iterations in case they do not fit integer
   to help loop peeling heuristics.  Use exact counts if at all possible.  */
unsigned
expected_loop_iterations (const struct loop *loop)
{
  edge e;

  if (loop->header->count)
    {
      gcov_type count_in, count_latch, expected;

      count_in = 0;
      count_latch = 0;

      for (e = loop->header->pred; e; e = e->pred_next)
        if (e->src == loop->latch)
          count_latch = e->count;
        else
          count_in += e->count;

      if (count_in == 0)
        return 0;

      expected = (count_latch + count_in - 1) / count_in;

      /* Avoid overflows.  */
      return (expected > REG_BR_PROB_BASE ? REG_BR_PROB_BASE : expected);
    }
  else
    {
      int freq_in, freq_latch;

      freq_in = 0;
      freq_latch = 0;

      for (e = loop->header->pred; e; e = e->pred_next)
        if (e->src == loop->latch)
          freq_latch = EDGE_FREQUENCY (e);
        else
          freq_in += EDGE_FREQUENCY (e);

      if (freq_in == 0)
        return 0;

      return (freq_latch + freq_in - 1) / freq_in;
    }
}