gcc/tree-ssa-loop-ch.c

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