re PR go/69966 (libgo: Port syscall.SetsockoptUcred from golang)

[gcc.git] / gcc / cfg.c

diff --git a/gcc/cfg.c b/gcc/cfg.c
index af8a377b927aa2f9fc49ee8edace9150108cf969..fdbdee8113f6d9a934d6fa7cd953f410ae1b75d8 100644 (file)
--- a/gcc/cfg.c
+++ b/gcc/cfg.c
@@ -1,13 +1,11 @@
 /* Control flow graph manipulation code for GNU compiler.
 /* Control flow graph manipulation code for GNU compiler.

-   Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002, 2003, 2004, 2005
-   Free Software Foundation, Inc.
+   Copyright (C) 1987-2016 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
 
 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


@@ -16,9 +14,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/>.  */

 
 /* This file contains low level functions to manipulate the CFG and
    analyze it.  All other modules should not transform the data structure
 
 /* This file contains low level functions to manipulate the CFG and
    analyze it.  All other modules should not transform the data structure


@@ -44,86 +41,79 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
         verify_flow_info
      - Dumping and debugging
         print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
         verify_flow_info
      - Dumping and debugging
         print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n

+
+   TODO: Document these "Available functionality" functions in the files
+   that implement them.

  */
 \f
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
  */
 \f
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"

-#include "tm.h"
-#include "tree.h"
-#include "rtl.h"
+#include "backend.h"

 #include "hard-reg-set.h"
 #include "hard-reg-set.h"

-#include "regs.h"
-#include "flags.h"
-#include "output.h"
-#include "function.h"
-#include "except.h"
-#include "toplev.h"
-#include "tm_p.h"
-#include "obstack.h"
-#include "timevar.h"
-#include "ggc.h"
-#include "hashtab.h"
-#include "alloc-pool.h"
-
-/* The obstack on which the flow graph components are allocated.  */
-
-struct bitmap_obstack reg_obstack;
-
-void debug_flow_info (void);
-static void free_edge (edge);
+#include "tree.h"
+#include "cfghooks.h"
+#include "df.h"
+#include "cfganal.h"
+#include "cfgloop.h" /* FIXME: For struct loop.  */
+#include "dumpfile.h"
+

 \f
 #define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
 
 /* Called once at initialization time.  */
 
 void
 \f
 #define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
 
 /* Called once at initialization time.  */
 
 void

-init_flow (void)
+init_flow (struct function *the_fun)

 {
 {

-  if (!cfun->cfg)
-    cfun->cfg = ggc_alloc_cleared (sizeof (struct control_flow_graph));
-  n_edges = 0;
-  ENTRY_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
-  ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
-  EXIT_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
-  EXIT_BLOCK_PTR->index = EXIT_BLOCK;
-  ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
-  EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
+  if (!the_fun->cfg)
+    the_fun->cfg = ggc_cleared_alloc<control_flow_graph> ();
+  n_edges_for_fn (the_fun) = 0;
+  ENTRY_BLOCK_PTR_FOR_FN (the_fun)
+    = ggc_cleared_alloc<basic_block_def> ();
+  ENTRY_BLOCK_PTR_FOR_FN (the_fun)->index = ENTRY_BLOCK;
+  EXIT_BLOCK_PTR_FOR_FN (the_fun)
+    = ggc_cleared_alloc<basic_block_def> ();
+  EXIT_BLOCK_PTR_FOR_FN (the_fun)->index = EXIT_BLOCK;
+  ENTRY_BLOCK_PTR_FOR_FN (the_fun)->next_bb
+    = EXIT_BLOCK_PTR_FOR_FN (the_fun);
+  EXIT_BLOCK_PTR_FOR_FN (the_fun)->prev_bb
+    = ENTRY_BLOCK_PTR_FOR_FN (the_fun);

 }
 \f
 /* Helper function for remove_edge and clear_edges.  Frees edge structure
 }
 \f
 /* Helper function for remove_edge and clear_edges.  Frees edge structure

-   without actually unlinking it from the pred/succ lists.  */
+   without actually removing it from the pred/succ arrays.  */

 
 static void
 
 static void

-free_edge (edge e ATTRIBUTE_UNUSED)
+free_edge (function *fn, edge e)

 {
 {

-  n_edges--;
+  n_edges_for_fn (fn)--;

   ggc_free (e);
 }
 
 /* Free the memory associated with the edge structures.  */
 
 void
   ggc_free (e);
 }
 
 /* Free the memory associated with the edge structures.  */
 
 void

-clear_edges (void)
+clear_edges (struct function *fn)

 {
   basic_block bb;
   edge e;
   edge_iterator ei;
 
 {
   basic_block bb;
   edge e;
   edge_iterator ei;
 

-  FOR_EACH_BB (bb)
+  FOR_EACH_BB_FN (bb, fn)

     {
       FOR_EACH_EDGE (e, ei, bb->succs)
     {
       FOR_EACH_EDGE (e, ei, bb->succs)

-       free_edge (e);
-      VEC_truncate (edge, bb->succs, 0);
-      VEC_truncate (edge, bb->preds, 0);
+       free_edge (fn, e);
+      vec_safe_truncate (bb->succs, 0);
+      vec_safe_truncate (bb->preds, 0);

     }
 
     }
 

-  FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
-    free_edge (e);
-  VEC_truncate (edge, EXIT_BLOCK_PTR->preds, 0);
-  VEC_truncate (edge, ENTRY_BLOCK_PTR->succs, 0);
+  FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fn)->succs)
+    free_edge (fn, e);
+  vec_safe_truncate (EXIT_BLOCK_PTR_FOR_FN (fn)->preds, 0);
+  vec_safe_truncate (ENTRY_BLOCK_PTR_FOR_FN (fn)->succs, 0);

 
 

-  gcc_assert (!n_edges);
+  gcc_assert (!n_edges_for_fn (fn));

 }
 \f
 /* Allocate memory for basic_block.  */
 }
 \f
 /* Allocate memory for basic_block.  */


@@ -132,20 +122,10 @@ basic_block
 alloc_block (void)
 {
   basic_block bb;
 alloc_block (void)
 {
   basic_block bb;

-  bb = ggc_alloc_cleared (sizeof (*bb));
+  bb = ggc_cleared_alloc<basic_block_def> ();

   return bb;
 }
 
   return bb;
 }
 

-/* Initialize rbi (the structure containing data used by basic block
-   duplication and reordering) for the given basic block.  */
-
-void
-initialize_bb_rbi (basic_block bb)
-{
-  gcc_assert (!bb->rbi);
-  bb->rbi = ggc_alloc_cleared (sizeof (struct reorder_block_def));
-}
-

 /* Link block B to chain after AFTER.  */
 void
 link_block (basic_block b, basic_block after)
 /* Link block B to chain after AFTER.  */
 void
 link_block (basic_block b, basic_block after)


@@ -171,22 +151,29 @@ void
 compact_blocks (void)
 {
   int i;
 compact_blocks (void)
 {
   int i;

-  basic_block bb;

 
 

-  i = 0;
-  FOR_EACH_BB (bb)
-    {
-      BASIC_BLOCK (i) = bb;
-      bb->index = i;
-      i++;
-    }
+  SET_BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (cfun));
+  SET_BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (cfun));

 
 

-  gcc_assert (i == n_basic_blocks);
+  if (df)
+    df_compact_blocks ();
+  else
+    {
+      basic_block bb;

 
 

-  for (; i < last_basic_block; i++)
-    BASIC_BLOCK (i) = NULL;
+      i = NUM_FIXED_BLOCKS;
+      FOR_EACH_BB_FN (bb, cfun)
+       {
+         SET_BASIC_BLOCK_FOR_FN (cfun, i, bb);
+         bb->index = i;
+         i++;
+       }
+      gcc_assert (i == n_basic_blocks_for_fn (cfun));

 
 

-  last_basic_block = n_basic_blocks;
+      for (; i < last_basic_block_for_fn (cfun); i++)
+       SET_BASIC_BLOCK_FOR_FN (cfun, i, NULL);
+    }
+  last_basic_block_for_fn (cfun) = n_basic_blocks_for_fn (cfun);

 }
 
 /* Remove block B from the basic block array.  */
 }
 
 /* Remove block B from the basic block array.  */


@@ -195,8 +182,8 @@ void
 expunge_block (basic_block b)
 {
   unlink_block (b);
 expunge_block (basic_block b)
 {
   unlink_block (b);

-  BASIC_BLOCK (b->index) = NULL;
-  n_basic_blocks--;
+  SET_BASIC_BLOCK_FOR_FN (cfun, b->index, NULL);
+  n_basic_blocks_for_fn (cfun)--;

   /* We should be able to ggc_free here, but we are not.
      The dead SSA_NAMES are left pointing to dead statements that are pointing
      to dead basic blocks making garbage collector to die.
   /* We should be able to ggc_free here, but we are not.
      The dead SSA_NAMES are left pointing to dead statements that are pointing
      to dead basic blocks making garbage collector to die.


@@ -209,7 +196,8 @@ expunge_block (basic_block b)
 static inline void
 connect_src (edge e)
 {
 static inline void
 connect_src (edge e)
 {

-  VEC_safe_push (edge, gc, e->src->succs, e);
+  vec_safe_push (e->src->succs, e);
+  df_mark_solutions_dirty ();

 }
 
 /* Connect E to E->dest.  */
 }
 
 /* Connect E to E->dest.  */


@@ -218,8 +206,9 @@ static inline void
 connect_dest (edge e)
 {
   basic_block dest = e->dest;
 connect_dest (edge e)
 {
   basic_block dest = e->dest;

-  VEC_safe_push (edge, gc, dest->preds, e);
+  vec_safe_push (dest->preds, e);

   e->dest_idx = EDGE_COUNT (dest->preds) - 1;
   e->dest_idx = EDGE_COUNT (dest->preds) - 1;

+  df_mark_solutions_dirty ();

 }
 
 /* Disconnect edge E from E->src.  */
 }
 
 /* Disconnect edge E from E->src.  */


@@ -235,7 +224,8 @@ disconnect_src (edge e)
     {
       if (tmp == e)
        {
     {
       if (tmp == e)
        {

-         VEC_unordered_remove (edge, src->succs, ei.index);
+         src->succs->unordered_remove (ei.index);
+         df_mark_solutions_dirty ();

          return;
        }
       else
          return;
        }
       else


@@ -253,12 +243,13 @@ disconnect_dest (edge e)
   basic_block dest = e->dest;
   unsigned int dest_idx = e->dest_idx;
 
   basic_block dest = e->dest;
   unsigned int dest_idx = e->dest_idx;
 

-  VEC_unordered_remove (edge, dest->preds, dest_idx);
+  dest->preds->unordered_remove (dest_idx);

 
   /* If we removed an edge in the middle of the edge vector, we need
      to update dest_idx of the edge that moved into the "hole".  */
   if (dest_idx < EDGE_COUNT (dest->preds))
     EDGE_PRED (dest, dest_idx)->dest_idx = dest_idx;
 
   /* If we removed an edge in the middle of the edge vector, we need
      to update dest_idx of the edge that moved into the "hole".  */
   if (dest_idx < EDGE_COUNT (dest->preds))
     EDGE_PRED (dest, dest_idx)->dest_idx = dest_idx;

+  df_mark_solutions_dirty ();

 }
 
 /* Create an edge connecting SRC and DEST with flags FLAGS.  Return newly
 }
 
 /* Create an edge connecting SRC and DEST with flags FLAGS.  Return newly


@@ -269,8 +260,8 @@ edge
 unchecked_make_edge (basic_block src, basic_block dst, int flags)
 {
   edge e;
 unchecked_make_edge (basic_block src, basic_block dst, int flags)
 {
   edge e;

-  e = ggc_alloc_cleared (sizeof (*e));
-  n_edges++;
+  e = ggc_cleared_alloc<edge_def> ();
+  n_edges_for_fn (cfun)++;

 
   e->src = src;
   e->dest = dst;
 
   e->src = src;
   e->dest = dst;


@@ -280,7 +271,6 @@ unchecked_make_edge (basic_block src, basic_block dst, int flags)
   connect_dest (e);
 
   execute_on_growing_pred (e);
   connect_dest (e);
 
   execute_on_growing_pred (e);

-

   return e;
 }
 
   return e;
 }
 


@@ -291,16 +281,16 @@ edge
 cached_make_edge (sbitmap edge_cache, basic_block src, basic_block dst, int flags)
 {
   if (edge_cache == NULL
 cached_make_edge (sbitmap edge_cache, basic_block src, basic_block dst, int flags)
 {
   if (edge_cache == NULL

-      || src == ENTRY_BLOCK_PTR
-      || dst == EXIT_BLOCK_PTR)
+      || src == ENTRY_BLOCK_PTR_FOR_FN (cfun)
+      || dst == EXIT_BLOCK_PTR_FOR_FN (cfun))

     return make_edge (src, dst, flags);
 
   /* Does the requested edge already exist?  */
     return make_edge (src, dst, flags);
 
   /* Does the requested edge already exist?  */

-  if (! TEST_BIT (edge_cache, dst->index))
+  if (! bitmap_bit_p (edge_cache, dst->index))

     {
       /* The edge does not exist.  Create one and update the
         cache.  */
     {
       /* The edge does not exist.  Create one and update the
         cache.  */

-      SET_BIT (edge_cache, dst->index);
+      bitmap_set_bit (edge_cache, dst->index);

       return unchecked_make_edge (src, dst, flags);
     }
 
       return unchecked_make_edge (src, dst, flags);
     }
 


@@ -349,7 +339,7 @@ make_single_succ_edge (basic_block src, basic_block dest, int flags)
 /* This function will remove an edge from the flow graph.  */
 
 void
 /* This function will remove an edge from the flow graph.  */
 
 void

-remove_edge (edge e)
+remove_edge_raw (edge e)

 {
   remove_predictions_associated_with_edge (e);
   execute_on_shrinking_pred (e);
 {
   remove_predictions_associated_with_edge (e);
   execute_on_shrinking_pred (e);


@@ -357,7 +347,7 @@ remove_edge (edge e)
   disconnect_src (e);
   disconnect_dest (e);
 
   disconnect_src (e);
   disconnect_dest (e);
 

-  free_edge (e);
+  free_edge (cfun, e);

 }
 
 /* Redirect an edge's successor from one block to another.  */
 }
 
 /* Redirect an edge's successor from one block to another.  */


@@ -377,30 +367,6 @@ redirect_edge_succ (edge e, basic_block new_succ)
   execute_on_growing_pred (e);
 }
 
   execute_on_growing_pred (e);
 }
 

-/* Like previous but avoid possible duplicate edge.  */
-
-edge
-redirect_edge_succ_nodup (edge e, basic_block new_succ)
-{
-  edge s;
-
-  s = find_edge (e->src, new_succ);
-  if (s && s != e)
-    {
-      s->flags |= e->flags;
-      s->probability += e->probability;
-      if (s->probability > REG_BR_PROB_BASE)
-       s->probability = REG_BR_PROB_BASE;
-      s->count += e->count;
-      remove_edge (e);
-      e = s;
-    }
-  else
-    redirect_edge_succ (e, new_succ);
-
-  return e;
-}
-

 /* Redirect an edge's predecessor from one block to another.  */
 
 void
 /* Redirect an edge's predecessor from one block to another.  */
 
 void


@@ -414,15 +380,14 @@ redirect_edge_pred (edge e, basic_block new_pred)
   connect_src (e);
 }
 
   connect_src (e);
 }
 

-/* Clear all basic block flags, with the exception of partitioning.  */
+/* Clear all basic block flags that do not have to be preserved.  */

 void
 clear_bb_flags (void)
 {
   basic_block bb;
 
 void
 clear_bb_flags (void)
 {
   basic_block bb;
 

-  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
-    bb->flags = (BB_PARTITION (bb)  | (bb->flags & BB_DISABLE_SCHEDULE)
-                | (bb->flags & BB_RTL));
+  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
+    bb->flags &= BB_FLAGS_TO_PRESERVE;

 }
 \f
 /* Check the consistency of profile information.  We can't do that
 }
 \f
 /* Check the consistency of profile information.  We can't do that


@@ -430,189 +395,112 @@ clear_bb_flags (void)
    solved graphs, later eliminating of conditionals or roundoff errors.
    It is still practical to have them reported for debugging of simple
    testcases.  */
    solved graphs, later eliminating of conditionals or roundoff errors.
    It is still practical to have them reported for debugging of simple
    testcases.  */

-void
-check_bb_profile (basic_block bb, FILE * file)
+static void
+check_bb_profile (basic_block bb, FILE * file, int indent, int flags)

 {
   edge e;
   int sum = 0;
   gcov_type lsum;
   edge_iterator ei;
 {
   edge e;
   int sum = 0;
   gcov_type lsum;
   edge_iterator ei;

+  struct function *fun = DECL_STRUCT_FUNCTION (current_function_decl);
+  char *s_indent = (char *) alloca ((size_t) indent + 1);
+  memset ((void *) s_indent, ' ', (size_t) indent);
+  s_indent[indent] = '\0';

 
 

-  if (profile_status == PROFILE_ABSENT)
+  if (profile_status_for_fn (fun) == PROFILE_ABSENT)

     return;
 
     return;
 

-  if (bb != EXIT_BLOCK_PTR)
+  if (bb != EXIT_BLOCK_PTR_FOR_FN (fun))

     {
       FOR_EACH_EDGE (e, ei, bb->succs)
        sum += e->probability;
       if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
     {
       FOR_EACH_EDGE (e, ei, bb->succs)
        sum += e->probability;
       if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)

-       fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
+       fprintf (file, "%s%sInvalid sum of outgoing probabilities %.1f%%\n",
+                (flags & TDF_COMMENT) ? ";; " : "", s_indent,

                 sum * 100.0 / REG_BR_PROB_BASE);
       lsum = 0;
       FOR_EACH_EDGE (e, ei, bb->succs)
        lsum += e->count;
       if (EDGE_COUNT (bb->succs)
          && (lsum - bb->count > 100 || lsum - bb->count < -100))
                 sum * 100.0 / REG_BR_PROB_BASE);
       lsum = 0;
       FOR_EACH_EDGE (e, ei, bb->succs)
        lsum += e->count;
       if (EDGE_COUNT (bb->succs)
          && (lsum - bb->count > 100 || lsum - bb->count < -100))

-       fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
+       fprintf (file, "%s%sInvalid sum of outgoing counts %i, should be %i\n",
+                (flags & TDF_COMMENT) ? ";; " : "", s_indent,

                 (int) lsum, (int) bb->count);
     }
                 (int) lsum, (int) bb->count);
     }

-  if (bb != ENTRY_BLOCK_PTR)
+    if (bb != ENTRY_BLOCK_PTR_FOR_FN (fun))

     {
       sum = 0;
       FOR_EACH_EDGE (e, ei, bb->preds)
        sum += EDGE_FREQUENCY (e);
       if (abs (sum - bb->frequency) > 100)
        fprintf (file,
     {
       sum = 0;
       FOR_EACH_EDGE (e, ei, bb->preds)
        sum += EDGE_FREQUENCY (e);
       if (abs (sum - bb->frequency) > 100)
        fprintf (file,

-                "Invalid sum of incoming frequencies %i, should be %i\n",
+                "%s%sInvalid sum of incoming frequencies %i, should be %i\n",
+                (flags & TDF_COMMENT) ? ";; " : "", s_indent,

                 sum, bb->frequency);
       lsum = 0;
       FOR_EACH_EDGE (e, ei, bb->preds)
        lsum += e->count;
       if (lsum - bb->count > 100 || lsum - bb->count < -100)
                 sum, bb->frequency);
       lsum = 0;
       FOR_EACH_EDGE (e, ei, bb->preds)
        lsum += e->count;
       if (lsum - bb->count > 100 || lsum - bb->count < -100)

-       fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
+       fprintf (file, "%s%sInvalid sum of incoming counts %i, should be %i\n",
+                (flags & TDF_COMMENT) ? ";; " : "", s_indent,

                 (int) lsum, (int) bb->count);
     }
                 (int) lsum, (int) bb->count);
     }

-}
-\f
-void
-dump_flow_info (FILE *file)
-{
-  basic_block bb;
-
-  /* There are no pseudo registers after reload.  Don't dump them.  */
-  if (reg_n_info && !reload_completed)
-    {
-      unsigned int i, max = max_reg_num ();
-      fprintf (file, "%d registers.\n", max);
-      for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
-       if (REG_N_REFS (i))
-         {
-           enum reg_class class, altclass;
-
-           fprintf (file, "\nRegister %d used %d times across %d insns",
-                    i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
-           if (REG_BASIC_BLOCK (i) >= 0)
-             fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
-           if (REG_N_SETS (i))
-             fprintf (file, "; set %d time%s", REG_N_SETS (i),
-                      (REG_N_SETS (i) == 1) ? "" : "s");
-           if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
-             fprintf (file, "; user var");
-           if (REG_N_DEATHS (i) != 1)
-             fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
-           if (REG_N_CALLS_CROSSED (i) == 1)
-             fprintf (file, "; crosses 1 call");
-           else if (REG_N_CALLS_CROSSED (i))
-             fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
-           if (regno_reg_rtx[i] != NULL
-               && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
-             fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
-
-           class = reg_preferred_class (i);
-           altclass = reg_alternate_class (i);
-           if (class != GENERAL_REGS || altclass != ALL_REGS)
-             {
-               if (altclass == ALL_REGS || class == ALL_REGS)
-                 fprintf (file, "; pref %s", reg_class_names[(int) class]);
-               else if (altclass == NO_REGS)
-                 fprintf (file, "; %s or none", reg_class_names[(int) class]);
-               else
-                 fprintf (file, "; pref %s, else %s",
-                          reg_class_names[(int) class],
-                          reg_class_names[(int) altclass]);
-             }
-
-           if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
-             fprintf (file, "; pointer");
-           fprintf (file, ".\n");
-         }
-    }
-
-  fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
-  FOR_EACH_BB (bb)
+  if (BB_PARTITION (bb) == BB_COLD_PARTITION)

     {
     {

-      edge e;
-      edge_iterator ei;
-
-      fprintf (file, "\nBasic block %d ", bb->index);
-      fprintf (file, "prev %d, next %d, ",
-              bb->prev_bb->index, bb->next_bb->index);
-      fprintf (file, "loop_depth %d, count ", bb->loop_depth);
-      fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
-      fprintf (file, ", freq %i", bb->frequency);
-      if (maybe_hot_bb_p (bb))
-       fprintf (file, ", maybe hot");
-      if (probably_never_executed_bb_p (bb))
-       fprintf (file, ", probably never executed");
-      fprintf (file, ".\n");
-
-      fprintf (file, "Predecessors: ");
+      /* Warn about inconsistencies in the partitioning that are
+         currently caused by profile insanities created via optimization.  */
+      if (!probably_never_executed_bb_p (fun, bb))
+        fprintf (file, "%s%sBlock in cold partition with hot count\n",
+                 (flags & TDF_COMMENT) ? ";; " : "", s_indent);

       FOR_EACH_EDGE (e, ei, bb->preds)
       FOR_EACH_EDGE (e, ei, bb->preds)

-       dump_edge_info (file, e, 0);
-
-      fprintf (file, "\nSuccessors: ");
-      FOR_EACH_EDGE (e, ei, bb->succs)
-       dump_edge_info (file, e, 1);
-
-      if (bb->flags & BB_RTL)
-       {
-         if (bb->il.rtl->global_live_at_start)
-           {
-             fprintf (file, "\nRegisters live at start:");
-             dump_regset (bb->il.rtl->global_live_at_start, file);
-           }
-
-         if (bb->il.rtl->global_live_at_end)
-           {
-             fprintf (file, "\nRegisters live at end:");
-             dump_regset (bb->il.rtl->global_live_at_end, file);
-           }
-       }
-
-      putc ('\n', file);
-      check_bb_profile (bb, file);
+        {
+          if (!probably_never_executed_edge_p (fun, e))
+            fprintf (file,
+                     "%s%sBlock in cold partition with incoming hot edge\n",
+                     (flags & TDF_COMMENT) ? ";; " : "", s_indent);
+        }

     }
     }

-
-  putc ('\n', file);
-}
-
-void
-debug_flow_info (void)
-{
-  dump_flow_info (stderr);

 }
 }

-
+\f

 void
 void

-dump_edge_info (FILE *file, edge e, int do_succ)
+dump_edge_info (FILE *file, edge e, int flags, int do_succ)

 {
   basic_block side = (do_succ ? e->dest : e->src);
 {
   basic_block side = (do_succ ? e->dest : e->src);

+  bool do_details = false;
+  
+  if ((flags & TDF_DETAILS) != 0
+      && (flags & TDF_SLIM) == 0)
+    do_details = true;

 
 

-  if (side == ENTRY_BLOCK_PTR)
+  if (side->index == ENTRY_BLOCK)

     fputs (" ENTRY", file);
     fputs (" ENTRY", file);

-  else if (side == EXIT_BLOCK_PTR)
+  else if (side->index == EXIT_BLOCK)

     fputs (" EXIT", file);
   else
     fprintf (file, " %d", side->index);
 
     fputs (" EXIT", file);
   else
     fprintf (file, " %d", side->index);
 

-  if (e->probability)
+  if (e->probability && do_details)

     fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
 
     fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
 

-  if (e->count)
+  if (e->count && do_details)

     {
     {

-      fprintf (file, " count:");
-      fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
+      fputs (" count:", file);
+      fprintf (file, "%" PRId64, e->count);

     }
 
     }
 

-  if (e->flags)
+  if (e->flags && do_details)

     {
     {

-      static const char * const bitnames[] = {
-       "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
-       "can_fallthru", "irreducible", "sibcall", "loop_exit",
-       "true", "false", "exec"
-      };
-      int comma = 0;
+      static const char * const bitnames[] =
+       {
+#define DEF_EDGE_FLAG(NAME,IDX) #NAME ,
+#include "cfg-flags.def"
+         NULL
+#undef DEF_EDGE_FLAG
+       };
+      bool comma = false;

       int i, flags = e->flags;
 
       int i, flags = e->flags;
 

+      gcc_assert (e->flags <= EDGE_ALL_FLAGS);

       fputs (" (", file);
       for (i = 0; flags; i++)
        if (flags & (1 << i))
       fputs (" (", file);
       for (i = 0; flags; i++)
        if (flags & (1 << i))


@@ -621,16 +509,30 @@ dump_edge_info (FILE *file, edge e, int do_succ)
 
            if (comma)
              fputc (',', file);
 
            if (comma)
              fputc (',', file);

-           if (i < (int) ARRAY_SIZE (bitnames))
-             fputs (bitnames[i], file);
-           else
-             fprintf (file, "%d", i);
-           comma = 1;
+           fputs (bitnames[i], file);
+           comma = true;

          }
 
       fputc (')', file);
     }
 }
          }
 
       fputc (')', file);
     }
 }

+
+DEBUG_FUNCTION void
+debug (edge_def &ref)
+{
+  /* FIXME (crowl): Is this desireable?  */
+  dump_edge_info (stderr, &ref, 0, false);
+  dump_edge_info (stderr, &ref, 0, true);
+}
+
+DEBUG_FUNCTION void
+debug (edge_def *ptr)
+{
+  if (ptr)
+    debug (*ptr);
+  else
+    fprintf (stderr, "<nil>\n");
+}

 \f
 /* Simple routines to easily allocate AUX fields of basic blocks.  */
 
 \f
 /* Simple routines to easily allocate AUX fields of basic blocks.  */
 


@@ -642,7 +544,7 @@ static void *first_edge_aux_obj = 0;
 /* Allocate a memory block of SIZE as BB->aux.  The obstack must
    be first initialized by alloc_aux_for_blocks.  */
 
 /* Allocate a memory block of SIZE as BB->aux.  The obstack must
    be first initialized by alloc_aux_for_blocks.  */
 

-inline void
+static void

 alloc_aux_for_block (basic_block bb, int size)
 {
   /* Verify that aux field is clear.  */
 alloc_aux_for_block (basic_block bb, int size)
 {
   /* Verify that aux field is clear.  */


@@ -667,13 +569,13 @@ alloc_aux_for_blocks (int size)
   else
     /* Check whether AUX data are still allocated.  */
     gcc_assert (!first_block_aux_obj);
   else
     /* Check whether AUX data are still allocated.  */
     gcc_assert (!first_block_aux_obj);

-  
+

   first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
   if (size)
     {
       basic_block bb;
 
   first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
   if (size)
     {
       basic_block bb;
 

-      FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+      FOR_ALL_BB_FN (bb, cfun)

        alloc_aux_for_block (bb, size);
     }
 }
        alloc_aux_for_block (bb, size);
     }
 }


@@ -685,7 +587,7 @@ clear_aux_for_blocks (void)
 {
   basic_block bb;
 
 {
   basic_block bb;
 

-  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+  FOR_ALL_BB_FN (bb, cfun)

     bb->aux = NULL;
 }
 
     bb->aux = NULL;
 }
 


@@ -702,10 +604,10 @@ free_aux_for_blocks (void)
   clear_aux_for_blocks ();
 }
 
   clear_aux_for_blocks ();
 }
 

-/* Allocate a memory edge of SIZE as BB->aux.  The obstack must
+/* Allocate a memory edge of SIZE as E->aux.  The obstack must

    be first initialized by alloc_aux_for_edges.  */
 
    be first initialized by alloc_aux_for_edges.  */
 

-inline void
+void

 alloc_aux_for_edge (edge e, int size)
 {
   /* Verify that aux field is clear.  */
 alloc_aux_for_edge (edge e, int size)
 {
   /* Verify that aux field is clear.  */


@@ -736,7 +638,8 @@ alloc_aux_for_edges (int size)
     {
       basic_block bb;
 
     {
       basic_block bb;
 

-      FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+      FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+                     EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)

        {
          edge e;
          edge_iterator ei;
        {
          edge e;
          edge_iterator ei;


@@ -755,7 +658,8 @@ clear_aux_for_edges (void)
   basic_block bb;
   edge e;
 
   basic_block bb;
   edge e;
 

-  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+                 EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)

     {
       edge_iterator ei;
       FOR_EACH_EDGE (e, ei, bb->succs)
     {
       edge_iterator ei;
       FOR_EACH_EDGE (e, ei, bb->succs)


@@ -776,76 +680,163 @@ free_aux_for_edges (void)
   clear_aux_for_edges ();
 }
 
   clear_aux_for_edges ();
 }
 

-void
+DEBUG_FUNCTION void

 debug_bb (basic_block bb)
 {
 debug_bb (basic_block bb)
 {

-  dump_bb (bb, stderr, 0);
+  dump_bb (stderr, bb, 0, dump_flags);

 }
 
 }
 

-basic_block
+DEBUG_FUNCTION basic_block

 debug_bb_n (int n)
 {
 debug_bb_n (int n)
 {

-  basic_block bb = BASIC_BLOCK (n);
-  dump_bb (bb, stderr, 0);
+  basic_block bb = BASIC_BLOCK_FOR_FN (cfun, n);
+  debug_bb (bb);

   return bb;
 }
 
   return bb;
 }
 

-/* Dumps cfg related information about basic block BB to FILE.  */
+/* Dumps cfg related information about basic block BB to OUTF.
+   If HEADER is true, dump things that appear before the instructions
+   contained in BB.  If FOOTER is true, dump things that appear after.
+   Flags are the TDF_* masks as documented in dumpfile.h.
+   NB: With TDF_DETAILS, it is assumed that cfun is available, so
+   that maybe_hot_bb_p and probably_never_executed_bb_p don't ICE.  */

 
 

-static void
-dump_cfg_bb_info (FILE *file, basic_block bb)
+void
+dump_bb_info (FILE *outf, basic_block bb, int indent, int flags,
+             bool do_header, bool do_footer)

 {
 {

-  unsigned i;

   edge_iterator ei;
   edge_iterator ei;

-  bool first = true;
+  edge e;

   static const char * const bb_bitnames[] =
     {
   static const char * const bb_bitnames[] =
     {

-      "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
+#define DEF_BASIC_BLOCK_FLAG(NAME,IDX) #NAME ,
+#include "cfg-flags.def"
+      NULL
+#undef DEF_BASIC_BLOCK_FLAG

     };
   const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
     };
   const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);

-  edge e;
+  bool first;
+  char *s_indent = (char *) alloca ((size_t) indent + 1);
+  memset ((void *) s_indent, ' ', (size_t) indent);
+  s_indent[indent] = '\0';

 
 

-  fprintf (file, "Basic block %d", bb->index);
-  for (i = 0; i < n_bitnames; i++)
-    if (bb->flags & (1 << i))
-      {
-       if (first)
-         fprintf (file, " (");
-       else
-         fprintf (file, ", ");
-       first = false;
-       fprintf (file, bb_bitnames[i]);
-      }
-  if (!first)
-    fprintf (file, ")");
-  fprintf (file, "\n");
-
-  fprintf (file, "Predecessors: ");
-  FOR_EACH_EDGE (e, ei, bb->preds)
-    dump_edge_info (file, e, 0);
-
-  fprintf (file, "\nSuccessors: ");
-  FOR_EACH_EDGE (e, ei, bb->succs)
-    dump_edge_info (file, e, 1);
-  fprintf (file, "\n\n");
+  gcc_assert (bb->flags <= BB_ALL_FLAGS);
+
+  if (do_header)
+    {
+      unsigned i;
+
+      if (flags & TDF_COMMENT)
+       fputs (";; ", outf);
+      fprintf (outf, "%sbasic block %d, loop depth %d",
+              s_indent, bb->index, bb_loop_depth (bb));
+      if (flags & TDF_DETAILS)
+       {
+         struct function *fun = DECL_STRUCT_FUNCTION (current_function_decl);
+         fprintf (outf, ", count " "%" PRId64,
+                  (int64_t) bb->count);
+         fprintf (outf, ", freq %i", bb->frequency);
+         if (maybe_hot_bb_p (fun, bb))
+           fputs (", maybe hot", outf);
+         if (probably_never_executed_bb_p (fun, bb))
+           fputs (", probably never executed", outf);
+       }
+      fputc ('\n', outf);
+
+      if (flags & TDF_DETAILS)
+       {
+         check_bb_profile (bb, outf, indent, flags);
+         if (flags & TDF_COMMENT)
+           fputs (";; ", outf);
+         fprintf (outf, "%s prev block ", s_indent);
+         if (bb->prev_bb)
+           fprintf (outf, "%d", bb->prev_bb->index);
+         else
+           fprintf (outf, "(nil)");
+         fprintf (outf, ", next block ");
+         if (bb->next_bb)
+           fprintf (outf, "%d", bb->next_bb->index);
+         else
+           fprintf (outf, "(nil)");
+
+         fputs (", flags:", outf);
+         first = true;
+         for (i = 0; i < n_bitnames; i++)
+           if (bb->flags & (1 << i))
+             {
+               if (first)
+                 fputs (" (", outf);
+               else
+                 fputs (", ", outf);
+               first = false;
+               fputs (bb_bitnames[i], outf);
+             }
+         if (!first)
+           fputc (')', outf);
+         fputc ('\n', outf);
+       }
+
+      if (flags & TDF_COMMENT)
+       fputs (";; ", outf);
+      fprintf (outf, "%s pred:      ", s_indent);
+      first = true;
+      FOR_EACH_EDGE (e, ei, bb->preds)
+       {
+         if (! first)
+           {
+             if (flags & TDF_COMMENT)
+               fputs (";; ", outf);
+             fprintf (outf, "%s            ", s_indent);
+           }
+         first = false;
+         dump_edge_info (outf, e, flags, 0);
+         fputc ('\n', outf);
+       }
+      if (first)
+       fputc ('\n', outf);
+    }
+
+  if (do_footer)
+    {
+      if (flags & TDF_COMMENT)
+       fputs (";; ", outf);
+      fprintf (outf, "%s succ:      ", s_indent);
+      first = true;
+      FOR_EACH_EDGE (e, ei, bb->succs)
+        {
+         if (! first)
+           {
+             if (flags & TDF_COMMENT)
+               fputs (";; ", outf);
+             fprintf (outf, "%s            ", s_indent);
+           }
+         first = false;
+         dump_edge_info (outf, e, flags, 1);
+         fputc ('\n', outf);
+       }
+      if (first)
+       fputc ('\n', outf);
+    }

 }
 
 /* Dumps a brief description of cfg to FILE.  */
 
 void
 }
 
 /* Dumps a brief description of cfg to FILE.  */
 
 void

-brief_dump_cfg (FILE *file)
+brief_dump_cfg (FILE *file, int flags)

 {
   basic_block bb;
 
 {
   basic_block bb;
 

-  FOR_EACH_BB (bb)
+  FOR_EACH_BB_FN (bb, cfun)

     {
     {

-      dump_cfg_bb_info (file, bb);
+      dump_bb_info (file, bb, 0,
+                   flags & (TDF_COMMENT | TDF_DETAILS),
+                   true, true);

     }
 }
 
 /* An edge originally destinating BB of FREQUENCY and COUNT has been proved to
    leave the block by TAKEN_EDGE.  Update profile of BB such that edge E can be
     }
 }
 
 /* An edge originally destinating BB of FREQUENCY and COUNT has been proved to
    leave the block by TAKEN_EDGE.  Update profile of BB such that edge E can be

-   redirected to destination of TAKEN_EDGE. 
+   redirected to destination of TAKEN_EDGE.

 
    This function may leave the profile inconsistent in the case TAKEN_EDGE
    frequency or count is believed to be lower than FREQUENCY or COUNT
 
    This function may leave the profile inconsistent in the case TAKEN_EDGE
    frequency or count is believed to be lower than FREQUENCY or COUNT


@@ -860,12 +851,17 @@ update_bb_profile_for_threading (basic_block bb, int edge_frequency,
 
   bb->count -= count;
   if (bb->count < 0)
 
   bb->count -= count;
   if (bb->count < 0)

-    bb->count = 0;
+    {
+      if (dump_file)
+       fprintf (dump_file, "bb %i count became negative after threading",
+                bb->index);
+      bb->count = 0;
+    }

 
   /* Compute the probability of TAKEN_EDGE being reached via threaded edge.
      Watch for overflows.  */
   if (bb->frequency)
 
   /* Compute the probability of TAKEN_EDGE being reached via threaded edge.
      Watch for overflows.  */
   if (bb->frequency)

-    prob = edge_frequency * REG_BR_PROB_BASE / bb->frequency;
+    prob = GCOV_COMPUTE_SCALE (edge_frequency, bb->frequency);

   else
     prob = 0;
   if (prob > taken_edge->probability)
   else
     prob = 0;
   if (prob > taken_edge->probability)


@@ -898,16 +894,31 @@ update_bb_profile_for_threading (basic_block bb, int edge_frequency,
     }
   else if (prob != REG_BR_PROB_BASE)
     {
     }
   else if (prob != REG_BR_PROB_BASE)
     {

-      int scale = 65536 * REG_BR_PROB_BASE / prob;
+      int scale = RDIV (65536 * REG_BR_PROB_BASE, prob);

 
       FOR_EACH_EDGE (c, ei, bb->succs)
 
       FOR_EACH_EDGE (c, ei, bb->succs)

-       c->probability = (c->probability * scale) / 65536;
+       {
+         /* Protect from overflow due to additional scaling.  */
+         if (c->probability > prob)
+           c->probability = REG_BR_PROB_BASE;
+         else
+           {
+             c->probability = RDIV (c->probability * scale, 65536);
+             if (c->probability > REG_BR_PROB_BASE)
+               c->probability = REG_BR_PROB_BASE;
+           }
+       }

     }
 
   gcc_assert (bb == taken_edge->src);
   taken_edge->count -= count;
   if (taken_edge->count < 0)
     }
 
   gcc_assert (bb == taken_edge->src);
   taken_edge->count -= count;
   if (taken_edge->count < 0)

-    taken_edge->count = 0;
+    {
+      if (dump_file)
+       fprintf (dump_file, "edge %i->%i count became negative after threading",
+                taken_edge->src->index, taken_edge->dest->index);
+      taken_edge->count = 0;
+    }

 }
 
 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
 }
 
 /* Multiply all frequencies of basic blocks in array BBS of length NBBS


@@ -917,41 +928,83 @@ scale_bbs_frequencies_int (basic_block *bbs, int nbbs, int num, int den)
 {
   int i;
   edge e;
 {
   int i;
   edge e;

+  if (num < 0)
+    num = 0;
+
+  /* Scale NUM and DEN to avoid overflows.  Frequencies are in order of
+     10^4, if we make DEN <= 10^3, we can afford to upscale by 100
+     and still safely fit in int during calculations.  */
+  if (den > 1000)
+    {
+      if (num > 1000000)
+       return;
+
+      num = RDIV (1000 * num, den);
+      den = 1000;
+    }
+  if (num > 100 * den)
+    return;
+

   for (i = 0; i < nbbs; i++)
     {
       edge_iterator ei;
   for (i = 0; i < nbbs; i++)
     {
       edge_iterator ei;

-      bbs[i]->frequency = (bbs[i]->frequency * num) / den;
+      bbs[i]->frequency = RDIV (bbs[i]->frequency * num, den);
+      /* Make sure the frequencies do not grow over BB_FREQ_MAX.  */
+      if (bbs[i]->frequency > BB_FREQ_MAX)
+       bbs[i]->frequency = BB_FREQ_MAX;

       bbs[i]->count = RDIV (bbs[i]->count * num, den);
       FOR_EACH_EDGE (e, ei, bbs[i]->succs)
       bbs[i]->count = RDIV (bbs[i]->count * num, den);
       FOR_EACH_EDGE (e, ei, bbs[i]->succs)

-       e->count = (e->count * num) /den;
+       e->count = RDIV (e->count * num, den);

     }
 }
 
     }
 }
 

+/* numbers smaller than this value are safe to multiply without getting
+   64bit overflow.  */
+#define MAX_SAFE_MULTIPLIER (1 << (sizeof (int64_t) * 4 - 1))
+

 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
    by NUM/DEN, in gcov_type arithmetic.  More accurate than previous
    function but considerably slower.  */
 void
 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
    by NUM/DEN, in gcov_type arithmetic.  More accurate than previous
    function but considerably slower.  */
 void

-scale_bbs_frequencies_gcov_type (basic_block *bbs, int nbbs, gcov_type num, 
-                                gcov_type den)
+scale_bbs_frequencies_gcov_type (basic_block *bbs, int nbbs, gcov_type num,
+                                gcov_type den)

 {
   int i;
   edge e;
 {
   int i;
   edge e;

+  gcov_type fraction = RDIV (num * 65536, den);

 
 

-  for (i = 0; i < nbbs; i++)
-    {
-      edge_iterator ei;
-      bbs[i]->frequency = (bbs[i]->frequency * num) / den;
-      bbs[i]->count = RDIV (bbs[i]->count * num, den);
-      FOR_EACH_EDGE (e, ei, bbs[i]->succs)
-       e->count = (e->count * num) /den;
-    }
+  gcc_assert (fraction >= 0);
+
+  if (num < MAX_SAFE_MULTIPLIER)
+    for (i = 0; i < nbbs; i++)
+      {
+       edge_iterator ei;
+       bbs[i]->frequency = RDIV (bbs[i]->frequency * num, den);
+       if (bbs[i]->count <= MAX_SAFE_MULTIPLIER)
+         bbs[i]->count = RDIV (bbs[i]->count * num, den);
+       else
+         bbs[i]->count = RDIV (bbs[i]->count * fraction, 65536);
+       FOR_EACH_EDGE (e, ei, bbs[i]->succs)
+         if (bbs[i]->count <= MAX_SAFE_MULTIPLIER)
+           e->count = RDIV (e->count * num, den);
+         else
+           e->count = RDIV (e->count * fraction, 65536);
+      }
+   else
+    for (i = 0; i < nbbs; i++)
+      {
+       edge_iterator ei;
+       if (sizeof (gcov_type) > sizeof (int))
+         bbs[i]->frequency = RDIV (bbs[i]->frequency * num, den);
+       else
+         bbs[i]->frequency = RDIV (bbs[i]->frequency * fraction, 65536);
+       bbs[i]->count = RDIV (bbs[i]->count * fraction, 65536);
+       FOR_EACH_EDGE (e, ei, bbs[i]->succs)
+         e->count = RDIV (e->count * fraction, 65536);
+      }

 }
 
 }
 

-/* Data structures used to maintain mapping between basic blocks and
-   copies.  */
-static htab_t bb_original;
-static htab_t bb_copy;
-static alloc_pool original_copy_bb_pool;
+/* Helper types for hash tables.  */

 
 struct htab_bb_copy_original_entry
 {
 
 struct htab_bb_copy_original_entry
 {


@@ -961,37 +1014,45 @@ struct htab_bb_copy_original_entry
   int index2;
 };
 
   int index2;
 };
 

-static hashval_t
-bb_copy_original_hash (const void *p)
+struct bb_copy_hasher : nofree_ptr_hash <htab_bb_copy_original_entry>

 {
 {

-  struct htab_bb_copy_original_entry *data
-    = ((struct htab_bb_copy_original_entry *)p);
+  static inline hashval_t hash (const htab_bb_copy_original_entry *);
+  static inline bool equal (const htab_bb_copy_original_entry *existing,
+                           const htab_bb_copy_original_entry * candidate);
+};

 
 

+inline hashval_t
+bb_copy_hasher::hash (const htab_bb_copy_original_entry *data)
+{

   return data->index1;
 }
   return data->index1;
 }

-static int
-bb_copy_original_eq (const void *p, const void *q)
-{
-  struct htab_bb_copy_original_entry *data
-    = ((struct htab_bb_copy_original_entry *)p);
-  struct htab_bb_copy_original_entry *data2
-    = ((struct htab_bb_copy_original_entry *)q);

 
 

+inline bool
+bb_copy_hasher::equal (const htab_bb_copy_original_entry *data,
+                      const htab_bb_copy_original_entry *data2)
+{

   return data->index1 == data2->index1;
 }
 
   return data->index1 == data2->index1;
 }
 

+/* Data structures used to maintain mapping between basic blocks and
+   copies.  */
+static hash_table<bb_copy_hasher> *bb_original;
+static hash_table<bb_copy_hasher> *bb_copy;
+
+/* And between loops and copies.  */
+static hash_table<bb_copy_hasher> *loop_copy;
+static object_allocator<htab_bb_copy_original_entry> *original_copy_bb_pool;
+

 /* Initialize the data structures to maintain mapping between blocks
    and its copies.  */
 void
 initialize_original_copy_tables (void)
 {
 /* Initialize the data structures to maintain mapping between blocks
    and its copies.  */
 void
 initialize_original_copy_tables (void)
 {

-  gcc_assert (!original_copy_bb_pool);
-  original_copy_bb_pool
-    = create_alloc_pool ("original_copy",
-                        sizeof (struct htab_bb_copy_original_entry), 10);
-  bb_original = htab_create (10, bb_copy_original_hash,
-                            bb_copy_original_eq, NULL);
-  bb_copy = htab_create (10, bb_copy_original_hash, bb_copy_original_eq, NULL);
+  original_copy_bb_pool = new object_allocator<htab_bb_copy_original_entry>
+    ("original_copy");
+  bb_original = new hash_table<bb_copy_hasher> (10);
+  bb_copy = new hash_table<bb_copy_hasher> (10);
+  loop_copy = new hash_table<bb_copy_hasher> (10);

 }
 
 /* Free the data structures to maintain mapping between blocks and
 }
 
 /* Free the data structures to maintain mapping between blocks and


@@ -1000,37 +1061,66 @@ void
 free_original_copy_tables (void)
 {
   gcc_assert (original_copy_bb_pool);
 free_original_copy_tables (void)
 {
   gcc_assert (original_copy_bb_pool);

-  htab_delete (bb_copy);
-  htab_delete (bb_original);
-  free_alloc_pool (original_copy_bb_pool);
+  delete bb_copy;

   bb_copy = NULL;
   bb_copy = NULL;

-  bb_original = NULL;
+  delete bb_original;
+  bb_copy = NULL;
+  delete loop_copy;
+  loop_copy = NULL;
+  delete original_copy_bb_pool;

   original_copy_bb_pool = NULL;
 }
 
   original_copy_bb_pool = NULL;
 }
 

+/* Removes the value associated with OBJ from table TAB.  */
+
+static void
+copy_original_table_clear (hash_table<bb_copy_hasher> *tab, unsigned obj)
+{
+  htab_bb_copy_original_entry **slot;
+  struct htab_bb_copy_original_entry key, *elt;
+
+  if (!original_copy_bb_pool)
+    return;
+
+  key.index1 = obj;
+  slot = tab->find_slot (&key, NO_INSERT);
+  if (!slot)
+    return;
+
+  elt = *slot;
+  tab->clear_slot (slot);
+  original_copy_bb_pool->remove (elt);
+}
+
+/* Sets the value associated with OBJ in table TAB to VAL.
+   Do nothing when data structures are not initialized.  */
+
+static void
+copy_original_table_set (hash_table<bb_copy_hasher> *tab,
+                        unsigned obj, unsigned val)
+{
+  struct htab_bb_copy_original_entry **slot;
+  struct htab_bb_copy_original_entry key;
+
+  if (!original_copy_bb_pool)
+    return;
+
+  key.index1 = obj;
+  slot = tab->find_slot (&key, INSERT);
+  if (!*slot)
+    {
+      *slot = original_copy_bb_pool->allocate ();
+      (*slot)->index1 = obj;
+    }
+  (*slot)->index2 = val;
+}
+

 /* Set original for basic block.  Do nothing when data structures are not
    initialized so passes not needing this don't need to care.  */
 void
 set_bb_original (basic_block bb, basic_block original)
 {
 /* Set original for basic block.  Do nothing when data structures are not
    initialized so passes not needing this don't need to care.  */
 void
 set_bb_original (basic_block bb, basic_block original)
 {

-  if (original_copy_bb_pool)
-    {
-      struct htab_bb_copy_original_entry **slot;
-      struct htab_bb_copy_original_entry key;
-
-      key.index1 = bb->index;
-      slot =
-       (struct htab_bb_copy_original_entry **) htab_find_slot (bb_original,
-                                                              &key, INSERT);
-      if (*slot)
-       (*slot)->index2 = original->index;
-      else
-       {
-         *slot = pool_alloc (original_copy_bb_pool);
-         (*slot)->index1 = bb->index;
-         (*slot)->index2 = original->index;
-       }
-    }
+  copy_original_table_set (bb_original, bb->index, original->index);

 }
 
 /* Get the original basic block.  */
 }
 
 /* Get the original basic block.  */


@@ -1043,9 +1133,9 @@ get_bb_original (basic_block bb)
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = bb->index;
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = bb->index;

-  entry = (struct htab_bb_copy_original_entry *) htab_find (bb_original, &key);
+  entry = bb_original->find (&key);

   if (entry)
   if (entry)

-    return BASIC_BLOCK (entry->index2);
+    return BASIC_BLOCK_FOR_FN (cfun, entry->index2);

   else
     return NULL;
 }
   else
     return NULL;
 }


@@ -1055,24 +1145,7 @@ get_bb_original (basic_block bb)
 void
 set_bb_copy (basic_block bb, basic_block copy)
 {
 void
 set_bb_copy (basic_block bb, basic_block copy)
 {

-  if (original_copy_bb_pool)
-    {
-      struct htab_bb_copy_original_entry **slot;
-      struct htab_bb_copy_original_entry key;
-
-      key.index1 = bb->index;
-      slot =
-       (struct htab_bb_copy_original_entry **) htab_find_slot (bb_copy,
-                                                              &key, INSERT);
-      if (*slot)
-       (*slot)->index2 = copy->index;
-      else
-       {
-         *slot = pool_alloc (original_copy_bb_pool);
-         (*slot)->index1 = bb->index;
-         (*slot)->index2 = copy->index;
-       }
-    }
+  copy_original_table_set (bb_copy, bb->index, copy->index);

 }
 
 /* Get the copy of basic block.  */
 }
 
 /* Get the copy of basic block.  */


@@ -1085,9 +1158,39 @@ get_bb_copy (basic_block bb)
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = bb->index;
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = bb->index;

-  entry = (struct htab_bb_copy_original_entry *) htab_find (bb_copy, &key);
+  entry = bb_copy->find (&key);
+  if (entry)
+    return BASIC_BLOCK_FOR_FN (cfun, entry->index2);
+  else
+    return NULL;
+}
+
+/* Set copy for LOOP to COPY.  Do nothing when data structures are not
+   initialized so passes not needing this don't need to care.  */
+
+void
+set_loop_copy (struct loop *loop, struct loop *copy)
+{
+  if (!copy)
+    copy_original_table_clear (loop_copy, loop->num);
+  else
+    copy_original_table_set (loop_copy, loop->num, copy->num);
+}
+
+/* Get the copy of LOOP.  */
+
+struct loop *
+get_loop_copy (struct loop *loop)
+{
+  struct htab_bb_copy_original_entry *entry;
+  struct htab_bb_copy_original_entry key;
+
+  gcc_assert (original_copy_bb_pool);
+
+  key.index1 = loop->num;
+  entry = loop_copy->find (&key);

   if (entry)
   if (entry)

-    return BASIC_BLOCK (entry->index2);
+    return get_loop (cfun, entry->index2);

   else
     return NULL;
 }
   else
     return NULL;
 }