gcc/tree-ssa-loop-ch.c

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