gcc/tree-ssa-loop-ch.c

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