gcc/tree-ssa-loop-ch.c

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