* optc-gen.awk (END): Make sure no variable is defined more

[pf3gnuchains/gcc-fork.git] / gcc / loop-unroll.c

diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
index c4f49d5..c93170c 100644 (file)
--- a/gcc/loop-unroll.c
+++ b/gcc/loop-unroll.c
@@ -1,5 +1,5 @@
 /* Loop unrolling and peeling.
-   Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -495,6 +495,8 @@ peel_loop_completely (struct loops *loops, struct loop *loop)
 
   if (npeel)
     {
+      bool ok;
+      
       wont_exit = sbitmap_alloc (npeel + 1);
       sbitmap_ones (wont_exit);
       RESET_BIT (wont_exit, 0);
@@ -508,11 +510,12 @@ peel_loop_completely (struct loops *loops, struct loop *loop)
         opt_info = analyze_insns_in_loop (loop);
       
       opt_info_start_duplication (opt_info);
-      if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
-               loops, npeel,
-               wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
-               DLTHE_FLAG_UPDATE_FREQ))
-       abort ();
+      ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+                                         loops, npeel,
+                                         wont_exit, desc->out_edge,
+                                         remove_edges, &n_remove_edges,
+                                         DLTHE_FLAG_UPDATE_FREQ);
+      gcc_assert (ok);
 
       free (wont_exit);
       
@@ -670,6 +673,7 @@ unroll_loop_constant_iterations (struct loops *loops, struct loop *loop)
   struct niter_desc *desc = get_simple_loop_desc (loop);
   bool exit_at_end = loop_exit_at_end_p (loop);
   struct opt_info *opt_info = NULL;
+  bool ok;
   
   niter = desc->niter;
 
@@ -704,12 +708,12 @@ unroll_loop_constant_iterations (struct loops *loops, struct loop *loop)
       if (exit_mod)
        {
          opt_info_start_duplication (opt_info);
-          if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+          ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
                                              loops, exit_mod,
                                              wont_exit, desc->out_edge,
                                              remove_edges, &n_remove_edges,
-                                             DLTHE_FLAG_UPDATE_FREQ))
-           abort ();
+                                             DLTHE_FLAG_UPDATE_FREQ);
+         gcc_assert (ok);
 
           if (opt_info && exit_mod > 1)
            apply_opt_in_copies (opt_info, exit_mod, false, false); 
@@ -740,11 +744,12 @@ unroll_loop_constant_iterations (struct loops *loops, struct loop *loop)
            RESET_BIT (wont_exit, 1);
          
           opt_info_start_duplication (opt_info);
-         if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
-               loops, exit_mod + 1,
-               wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
-               DLTHE_FLAG_UPDATE_FREQ))
-           abort ();
+         ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+                                             loops, exit_mod + 1,
+                                             wont_exit, desc->out_edge,
+                                             remove_edges, &n_remove_edges,
+                                             DLTHE_FLAG_UPDATE_FREQ);
+         gcc_assert (ok);
  
           if (opt_info && exit_mod > 0)
            apply_opt_in_copies (opt_info, exit_mod + 1, false, false);
@@ -763,11 +768,12 @@ unroll_loop_constant_iterations (struct loops *loops, struct loop *loop)
   /* Now unroll the loop.  */
   
   opt_info_start_duplication (opt_info);
-  if (!duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
-               loops, max_unroll,
-               wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
-               DLTHE_FLAG_UPDATE_FREQ))
-    abort ();
+  ok = duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
+                                     loops, max_unroll,
+                                     wont_exit, desc->out_edge,
+                                     remove_edges, &n_remove_edges,
+                                     DLTHE_FLAG_UPDATE_FREQ);
+  gcc_assert (ok);
 
   if (opt_info)
     {
@@ -935,6 +941,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
   struct niter_desc *desc = get_simple_loop_desc (loop);
   bool exit_at_end = loop_exit_at_end_p (loop);
   struct opt_info *opt_info = NULL;
+  bool ok;
   
   if (flag_split_ivs_in_unroller
       || flag_variable_expansion_in_unroller)
@@ -1013,11 +1020,12 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       && !desc->noloop_assumptions)
     SET_BIT (wont_exit, 1);
   ezc_swtch = loop_preheader_edge (loop)->src;
-  if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
-               loops, 1,
-               wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
-               DLTHE_FLAG_UPDATE_FREQ))
-    abort ();
+  ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+                                     loops, 1,
+                                     wont_exit, desc->out_edge,
+                                     remove_edges, &n_remove_edges,
+                                     DLTHE_FLAG_UPDATE_FREQ);
+  gcc_assert (ok);
 
   /* Record the place where switch will be built for preconditioning.  */
   swtch = loop_split_edge_with (loop_preheader_edge (loop),
@@ -1029,11 +1037,12 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       sbitmap_zero (wont_exit);
       if (i != n_peel - 1 || !last_may_exit)
        SET_BIT (wont_exit, 1);
-      if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
-               loops, 1,
-               wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
-               DLTHE_FLAG_UPDATE_FREQ))
-       abort ();
+      ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+                                         loops, 1,
+                                         wont_exit, desc->out_edge,
+                                         remove_edges, &n_remove_edges,
+                                         DLTHE_FLAG_UPDATE_FREQ);
+      gcc_assert (ok);
 
       /* Create item for switch.  */
       j = n_peel - i - (extra_zero_check ? 0 : 1);
@@ -1041,13 +1050,14 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
 
       preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
       branch_code = compare_and_jump_seq (copy_rtx (niter), GEN_INT (j), EQ,
-                                         block_label (preheader), p, NULL_RTX);
+                                         block_label (preheader), p,
+                                         NULL_RTX);
 
-      swtch = loop_split_edge_with (EDGE_PRED (swtch, 0), branch_code);
+      swtch = loop_split_edge_with (single_pred_edge (swtch), branch_code);
       set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
-      EDGE_SUCC (swtch, 0)->probability = REG_BR_PROB_BASE - p;
+      single_pred_edge (swtch)->probability = REG_BR_PROB_BASE - p;
       e = make_edge (swtch, preheader,
-                    EDGE_SUCC (swtch, 0)->flags & EDGE_IRREDUCIBLE_LOOP);
+                    single_succ_edge (swtch)->flags & EDGE_IRREDUCIBLE_LOOP);
       e->probability = p;
     }
 
@@ -1058,13 +1068,14 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       swtch = ezc_swtch;
       preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
       branch_code = compare_and_jump_seq (copy_rtx (niter), const0_rtx, EQ,
-                                         block_label (preheader), p, NULL_RTX);
+                                         block_label (preheader), p,
+                                         NULL_RTX);
 
-      swtch = loop_split_edge_with (EDGE_SUCC (swtch, 0), branch_code);
+      swtch = loop_split_edge_with (single_succ_edge (swtch), branch_code);
       set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
-      EDGE_SUCC (swtch, 0)->probability = REG_BR_PROB_BASE - p;
+      single_succ_edge (swtch)->probability = REG_BR_PROB_BASE - p;
       e = make_edge (swtch, preheader,
-                    EDGE_SUCC (swtch, 0)->flags & EDGE_IRREDUCIBLE_LOOP);
+                    single_succ_edge (swtch)->flags & EDGE_IRREDUCIBLE_LOOP);
       e->probability = p;
     }
 
@@ -1077,11 +1088,12 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
   RESET_BIT (wont_exit, may_exit_copy);
   opt_info_start_duplication (opt_info);
   
-  if (!duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
-               loops, max_unroll,
-               wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
-               DLTHE_FLAG_UPDATE_FREQ))
-    abort ();
+  ok = duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
+                                     loops, max_unroll,
+                                     wont_exit, desc->out_edge,
+                                     remove_edges, &n_remove_edges,
+                                     DLTHE_FLAG_UPDATE_FREQ);
+  gcc_assert (ok);
   
   if (opt_info)
     {
@@ -1094,7 +1106,8 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
   if (exit_at_end)
     {
       basic_block exit_block = desc->in_edge->src->rbi->copy;
-      /* Find a new in and out edge; they are in the last copy we have made.  */
+      /* Find a new in and out edge; they are in the last copy we have
+        made.  */
       
       if (EDGE_SUCC (exit_block, 0)->dest == desc->out_edge->dest)
        {
@@ -1119,7 +1132,8 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
      the correct new number of iterations is this:  */
   gcc_assert (!desc->const_iter);
   desc->niter_expr =
-    simplify_gen_binary (UDIV, desc->mode, old_niter, GEN_INT (max_unroll + 1));
+    simplify_gen_binary (UDIV, desc->mode, old_niter,
+                        GEN_INT (max_unroll + 1));
   desc->niter_max /= max_unroll + 1;
   if (exit_at_end)
     {
@@ -1242,6 +1256,7 @@ peel_loop_simple (struct loops *loops, struct loop *loop)
   unsigned npeel = loop->lpt_decision.times;
   struct niter_desc *desc = get_simple_loop_desc (loop);
   struct opt_info *opt_info = NULL;
+  bool ok;
   
   if (flag_split_ivs_in_unroller && npeel > 1)
     opt_info = analyze_insns_in_loop (loop);
@@ -1251,10 +1266,11 @@ peel_loop_simple (struct loops *loops, struct loop *loop)
   
   opt_info_start_duplication (opt_info);
   
-  if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
-               loops, npeel, wont_exit, NULL, NULL, NULL,
-               DLTHE_FLAG_UPDATE_FREQ))
-    abort ();
+  ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+                                     loops, npeel, wont_exit,
+                                     NULL, NULL,
+                                     NULL, DLTHE_FLAG_UPDATE_FREQ);
+  gcc_assert (ok);
 
   free (wont_exit);
   
@@ -1387,6 +1403,7 @@ unroll_loop_stupid (struct loops *loops, struct loop *loop)
   unsigned nunroll = loop->lpt_decision.times;
   struct niter_desc *desc = get_simple_loop_desc (loop);
   struct opt_info *opt_info = NULL;
+  bool ok;
   
   if (flag_split_ivs_in_unroller
       || flag_variable_expansion_in_unroller)
@@ -1397,10 +1414,11 @@ unroll_loop_stupid (struct loops *loops, struct loop *loop)
   sbitmap_zero (wont_exit);
   opt_info_start_duplication (opt_info);
   
-  if (!duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
-               loops, nunroll, wont_exit, NULL, NULL, NULL,
-               DLTHE_FLAG_UPDATE_FREQ))
-    abort ();
+  ok = duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
+                                     loops, nunroll, wont_exit,
+                                     NULL, NULL, NULL,
+                                     DLTHE_FLAG_UPDATE_FREQ);
+  gcc_assert (ok);
   
   if (opt_info)
     {
@@ -1599,6 +1617,7 @@ analyze_iv_to_split_insn (rtx insn)
   rtx set, dest;
   struct rtx_iv iv;
   struct iv_to_split *ivts;
+  bool ok;
 
   /* For now we just split the basic induction variables.  Later this may be
      extended for example by selecting also addresses of memory references.  */
@@ -1613,8 +1632,8 @@ analyze_iv_to_split_insn (rtx insn)
   if (!biv_p (insn, dest))
     return NULL;
 
-  if (!iv_analyze (insn, dest, &iv))
-    abort ();
+  ok = iv_analyze (insn, dest, &iv);
+  gcc_assert (ok);
 
   if (iv.step == const0_rtx
       || iv.mode != iv.extend_mode)
@@ -1640,15 +1659,14 @@ static struct opt_info *
 analyze_insns_in_loop (struct loop *loop)
 {
   basic_block *body, bb;
-  unsigned i, n_edges = 0;
+  unsigned i, num_edges = 0;
   struct opt_info *opt_info = xcalloc (1, sizeof (struct opt_info));
   rtx insn;
   struct iv_to_split *ivts = NULL;
   struct var_to_expand *ves = NULL;
   PTR *slot1;
   PTR *slot2;
-  edge *edges = get_loop_exit_edges (loop, &n_edges);
-  basic_block preheader;
+  edge *edges = get_loop_exit_edges (loop, &num_edges);
   bool can_apply = false;
   
   iv_analysis_loop_init (loop);
@@ -1662,13 +1680,13 @@ analyze_insns_in_loop (struct loop *loop)
   /* Record the loop exit bb and loop preheader before the unrolling.  */
   if (!loop_preheader_edge (loop)->src)
     {
-      preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
+      loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
       opt_info->loop_preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
     }
   else
     opt_info->loop_preheader = loop_preheader_edge (loop)->src;
   
-  if (n_edges == 1
+  if (num_edges == 1
       && !(edges[0]->flags & EDGE_COMPLEX))
     {
       opt_info->loop_exit = loop_split_edge_with (edges[0], NULL_RTX);
@@ -1892,8 +1910,7 @@ expand_var_during_unrolling (struct var_to_expand *ve, rtx insn)
   bool really_new_expansion = false;
   
   set = single_set (insn);
-  if (!set)
-    abort ();
+  gcc_assert (set);
   
   /* Generate a new register only if the expansion limit has not been
      reached.  Else reuse an already existing expansion.  */