gcc/tree-ssa-loop-ch.c

   1 /* Loop header copying on trees.
   2    Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING.  If not, write to the Free
  18 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "rtl.h"
  27 #include "tm_p.h"
  28 #include "hard-reg-set.h"
  29 #include "basic-block.h"
  30 #include "output.h"
  31 #include "diagnostic.h"
  32 #include "tree-flow.h"
  33 #include "tree-dump.h"
  34 #include "tree-pass.h"
  35 #include "timevar.h"
  36 #include "cfgloop.h"
  37 #include "tree-inline.h"
  38 #include "flags.h"
  39 #include "tree-inline.h"
  40
  41 /* Duplicates headers of loops if they are small enough, so that the statements
  42    in the loop body are always executed when the loop is entered.  This
  43    increases effectiveness of code motion optimizations, and reduces the need
  44    for loop preconditioning.  */
  45
  46 /* Check whether we should duplicate HEADER of LOOP.  At most *LIMIT
  47    instructions should be duplicated, limit is decreased by the actual
  48    amount.  */
  49
  50 static bool
  51 should_duplicate_loop_header_p (basic_block header, struct loop *loop,
  52                                 int *limit)
  53 {
  54   block_stmt_iterator bsi;
  55   tree last;
  56
  57   /* Do not copy one block more than once (we do not really want to do
  58      loop peeling here).  */
  59   if (header->aux)
  60     return false;
  61
  62   gcc_assert (EDGE_COUNT (header->succs) > 0);
  63   if (single_succ_p (header))
  64     return false;
  65   if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest)
  66       && flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 1)->dest))
  67     return false;
  68
  69   /* If this is not the original loop header, we want it to have just
  70      one predecessor in order to match the && pattern.  */
  71   if (header != loop->header && !single_pred_p (header))
  72     return false;
  73
  74   last = last_stmt (header);
  75   if (TREE_CODE (last) != COND_EXPR)
  76     return false;
  77
  78   /* Approximately copy the conditions that used to be used in jump.c --
  79      at most 20 insns and no calls.  */
  80   for (bsi = bsi_start (header); !bsi_end_p (bsi); bsi_next (&bsi))
  81     {
  82       last = bsi_stmt (bsi);
  83
  84       if (TREE_CODE (last) == LABEL_EXPR)
  85         continue;
  86
  87       if (get_call_expr_in (last))
  88         return false;
  89
  90       *limit -= estimate_num_insns (last, &eni_size_weights);
  91       if (*limit < 0)
  92         return false;
  93     }
  94
  95   return true;
  96 }
  97
  98 /* Checks whether LOOP is a do-while style loop.  */
  99
 100 static bool
 101 do_while_loop_p (struct loop *loop)
 102 {
 103   tree stmt = last_stmt (loop->latch);
 104
 105   /* If the latch of the loop is not empty, it is not a do-while loop.  */
 106   if (stmt
 107       && TREE_CODE (stmt) != LABEL_EXPR)
 108     return false;
 109
 110   /* If the header contains just a condition, it is not a do-while loop.  */
 111   stmt = last_and_only_stmt (loop->header);
 112   if (stmt
 113       && TREE_CODE (stmt) == COND_EXPR)
 114     return false;
 115
 116   return true;
 117 }
 118
 119 /* For all loops, copy the condition at the end of the loop body in front
 120    of the loop.  This is beneficial since it increases efficiency of
 121    code motion optimizations.  It also saves one jump on entry to the loop.  */
 122
 123 static unsigned int
 124 copy_loop_headers (void)
 125 {
 126   loop_iterator li;
 127   struct loop *loop;
 128   basic_block header;
 129   edge exit, entry;
 130   basic_block *bbs, *copied_bbs;
 131   unsigned n_bbs;
 132   unsigned bbs_size;
 133
 134   loop_optimizer_init (LOOPS_HAVE_PREHEADERS
 135                        | LOOPS_HAVE_SIMPLE_LATCHES);
 136   if (!current_loops)
 137     return 0;
 138
 139 #ifdef ENABLE_CHECKING
 140   verify_loop_structure ();
 141 #endif
 142
 143   bbs = XNEWVEC (basic_block, n_basic_blocks);
 144   copied_bbs = XNEWVEC (basic_block, n_basic_blocks);
 145   bbs_size = n_basic_blocks;
 146
 147   FOR_EACH_LOOP (li, loop, 0)
 148     {
 149       /* Copy at most 20 insns.  */
 150       int limit = 20;
 151
 152       header = loop->header;
 153
 154       /* If the loop is already a do-while style one (either because it was
 155          written as such, or because jump threading transformed it into one),
 156          we might be in fact peeling the first iteration of the loop.  This
 157          in general is not a good idea.  */
 158       if (do_while_loop_p (loop))
 159         continue;
 160
 161       /* Iterate the header copying up to limit; this takes care of the cases
 162          like while (a && b) {...}, where we want to have both of the conditions
 163          copied.  TODO -- handle while (a || b) - like cases, by not requiring
 164          the header to have just a single successor and copying up to
 165          postdominator.  */
 166
 167       exit = NULL;
 168       n_bbs = 0;
 169       while (should_duplicate_loop_header_p (header, loop, &limit))
 170         {
 171           /* Find a successor of header that is inside a loop; i.e. the new
 172              header after the condition is copied.  */
 173           if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest))
 174             exit = EDGE_SUCC (header, 0);
 175           else
 176             exit = EDGE_SUCC (header, 1);
 177           bbs[n_bbs++] = header;
 178           gcc_assert (bbs_size > n_bbs);
 179           header = exit->dest;
 180         }
 181
 182       if (!exit)
 183         continue;
 184
 185       if (dump_file && (dump_flags & TDF_DETAILS))
 186         fprintf (dump_file,
 187                  "Duplicating header of the loop %d up to edge %d->%d.\n",
 188                  loop->num, exit->src->index, exit->dest->index);
 189
 190       /* Ensure that the header will have just the latch as a predecessor
 191          inside the loop.  */
 192       if (!single_pred_p (exit->dest))
 193         exit = single_pred_edge (split_edge (exit));
 194
 195       entry = loop_preheader_edge (loop);
 196
 197       if (!tree_duplicate_sese_region (entry, exit, bbs, n_bbs, copied_bbs))
 198         {
 199           fprintf (dump_file, "Duplication failed.\n");
 200           continue;
 201         }
 202
 203       /* If the loop has the form "for (i = j; i < j + 10; i++)" then
 204          this copying can introduce a case where we rely on undefined
 205          signed overflow to eliminate the preheader condition, because
 206          we assume that "j < j + 10" is true.  We don't want to warn
 207          about that case for -Wstrict-overflow, because in general we
 208          don't warn about overflow involving loops.  Prevent the
 209          warning by setting TREE_NO_WARNING.  */
 210       if (warn_strict_overflow > 0)
 211         {
 212           unsigned int i;
 213
 214           for (i = 0; i < n_bbs; ++i)
 215             {
 216               tree last;
 217
 218               last = last_stmt (copied_bbs[i]);
 219               if (TREE_CODE (last) == COND_EXPR)
 220                 TREE_NO_WARNING (last) = 1;
 221             }
 222         }
 223
 224       /* Ensure that the latch and the preheader is simple (we know that they
 225          are not now, since there was the loop exit condition.  */
 226       split_edge (loop_preheader_edge (loop));
 227       split_edge (loop_latch_edge (loop));
 228     }
 229
 230   free (bbs);
 231   free (copied_bbs);
 232
 233   loop_optimizer_finalize ();
 234   return 0;
 235 }
 236
 237 static bool
 238 gate_ch (void)
 239 {
 240   return flag_tree_ch != 0;
 241 }
 242
 243 struct tree_opt_pass pass_ch =
 244 {
 245   "ch",                                 /* name */
 246   gate_ch,                              /* gate */
 247   copy_loop_headers,                    /* execute */
 248   NULL,                                 /* sub */
 249   NULL,                                 /* next */
 250   0,                                    /* static_pass_number */
 251   TV_TREE_CH,                           /* tv_id */
 252   PROP_cfg | PROP_ssa,                  /* properties_required */
 253   0,                                    /* properties_provided */
 254   0,                                    /* properties_destroyed */
 255   0,                                    /* todo_flags_start */
 256   TODO_cleanup_cfg | TODO_dump_func
 257   | TODO_verify_ssa,                    /* todo_flags_finish */
 258   0                                     /* letter */
 259 };