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 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 "rtl.h"
  26 #include "tm_p.h"
  27 #include "hard-reg-set.h"
  28 #include "basic-block.h"
  29 #include "output.h"
  30 #include "diagnostic.h"
  31 #include "tree-flow.h"
  32 #include "tree-dump.h"
  33 #include "tree-pass.h"
  34 #include "timevar.h"
  35 #include "cfgloop.h"
  36 #include "tree-inline.h"
  37 #include "flags.h"
  38 #include "tree-inline.h"
  39
  40 /* Duplicates headers of loops if they are small enough, so that the statements
  41    in the loop body are always executed when the loop is entered.  This
  42    increases effectiveness of code motion optimizations, and reduces the need
  43    for loop preconditioning.  */
  44
  45 /* Check whether we should duplicate HEADER of LOOP.  At most *LIMIT
  46    instructions should be duplicated, limit is decreased by the actual
  47    amount.  */
  48
  49 static bool
  50 should_duplicate_loop_header_p (basic_block header, struct loop *loop,
  51                                 int *limit)
  52 {
  53   block_stmt_iterator bsi;
  54   tree last;
  55
  56   /* Do not copy one block more than once (we do not really want to do
  57      loop peeling here).  */
  58   if (header->aux)
  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 (TREE_CODE (last) != COND_EXPR)
  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 = bsi_start (header); !bsi_end_p (bsi); bsi_next (&bsi))
  80     {
  81       last = bsi_stmt (bsi);
  82
  83       if (TREE_CODE (last) == LABEL_EXPR)
  84         continue;
  85
  86       if (get_call_expr_in (last))
  87         return false;
  88
  89       *limit -= estimate_num_insns (last, &eni_size_weights);
  90       if (*limit < 0)
  91         return false;
  92     }
  93
  94   return true;
  95 }
  96
  97 /* Checks whether LOOP is a do-while style loop.  */
  98
  99 static bool
 100 do_while_loop_p (struct loop *loop)
 101 {
 102   tree stmt = last_stmt (loop->latch);
 103
 104   /* If the latch of the loop is not empty, it is not a do-while loop.  */
 105   if (stmt
 106       && TREE_CODE (stmt) != LABEL_EXPR)
 107     return false;
 108
 109   /* If the header contains just a condition, it is not a do-while loop.  */
 110   stmt = last_and_only_stmt (loop->header);
 111   if (stmt
 112       && TREE_CODE (stmt) == COND_EXPR)
 113     return false;
 114
 115   return true;
 116 }
 117
 118 /* For all loops, copy the condition at the end of the loop body in front
 119    of the loop.  This is beneficial since it increases efficiency of
 120    code motion optimizations.  It also saves one jump on entry to the loop.  */
 121
 122 static unsigned int
 123 copy_loop_headers (void)
 124 {
 125   loop_iterator li;
 126   struct loop *loop;
 127   basic_block header;
 128   edge exit, entry;
 129   basic_block *bbs, *copied_bbs;
 130   unsigned n_bbs;
 131   unsigned bbs_size;
 132
 133   loop_optimizer_init (LOOPS_HAVE_PREHEADERS
 134                        | LOOPS_HAVE_SIMPLE_LATCHES);
 135   if (number_of_loops () <= 1)
 136     {
 137       loop_optimizer_finalize ();
 138       return 0;
 139     }
 140
 141 #ifdef ENABLE_CHECKING
 142   verify_loop_structure ();
 143 #endif
 144
 145   bbs = XNEWVEC (basic_block, n_basic_blocks);
 146   copied_bbs = XNEWVEC (basic_block, n_basic_blocks);
 147   bbs_size = n_basic_blocks;
 148
 149   FOR_EACH_LOOP (li, loop, 0)
 150     {
 151       /* Copy at most 20 insns.  */
 152       int limit = 20;
 153
 154       header = loop->header;
 155
 156       /* If the loop is already a do-while style one (either because it was
 157          written as such, or because jump threading transformed it into one),
 158          we might be in fact peeling the first iteration of the loop.  This
 159          in general is not a good idea.  */
 160       if (do_while_loop_p (loop))
 161         continue;
 162
 163       /* Iterate the header copying up to limit; this takes care of the cases
 164          like while (a && b) {...}, where we want to have both of the conditions
 165          copied.  TODO -- handle while (a || b) - like cases, by not requiring
 166          the header to have just a single successor and copying up to
 167          postdominator.  */
 168
 169       exit = NULL;
 170       n_bbs = 0;
 171       while (should_duplicate_loop_header_p (header, loop, &limit))
 172         {
 173           /* Find a successor of header that is inside a loop; i.e. the new
 174              header after the condition is copied.  */
 175           if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest))
 176             exit = EDGE_SUCC (header, 0);
 177           else
 178             exit = EDGE_SUCC (header, 1);
 179           bbs[n_bbs++] = header;
 180           gcc_assert (bbs_size > n_bbs);
 181           header = exit->dest;
 182         }
 183
 184       if (!exit)
 185         continue;
 186
 187       if (dump_file && (dump_flags & TDF_DETAILS))
 188         fprintf (dump_file,
 189                  "Duplicating header of the loop %d up to edge %d->%d.\n",
 190                  loop->num, exit->src->index, exit->dest->index);
 191
 192       /* Ensure that the header will have just the latch as a predecessor
 193          inside the loop.  */
 194       if (!single_pred_p (exit->dest))
 195         exit = single_pred_edge (split_edge (exit));
 196
 197       entry = loop_preheader_edge (loop);
 198
 199       if (!tree_duplicate_sese_region (entry, exit, bbs, n_bbs, copied_bbs))
 200         {
 201           fprintf (dump_file, "Duplication failed.\n");
 202           continue;
 203         }
 204
 205       /* If the loop has the form "for (i = j; i < j + 10; i++)" then
 206          this copying can introduce a case where we rely on undefined
 207          signed overflow to eliminate the preheader condition, because
 208          we assume that "j < j + 10" is true.  We don't want to warn
 209          about that case for -Wstrict-overflow, because in general we
 210          don't warn about overflow involving loops.  Prevent the
 211          warning by setting TREE_NO_WARNING.  */
 212       if (warn_strict_overflow > 0)
 213         {
 214           unsigned int i;
 215
 216           for (i = 0; i < n_bbs; ++i)
 217             {
 218               block_stmt_iterator bsi;
 219
 220               for (bsi = bsi_start (copied_bbs[i]);
 221                    !bsi_end_p (bsi);
 222                    bsi_next (&bsi))
 223                 {
 224                   tree stmt = bsi_stmt (bsi);
 225                   if (TREE_CODE (stmt) == COND_EXPR)
 226                     TREE_NO_WARNING (stmt) = 1;
 227                   else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
 228                     {
 229                       tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 230                       if (COMPARISON_CLASS_P (rhs))
 231                         TREE_NO_WARNING (stmt) = 1;
 232                     }
 233                 }
 234             }
 235         }
 236
 237       /* Ensure that the latch and the preheader is simple (we know that they
 238          are not now, since there was the loop exit condition.  */
 239       split_edge (loop_preheader_edge (loop));
 240       split_edge (loop_latch_edge (loop));
 241     }
 242
 243   free (bbs);
 244   free (copied_bbs);
 245
 246   loop_optimizer_finalize ();
 247   return 0;
 248 }
 249
 250 static bool
 251 gate_ch (void)
 252 {
 253   return flag_tree_ch != 0;
 254 }
 255
 256 struct gimple_opt_pass pass_ch =
 257 {
 258  {
 259   GIMPLE_PASS,
 260   "ch",                                 /* name */
 261   gate_ch,                              /* gate */
 262   copy_loop_headers,                    /* execute */
 263   NULL,                                 /* sub */
 264   NULL,                                 /* next */
 265   0,                                    /* static_pass_number */
 266   TV_TREE_CH,                           /* tv_id */
 267   PROP_cfg | PROP_ssa,                  /* properties_required */
 268   0,                                    /* properties_provided */
 269   0,                                    /* properties_destroyed */
 270   0,                                    /* todo_flags_start */
 271   TODO_cleanup_cfg | TODO_dump_func
 272   | TODO_verify_ssa                     /* todo_flags_finish */
 273  }
 274 };