* config/alpha/alpha.c (alpha_sa_size): Force procedure type to

[pf3gnuchains/gcc-fork.git] / gcc / cfgloop.c

diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
index 6542b3a..b9af098 100644 (file)
--- a/gcc/cfgloop.c
+++ b/gcc/cfgloop.c
@@ -1,12 +1,12 @@
 /* Natural loop discovery code for GNU compiler.
 /* Natural loop discovery code for GNU compiler.

-   Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006, 2007
+   Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008

    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
    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
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -15,9 +15,8 @@ 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
 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.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"


@@ -339,6 +338,7 @@ alloc_loop (void)
 
   loop->exits = GGC_CNEW (struct loop_exit);
   loop->exits->next = loop->exits->prev = loop->exits;
 
   loop->exits = GGC_CNEW (struct loop_exit);
   loop->exits->next = loop->exits->prev = loop->exits;

+  loop->can_be_parallel = false;

 
   return loop;
 }
 
   return loop;
 }


@@ -503,7 +503,6 @@ flow_loops_find (struct loops *loops)
   sbitmap_free (headers);
 
   loops->exits = NULL;
   sbitmap_free (headers);
 
   loops->exits = NULL;

-  loops->state = 0;

   return VEC_length (loop_p, loops->larray);
 }
 
   return VEC_length (loop_p, loops->larray);
 }
 


@@ -565,11 +564,13 @@ find_subloop_latch_edge_by_profile (VEC (edge, heap) *latches)
    another edge.  */
 
 static edge
    another edge.  */
 
 static edge

-find_subloop_latch_edge_by_ivs (struct loop *loop, VEC (edge, heap) *latches)
+find_subloop_latch_edge_by_ivs (struct loop *loop ATTRIBUTE_UNUSED, VEC (edge, heap) *latches)

 {
   edge e, latch = VEC_index (edge, latches, 0);
   unsigned i;
 {
   edge e, latch = VEC_index (edge, latches, 0);
   unsigned i;

-  tree phi, lop;
+  gimple phi;
+  gimple_stmt_iterator psi;
+  tree lop;

   basic_block bb;
 
   /* Find the candidate for the latch edge.  */
   basic_block bb;
 
   /* Find the candidate for the latch edge.  */


@@ -584,15 +585,16 @@ find_subloop_latch_edge_by_ivs (struct loop *loop, VEC (edge, heap) *latches)
 
   /* Check for a phi node that would deny that this is a latch edge of
      a subloop.  */
 
   /* Check for a phi node that would deny that this is a latch edge of
      a subloop.  */

-  for (phi = phi_nodes (loop->header); phi; phi = PHI_CHAIN (phi))
+  for (psi = gsi_start_phis (loop->header); !gsi_end_p (psi); gsi_next (&psi))

     {
     {

+      phi = gsi_stmt (psi);

       lop = PHI_ARG_DEF_FROM_EDGE (phi, latch);
 
       /* Ignore the values that are not changed inside the subloop.  */
       if (TREE_CODE (lop) != SSA_NAME
          || SSA_NAME_DEF_STMT (lop) == phi)
        continue;
       lop = PHI_ARG_DEF_FROM_EDGE (phi, latch);
 
       /* Ignore the values that are not changed inside the subloop.  */
       if (TREE_CODE (lop) != SSA_NAME
          || SSA_NAME_DEF_STMT (lop) == phi)
        continue;

-      bb = bb_for_stmt (SSA_NAME_DEF_STMT (lop));
+      bb = gimple_bb (SSA_NAME_DEF_STMT (lop));

       if (!bb || !flow_bb_inside_loop_p (loop, bb))
        continue;
 
       if (!bb || !flow_bb_inside_loop_p (loop, bb))
        continue;
 


@@ -767,7 +769,7 @@ disambiguate_loops_with_multiple_latches (void)
 
 /* Return nonzero if basic block BB belongs to LOOP.  */
 bool
 
 /* Return nonzero if basic block BB belongs to LOOP.  */
 bool

-flow_bb_inside_loop_p (const struct loop *loop, const basic_block bb)
+flow_bb_inside_loop_p (const struct loop *loop, const_basic_block bb)

 {
   struct loop *source_loop;
 
 {
   struct loop *source_loop;
 


@@ -780,9 +782,9 @@ flow_bb_inside_loop_p (const struct loop *loop, const basic_block bb)
 
 /* Enumeration predicate for get_loop_body_with_size.  */
 static bool
 
 /* Enumeration predicate for get_loop_body_with_size.  */
 static bool

-glb_enum_p (basic_block bb, void *glb_loop)
+glb_enum_p (const_basic_block bb, const void *glb_loop)

 {
 {

-  struct loop *loop = (struct loop *) glb_loop;
+  const struct loop *const loop = (const struct loop *) glb_loop;

   return (bb != loop->header
          && dominated_by_p (CDI_DOMINATORS, bb, loop->header));
 }
   return (bb != loop->header
          && dominated_by_p (CDI_DOMINATORS, bb, loop->header));
 }


@@ -799,7 +801,7 @@ get_loop_body_with_size (const struct loop *loop, basic_block *body,
                         unsigned max_size)
 {
   return dfs_enumerate_from (loop->header, 1, glb_enum_p,
                         unsigned max_size)
 {
   return dfs_enumerate_from (loop->header, 1, glb_enum_p,

-                            body, max_size, (void *) loop);
+                            body, max_size, loop);

 }
 
 /* Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs
 }
 
 /* Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs


@@ -886,6 +888,19 @@ get_loop_body_in_dom_order (const struct loop *loop)
   return tovisit;
 }
 
   return tovisit;
 }
 

+/* Gets body of a LOOP sorted via provided BB_COMPARATOR.  */
+
+basic_block *
+get_loop_body_in_custom_order (const struct loop *loop, 
+                              int (*bb_comparator) (const void *, const void *))
+{
+  basic_block *bbs = get_loop_body (loop);
+
+  qsort (bbs, loop->num_nodes, sizeof (basic_block), bb_comparator);
+
+  return bbs;
+}
+

 /* Get body of a LOOP in breadth first sort order.  */
 
 basic_block *
 /* Get body of a LOOP in breadth first sort order.  */
 
 basic_block *


@@ -942,7 +957,7 @@ get_loop_body_in_bfs_order (const struct loop *loop)
 static hashval_t
 loop_exit_hash (const void *ex)
 {
 static hashval_t
 loop_exit_hash (const void *ex)
 {

-  struct loop_exit *exit = (struct loop_exit *) ex;
+  const struct loop_exit *const exit = (const struct loop_exit *) ex;

 
   return htab_hash_pointer (exit->e);
 }
 
   return htab_hash_pointer (exit->e);
 }


@@ -952,7 +967,7 @@ loop_exit_hash (const void *ex)
 static int
 loop_exit_eq (const void *ex, const void *e)
 {
 static int
 loop_exit_eq (const void *ex, const void *e)
 {

-  struct loop_exit *exit = (struct loop_exit *) ex;
+  const struct loop_exit *const exit = (const struct loop_exit *) ex;

 
   return exit->e == e;
 }
 
   return exit->e == e;
 }


@@ -997,7 +1012,7 @@ rescan_loop_exit (edge e, bool new_edge, bool removed)
   struct loop_exit *exits = NULL, *exit;
   struct loop *aloop, *cloop;
 
   struct loop_exit *exits = NULL, *exit;
   struct loop *aloop, *cloop;
 

-  if ((current_loops->state & LOOPS_HAVE_RECORDED_EXITS) == 0)
+  if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))

     return;
 
   if (!removed
     return;
 
   if (!removed


@@ -1055,9 +1070,9 @@ record_loop_exits (void)
   if (!current_loops)
     return;
 
   if (!current_loops)
     return;
 

-  if (current_loops->state & LOOPS_HAVE_RECORDED_EXITS)
+  if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))

     return;
     return;

-  current_loops->state |= LOOPS_HAVE_RECORDED_EXITS;
+  loops_state_set (LOOPS_HAVE_RECORDED_EXITS);

 
   gcc_assert (current_loops->exits == NULL);
   current_loops->exits = htab_create_alloc (2 * number_of_loops (),
 
   gcc_assert (current_loops->exits == NULL);
   current_loops->exits = htab_create_alloc (2 * number_of_loops (),


@@ -1110,10 +1125,10 @@ dump_recorded_exits (FILE *file)
 void
 release_recorded_exits (void)
 {
 void
 release_recorded_exits (void)
 {

-  gcc_assert (current_loops->state & LOOPS_HAVE_RECORDED_EXITS);
+  gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS));

   htab_delete (current_loops->exits);
   current_loops->exits = NULL;
   htab_delete (current_loops->exits);
   current_loops->exits = NULL;

-  current_loops->state &= ~LOOPS_HAVE_RECORDED_EXITS;
+  loops_state_clear (LOOPS_HAVE_RECORDED_EXITS);

 }
 
 /* Returns the list of the exit edges of a LOOP.  */
 }
 
 /* Returns the list of the exit edges of a LOOP.  */


@@ -1132,7 +1147,7 @@ get_loop_exit_edges (const struct loop *loop)
 
   /* If we maintain the lists of exits, use them.  Otherwise we must
      scan the body of the loop.  */
 
   /* If we maintain the lists of exits, use them.  Otherwise we must
      scan the body of the loop.  */

-  if (current_loops->state & LOOPS_HAVE_RECORDED_EXITS)
+  if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))

     {
       for (exit = loop->exits->next; exit->e; exit = exit->next)
        VEC_safe_push (edge, heap, edges, exit->e);
     {
       for (exit = loop->exits->next; exit->e; exit = exit->next)
        VEC_safe_push (edge, heap, edges, exit->e);


@@ -1353,13 +1368,13 @@ verify_loop_structure (void)
     {
       i = loop->num;
 
     {
       i = loop->num;
 

-      if ((current_loops->state & LOOPS_HAVE_PREHEADERS)
+      if (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS)

          && EDGE_COUNT (loop->header->preds) != 2)
        {
          error ("loop %d's header does not have exactly 2 entries", i);
          err = 1;
        }
          && EDGE_COUNT (loop->header->preds) != 2)
        {
          error ("loop %d's header does not have exactly 2 entries", i);
          err = 1;
        }

-      if (current_loops->state & LOOPS_HAVE_SIMPLE_LATCHES)
+      if (loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES))

        {
          if (!single_succ_p (loop->latch))
            {
        {
          if (!single_succ_p (loop->latch))
            {


@@ -1382,7 +1397,7 @@ verify_loop_structure (void)
          error ("loop %d's header does not belong directly to it", i);
          err = 1;
        }
          error ("loop %d's header does not belong directly to it", i);
          err = 1;
        }

-      if ((current_loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
+      if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)

          && (loop_latch_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP))
        {
          error ("loop %d's latch is marked as part of irreducible region", i);
          && (loop_latch_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP))
        {
          error ("loop %d's latch is marked as part of irreducible region", i);


@@ -1391,7 +1406,7 @@ verify_loop_structure (void)
     }
 
   /* Check irreducible loops.  */
     }
 
   /* Check irreducible loops.  */

-  if (current_loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
+  if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS))

     {
       /* Record old info.  */
       irreds = sbitmap_alloc (last_basic_block);
     {
       /* Record old info.  */
       irreds = sbitmap_alloc (last_basic_block);


@@ -1477,7 +1492,7 @@ verify_loop_structure (void)
            }
        }
 
            }
        }
 

-      if ((current_loops->state & LOOPS_HAVE_RECORDED_EXITS) == 0)
+      if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))

        {
          if (loop->exits->next != loop->exits)
            {
        {
          if (loop->exits->next != loop->exits)
            {


@@ -1488,7 +1503,7 @@ verify_loop_structure (void)
        }
     }
 
        }
     }
 

-  if (current_loops->state & LOOPS_HAVE_RECORDED_EXITS)
+  if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))

     {
       unsigned n_exits = 0, eloops;
 
     {
       unsigned n_exits = 0, eloops;
 


@@ -1571,7 +1586,7 @@ loop_preheader_edge (const struct loop *loop)
   edge e;
   edge_iterator ei;
 
   edge e;
   edge_iterator ei;
 

-  gcc_assert ((current_loops->state & LOOPS_HAVE_PREHEADERS) != 0);
+  gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS));

 
   FOR_EACH_EDGE (e, ei, loop->header->preds)
     if (e->src != loop->latch)
 
   FOR_EACH_EDGE (e, ei, loop->header->preds)
     if (e->src != loop->latch)


@@ -1583,7 +1598,7 @@ loop_preheader_edge (const struct loop *loop)
 /* Returns true if E is an exit of LOOP.  */
 
 bool
 /* Returns true if E is an exit of LOOP.  */
 
 bool

-loop_exit_edge_p (const struct loop *loop, edge e)
+loop_exit_edge_p (const struct loop *loop, const_edge e)

 {
   return (flow_bb_inside_loop_p (loop, e->src)
          && !flow_bb_inside_loop_p (loop, e->dest));
 {
   return (flow_bb_inside_loop_p (loop, e->src)
          && !flow_bb_inside_loop_p (loop, e->dest));


@@ -1598,7 +1613,7 @@ single_exit (const struct loop *loop)
 {
   struct loop_exit *exit = loop->exits->next;
 
 {
   struct loop_exit *exit = loop->exits->next;
 

-  if ((current_loops->state & LOOPS_HAVE_RECORDED_EXITS) == 0)
+  if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))

     return NULL;
 
   if (exit->e && exit->next == loop->exits)
     return NULL;
 
   if (exit->e && exit->next == loop->exits)


@@ -1606,3 +1621,18 @@ single_exit (const struct loop *loop)
   else
     return NULL;
 }
   else
     return NULL;
 }

+
+/* Returns true when BB has an edge exiting LOOP.  */
+
+bool
+is_loop_exit (struct loop *loop, basic_block bb)
+{
+  edge e;
+  edge_iterator ei;
+
+  FOR_EACH_EDGE (e, ei, bb->preds)
+    if (loop_exit_edge_p (loop, e))
+      return true;
+
+  return false;
+}