Subversion Repositories scarts

/* Loop manipulation code for GNU compiler.

   Copyright (C) 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "hard-reg-set.h"

#include "obstack.h"

#include "basic-block.h"

#include "cfgloop.h"

#include "cfglayout.h"

#include "cfghooks.h"

#include "output.h"

static void duplicate_subloops (struct loops *, struct loop *, struct loop *);

static void copy_loops_to (struct loops *, struct loop **, int,

                           struct loop *);

static void loop_redirect_edge (edge, basic_block);

static bool loop_delete_branch_edge (edge, int);

static void remove_bbs (basic_block *, int);

static bool rpe_enum_p (basic_block, void *);

static int find_path (edge, basic_block **);

static bool alp_enum_p (basic_block, void *);

static void add_loop (struct loops *, struct loop *);

static void fix_loop_placements (struct loops *, struct loop *);

static bool fix_bb_placement (struct loops *, basic_block);

static void fix_bb_placements (struct loops *, basic_block);

static void place_new_loop (struct loops *, struct loop *);

static void scale_loop_frequencies (struct loop *, int, int);

static basic_block create_preheader (struct loop *, int);

static void fix_irreducible_loops (basic_block);

static void unloop (struct loops *, struct loop *);

#define RDIV(X,Y) (((X) + (Y) / 2) / (Y))

/* Splits basic block BB after INSN, returns created edge.  Updates loops

   and dominators.  */

edge

split_loop_bb (basic_block bb, void *insn)

{

  edge e;

  /* Split the block.  */

  e = split_block (bb, insn);

  /* Add dest to loop.  */

  add_bb_to_loop (e->dest, e->src->loop_father);

  return e;

}

/* Checks whether basic block BB is dominated by DATA.  */

static bool

rpe_enum_p (basic_block bb, void *data)

{

  return dominated_by_p (CDI_DOMINATORS, bb, data);

}

/* Remove basic blocks BBS from loop structure and dominance info,

   and delete them afterwards.  */

static void

remove_bbs (basic_block *bbs, int nbbs)

{

  int i;

  for (i = 0; i < nbbs; i++)

    {

      remove_bb_from_loops (bbs[i]);

      delete_basic_block (bbs[i]);

    }

}

/* Find path -- i.e. the basic blocks dominated by edge E and put them

   into array BBS, that will be allocated large enough to contain them.

   E->dest must have exactly one predecessor for this to work (it is

   easy to achieve and we do not put it here because we do not want to

   alter anything by this function).  The number of basic blocks in the

   path is returned.  */

static int

find_path (edge e, basic_block **bbs)

{

  gcc_assert (EDGE_COUNT (e->dest->preds) <= 1);

  /* Find bbs in the path.  */

  *bbs = xcalloc (n_basic_blocks, sizeof (basic_block));

  return dfs_enumerate_from (e->dest, 0, rpe_enum_p, *bbs,

                             n_basic_blocks, e->dest);

}

/* Fix placement of basic block BB inside loop hierarchy stored in LOOPS --

   Let L be a loop to that BB belongs.  Then every successor of BB must either

     1) belong to some superloop of loop L, or

     2) be a header of loop K such that K->outer is superloop of L

   Returns true if we had to move BB into other loop to enforce this condition,

   false if the placement of BB was already correct (provided that placements

   of its successors are correct).  */

static bool

fix_bb_placement (struct loops *loops, basic_block bb)

{

  edge e;

  edge_iterator ei;

  struct loop *loop = loops->tree_root, *act;

  FOR_EACH_EDGE (e, ei, bb->succs)

    {

      if (e->dest == EXIT_BLOCK_PTR)

        continue;

      act = e->dest->loop_father;

      if (act->header == e->dest)

        act = act->outer;

      if (flow_loop_nested_p (loop, act))

        loop = act;

    }

  if (loop == bb->loop_father)

    return false;

  remove_bb_from_loops (bb);

  add_bb_to_loop (bb, loop);

  return true;

}

/* Fix placements of basic blocks inside loop hierarchy stored in loops; i.e.

   enforce condition condition stated in description of fix_bb_placement. We

   start from basic block FROM that had some of its successors removed, so that

   his placement no longer has to be correct, and iteratively fix placement of

   its predecessors that may change if placement of FROM changed.  Also fix

   placement of subloops of FROM->loop_father, that might also be altered due

   to this change; the condition for them is similar, except that instead of

   successors we consider edges coming out of the loops.  */

static void

fix_bb_placements (struct loops *loops, basic_block from)

{

  sbitmap in_queue;

  basic_block *queue, *qtop, *qbeg, *qend;

  struct loop *base_loop;

  edge e;

  /* We pass through blocks back-reachable from FROM, testing whether some

     of their successors moved to outer loop.  It may be necessary to

     iterate several times, but it is finite, as we stop unless we move

     the basic block up the loop structure.  The whole story is a bit

     more complicated due to presence of subloops, those are moved using

     fix_loop_placement.  */

  base_loop = from->loop_father;

  if (base_loop == loops->tree_root)

    return;

  in_queue = sbitmap_alloc (last_basic_block);

  sbitmap_zero (in_queue);

  SET_BIT (in_queue, from->index);

  /* Prevent us from going out of the base_loop.  */

  SET_BIT (in_queue, base_loop->header->index);

  queue = xmalloc ((base_loop->num_nodes + 1) * sizeof (basic_block));

  qtop = queue + base_loop->num_nodes + 1;

  qbeg = queue;

  qend = queue + 1;

  *qbeg = from;

  while (qbeg != qend)

    {

      edge_iterator ei;

      from = *qbeg;

      qbeg++;

      if (qbeg == qtop)

        qbeg = queue;

      RESET_BIT (in_queue, from->index);

      if (from->loop_father->header == from)

        {

          /* Subloop header, maybe move the loop upward.  */

          if (!fix_loop_placement (from->loop_father))

            continue;

        }

      else

        {

          /* Ordinary basic block.  */

          if (!fix_bb_placement (loops, from))

            continue;

        }

      /* Something has changed, insert predecessors into queue.  */

      FOR_EACH_EDGE (e, ei, from->preds)

        {

          basic_block pred = e->src;

          struct loop *nca;

          if (TEST_BIT (in_queue, pred->index))

            continue;

          /* If it is subloop, then it either was not moved, or

             the path up the loop tree from base_loop do not contain

             it.  */

          nca = find_common_loop (pred->loop_father, base_loop);

          if (pred->loop_father != base_loop

              && (nca == base_loop

                  || nca != pred->loop_father))

            pred = pred->loop_father->header;

          else if (!flow_loop_nested_p (from->loop_father, pred->loop_father))

            {

              /* No point in processing it.  */

              continue;

            }

          if (TEST_BIT (in_queue, pred->index))

            continue;

          /* Schedule the basic block.  */

          *qend = pred;

          qend++;

          if (qend == qtop)

            qend = queue;

          SET_BIT (in_queue, pred->index);

        }

    }

  free (in_queue);

  free (queue);

}

/* Basic block from has lost one or more of its predecessors, so it might

   mo longer be part irreducible loop.  Fix it and proceed recursively

   for its successors if needed.  */

static void

fix_irreducible_loops (basic_block from)

{

  basic_block bb;

  basic_block *stack;

  int stack_top;

  sbitmap on_stack;

  edge *edges, e;

  unsigned num_edges, i;

  if (!(from->flags & BB_IRREDUCIBLE_LOOP))

    return;

  on_stack = sbitmap_alloc (last_basic_block);

  sbitmap_zero (on_stack);

  SET_BIT (on_stack, from->index);

  stack = xmalloc (from->loop_father->num_nodes * sizeof (basic_block));

  stack[0] = from;

  stack_top = 1;

  while (stack_top)

    {

      edge_iterator ei;

      bb = stack[--stack_top];

      RESET_BIT (on_stack, bb->index);

      FOR_EACH_EDGE (e, ei, bb->preds)

        if (e->flags & EDGE_IRREDUCIBLE_LOOP)

          break;

      if (e)

        continue;

      bb->flags &= ~BB_IRREDUCIBLE_LOOP;

      if (bb->loop_father->header == bb)

        edges = get_loop_exit_edges (bb->loop_father, &num_edges);

      else

        {

          num_edges = EDGE_COUNT (bb->succs);

          edges = xmalloc (num_edges * sizeof (edge));

          FOR_EACH_EDGE (e, ei, bb->succs)

            edges[ei.index] = e;

        }

      for (i = 0; i < num_edges; i++)

        {

          e = edges[i];

          if (e->flags & EDGE_IRREDUCIBLE_LOOP)

            {

              if (!flow_bb_inside_loop_p (from->loop_father, e->dest))

                continue;

              e->flags &= ~EDGE_IRREDUCIBLE_LOOP;

              if (TEST_BIT (on_stack, e->dest->index))

                continue;

              SET_BIT (on_stack, e->dest->index);

              stack[stack_top++] = e->dest;

            }

        }

      free (edges);

    }

  free (on_stack);

  free (stack);

}

/* Removes path beginning at edge E, i.e. remove basic blocks dominated by E

   and update loop structure stored in LOOPS and dominators.  Return true if

   we were able to remove the path, false otherwise (and nothing is affected

   then).  */

bool

remove_path (struct loops *loops, edge e)

{

  edge ae;

  basic_block *rem_bbs, *bord_bbs, *dom_bbs, from, bb;

  int i, nrem, n_bord_bbs, n_dom_bbs;

  sbitmap seen;

  bool deleted;

  if (!loop_delete_branch_edge (e, 0))

    return false;

  /* We need to check whether basic blocks are dominated by the edge

     e, but we only have basic block dominators.  This is easy to

     fix -- when e->dest has exactly one predecessor, this corresponds

     to blocks dominated by e->dest, if not, split the edge.  */

  if (!single_pred_p (e->dest))

    e = single_pred_edge (loop_split_edge_with (e, NULL_RTX));

  /* It may happen that by removing path we remove one or more loops

     we belong to.  In this case first unloop the loops, then proceed

     normally.   We may assume that e->dest is not a header of any loop,

     as it now has exactly one predecessor.  */

  while (e->src->loop_father->outer

         && dominated_by_p (CDI_DOMINATORS,

                            e->src->loop_father->latch, e->dest))

    unloop (loops, e->src->loop_father);

  /* Identify the path.  */

  nrem = find_path (e, &rem_bbs);

  n_bord_bbs = 0;

  bord_bbs = xcalloc (n_basic_blocks, sizeof (basic_block));

  seen = sbitmap_alloc (last_basic_block);

  sbitmap_zero (seen);

  /* Find "border" hexes -- i.e. those with predecessor in removed path.  */

  for (i = 0; i < nrem; i++)

    SET_BIT (seen, rem_bbs[i]->index);

  for (i = 0; i < nrem; i++)

    {

      edge_iterator ei;

      bb = rem_bbs[i];

      FOR_EACH_EDGE (ae, ei, rem_bbs[i]->succs)

        if (ae->dest != EXIT_BLOCK_PTR && !TEST_BIT (seen, ae->dest->index))

          {

            SET_BIT (seen, ae->dest->index);

            bord_bbs[n_bord_bbs++] = ae->dest;

          }

    }

  /* Remove the path.  */

  from = e->src;

  deleted = loop_delete_branch_edge (e, 1);

  gcc_assert (deleted);

  dom_bbs = xcalloc (n_basic_blocks, sizeof (basic_block));

  /* Cancel loops contained in the path.  */

  for (i = 0; i < nrem; i++)

    if (rem_bbs[i]->loop_father->header == rem_bbs[i])

      cancel_loop_tree (loops, rem_bbs[i]->loop_father);

  remove_bbs (rem_bbs, nrem);

  free (rem_bbs);

  /* Find blocks whose dominators may be affected.  */

  n_dom_bbs = 0;

  sbitmap_zero (seen);

  for (i = 0; i < n_bord_bbs; i++)

    {

      basic_block ldom;

      bb = get_immediate_dominator (CDI_DOMINATORS, bord_bbs[i]);

      if (TEST_BIT (seen, bb->index))

        continue;

      SET_BIT (seen, bb->index);

      for (ldom = first_dom_son (CDI_DOMINATORS, bb);

           ldom;

           ldom = next_dom_son (CDI_DOMINATORS, ldom))

        if (!dominated_by_p (CDI_DOMINATORS, from, ldom))

          dom_bbs[n_dom_bbs++] = ldom;

    }

  free (seen);

  /* Recount dominators.  */

  iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, n_dom_bbs);

  free (dom_bbs);

  /* These blocks have lost some predecessor(s), thus their irreducible

     status could be changed.  */

  for (i = 0; i < n_bord_bbs; i++)

    fix_irreducible_loops (bord_bbs[i]);

  free (bord_bbs);

  /* Fix placements of basic blocks inside loops and the placement of

     loops in the loop tree.  */

  fix_bb_placements (loops, from);

  fix_loop_placements (loops, from->loop_father);

  return true;

}

/* Predicate for enumeration in add_loop.  */

static bool

alp_enum_p (basic_block bb, void *alp_header)

{

  return bb != (basic_block) alp_header;

}

/* Given LOOP structure with filled header and latch, find the body of the

   corresponding loop and add it to LOOPS tree.  */

static void

add_loop (struct loops *loops, struct loop *loop)

{

  basic_block *bbs;

  int i, n;

  /* Add it to loop structure.  */

  place_new_loop (loops, loop);

  loop->level = 1;

  /* Find its nodes.  */

  bbs = xcalloc (n_basic_blocks, sizeof (basic_block));

  n = dfs_enumerate_from (loop->latch, 1, alp_enum_p,

                          bbs, n_basic_blocks, loop->header);

  for (i = 0; i < n; i++)

    add_bb_to_loop (bbs[i], loop);

  add_bb_to_loop (loop->header, loop);

  free (bbs);

}

/* Multiply all frequencies in LOOP by NUM/DEN.  */

static void

scale_loop_frequencies (struct loop *loop, int num, int den)

{

  basic_block *bbs;

  bbs = get_loop_body (loop);

  scale_bbs_frequencies_int (bbs, loop->num_nodes, num, den);

  free (bbs);

}

/* Make area between HEADER_EDGE and LATCH_EDGE a loop by connecting

   latch to header and update loop tree stored in LOOPS and dominators

   accordingly. Everything between them plus LATCH_EDGE destination must

   be dominated by HEADER_EDGE destination, and back-reachable from

   LATCH_EDGE source.  HEADER_EDGE is redirected to basic block SWITCH_BB,

   FALSE_EDGE of SWITCH_BB to original destination of HEADER_EDGE and

   TRUE_EDGE of SWITCH_BB to original destination of LATCH_EDGE.

   Returns newly created loop.  */

struct loop *

loopify (struct loops *loops, edge latch_edge, edge header_edge,

         basic_block switch_bb, edge true_edge, edge false_edge,

         bool redirect_all_edges)

{

  basic_block succ_bb = latch_edge->dest;

  basic_block pred_bb = header_edge->src;

  basic_block *dom_bbs, *body;

  unsigned n_dom_bbs, i;

  sbitmap seen;

  struct loop *loop = xcalloc (1, sizeof (struct loop));

  struct loop *outer = succ_bb->loop_father->outer;

  int freq, prob, tot_prob;

  gcov_type cnt;

  edge e;

  edge_iterator ei;

  loop->header = header_edge->dest;

  loop->latch = latch_edge->src;

  freq = EDGE_FREQUENCY (header_edge);

  cnt = header_edge->count;

  prob = EDGE_SUCC (switch_bb, 0)->probability;

  tot_prob = prob + EDGE_SUCC (switch_bb, 1)->probability;

  if (tot_prob == 0)

    tot_prob = 1;

  /* Redirect edges.  */

  loop_redirect_edge (latch_edge, loop->header);

  loop_redirect_edge (true_edge, succ_bb);

  /* During loop versioning, one of the switch_bb edge is already properly

     set. Do not redirect it again unless redirect_all_edges is true.  */

  if (redirect_all_edges)

    {

      loop_redirect_edge (header_edge, switch_bb);

      loop_redirect_edge (false_edge, loop->header);

      /* Update dominators.  */

      set_immediate_dominator (CDI_DOMINATORS, switch_bb, pred_bb);

      set_immediate_dominator (CDI_DOMINATORS, loop->header, switch_bb);

    }

  set_immediate_dominator (CDI_DOMINATORS, succ_bb, switch_bb);

  /* Compute new loop.  */

  add_loop (loops, loop);

  flow_loop_tree_node_add (outer, loop);

  /* Add switch_bb to appropriate loop.  */

  add_bb_to_loop (switch_bb, outer);

  /* Fix frequencies.  */

  switch_bb->frequency = freq;

  switch_bb->count = cnt;

  FOR_EACH_EDGE (e, ei, switch_bb->succs)

    e->count = (switch_bb->count * e->probability) / REG_BR_PROB_BASE;

  scale_loop_frequencies (loop, prob, tot_prob);

  scale_loop_frequencies (succ_bb->loop_father, tot_prob - prob, tot_prob);

  /* Update dominators of blocks outside of LOOP.  */

  dom_bbs = xcalloc (n_basic_blocks, sizeof (basic_block));

  n_dom_bbs = 0;

  seen = sbitmap_alloc (last_basic_block);

  sbitmap_zero (seen);

  body = get_loop_body (loop);

  for (i = 0; i < loop->num_nodes; i++)

    SET_BIT (seen, body[i]->index);

  for (i = 0; i < loop->num_nodes; i++)

    {

      basic_block ldom;

      for (ldom = first_dom_son (CDI_DOMINATORS, body[i]);

           ldom;

           ldom = next_dom_son (CDI_DOMINATORS, ldom))

        if (!TEST_BIT (seen, ldom->index))

          {

            SET_BIT (seen, ldom->index);

            dom_bbs[n_dom_bbs++] = ldom;

          }

    }

  iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, n_dom_bbs);

  free (body);

  free (seen);

  free (dom_bbs);

  return loop;

}

/* Remove the latch edge of a LOOP and update LOOPS tree to indicate that

   the LOOP was removed.  After this function, original loop latch will

   have no successor, which caller is expected to fix somehow.  */

static void

unloop (struct loops *loops, struct loop *loop)

{

  basic_block *body;

  struct loop *ploop;

  unsigned i, n;

  basic_block latch = loop->latch;

  edge *edges;

  unsigned num_edges;

  /* This is relatively straightforward.  The dominators are unchanged, as

     loop header dominates loop latch, so the only thing we have to care of

     is the placement of loops and basic blocks inside the loop tree.  We

     move them all to the loop->outer, and then let fix_bb_placements do

     its work.  */

  body = get_loop_body (loop);

  edges = get_loop_exit_edges (loop, &num_edges);

  n = loop->num_nodes;

  for (i = 0; i < n; i++)

    if (body[i]->loop_father == loop)

      {

        remove_bb_from_loops (body[i]);

        add_bb_to_loop (body[i], loop->outer);

      }

  free(body);

  while (loop->inner)

    {

      ploop = loop->inner;

      flow_loop_tree_node_remove (ploop);

      flow_loop_tree_node_add (loop->outer, ploop);

    }

  /* Remove the loop and free its data.  */

  flow_loop_tree_node_remove (loop);

  loops->parray[loop->num] = NULL;

  flow_loop_free (loop);

  remove_edge (single_succ_edge (latch));

  fix_bb_placements (loops, latch);

  /* If the loop was inside an irreducible region, we would have to somehow

     update the irreducible marks inside its body.  While it is certainly

     possible to do, it is a bit complicated and this situation should be

     very rare, so we just remark all loops in this case.  */

  for (i = 0; i < num_edges; i++)

    if (edges[i]->flags & EDGE_IRREDUCIBLE_LOOP)

      break;

  if (i != num_edges)

    mark_irreducible_loops (loops);

  free (edges);

}

/* Fix placement of LOOP inside loop tree, i.e. find the innermost superloop

   FATHER of LOOP such that all of the edges coming out of LOOP belong to

   FATHER, and set it as outer loop of LOOP.  Return 1 if placement of

   LOOP changed.  */

int

fix_loop_placement (struct loop *loop)

{

  basic_block *body;

  unsigned i;

  edge e;

  edge_iterator ei;

  struct loop *father = loop->pred[0], *act;

  body = get_loop_body (loop);

  for (i = 0; i < loop->num_nodes; i++)

    FOR_EACH_EDGE (e, ei, body[i]->succs)

      if (!flow_bb_inside_loop_p (loop, e->dest))

        {

          act = find_common_loop (loop, e->dest->loop_father);

          if (flow_loop_nested_p (father, act))

            father = act;

        }

  free (body);

  if (father != loop->outer)

    {

      for (act = loop->outer; act != father; act = act->outer)

        act->num_nodes -= loop->num_nodes;

      flow_loop_tree_node_remove (loop);

      flow_loop_tree_node_add (father, loop);

      return 1;

    }

  return 0;

}

/* Fix placement of superloops of LOOP inside loop tree, i.e. ensure that

   condition stated in description of fix_loop_placement holds for them.

   It is used in case when we removed some edges coming out of LOOP, which

   may cause the right placement of LOOP inside loop tree to change.  */

static void

fix_loop_placements (struct loops *loops, struct loop *loop)

{

  struct loop *outer;

  while (loop->outer)

    {

      outer = loop->outer;

      if (!fix_loop_placement (loop))

        break;

      /* Changing the placement of a loop in the loop tree may alter the

         validity of condition 2) of the description of fix_bb_placement

         for its preheader, because the successor is the header and belongs

         to the loop.  So call fix_bb_placements to fix up the placement

         of the preheader and (possibly) of its predecessors.  */

      fix_bb_placements (loops, loop_preheader_edge (loop)->src);

      loop = outer;

    }

}

/* Creates place for a new LOOP in LOOPS structure.  */

static void

place_new_loop (struct loops *loops, struct loop *loop)