gcc/tree-optimize.c

   1 /* Top-level control of tree optimizations.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Diego Novillo <dnovillo@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "tm_p.h"
  28 #include "basic-block.h"
  29 #include "flags.h"
  30 #include "tree-flow.h"
  31 #include "function.h"
  32 #include "langhooks.h"
  33 #include "diagnostic-core.h"
  34 #include "toplev.h"
  35 #include "flags.h"
  36 #include "cgraph.h"
  37 #include "tree-inline.h"
  38 #include "tree-pass.h"
  39 #include "ggc.h"
  40 #include "cgraph.h"
  41 #include "graph.h"
  42 #include "cfgloop.h"
  43 #include "except.h"
  44 #include "plugin.h"
  45
  46
  47 /* Pass: cleanup the CFG just before expanding trees to RTL.
  48    This is just a round of label cleanups and case node grouping
  49    because after the tree optimizers have run such cleanups may
  50    be necessary.  */
  51
  52 static unsigned int
  53 execute_cleanup_cfg_post_optimizing (void)
  54 {
  55   unsigned int todo = 0;
  56   if (cleanup_tree_cfg ())
  57     todo |= TODO_update_ssa;
  58   maybe_remove_unreachable_handlers ();
  59   cleanup_dead_labels ();
  60   group_case_labels ();
  61   if ((flag_compare_debug_opt || flag_compare_debug)
  62       && flag_dump_final_insns)
  63     {
  64       FILE *final_output = fopen (flag_dump_final_insns, "a");
  65
  66       if (!final_output)
  67         {
  68           error ("could not open final insn dump file %qs: %m",
  69                  flag_dump_final_insns);
  70           flag_dump_final_insns = NULL;
  71         }
  72       else
  73         {
  74           int save_unnumbered = flag_dump_unnumbered;
  75           int save_noaddr = flag_dump_noaddr;
  76
  77           flag_dump_noaddr = flag_dump_unnumbered = 1;
  78           fprintf (final_output, "\n");
  79           dump_enumerated_decls (final_output, dump_flags | TDF_NOUID);
  80           flag_dump_noaddr = save_noaddr;
  81           flag_dump_unnumbered = save_unnumbered;
  82           if (fclose (final_output))
  83             {
  84               error ("could not close final insn dump file %qs: %m",
  85                      flag_dump_final_insns);
  86               flag_dump_final_insns = NULL;
  87             }
  88         }
  89     }
  90   return todo;
  91 }
  92
  93 struct gimple_opt_pass pass_cleanup_cfg_post_optimizing =
  94 {
  95  {
  96   GIMPLE_PASS,
  97   "optimized",                          /* name */
  98   NULL,                                 /* gate */
  99   execute_cleanup_cfg_post_optimizing,  /* execute */
 100   NULL,                                 /* sub */
 101   NULL,                                 /* next */
 102   0,                                    /* static_pass_number */
 103   TV_TREE_CLEANUP_CFG,                  /* tv_id */
 104   PROP_cfg,                             /* properties_required */
 105   0,                                    /* properties_provided */
 106   0,                                    /* properties_destroyed */
 107   0,                                    /* todo_flags_start */
 108   TODO_remove_unused_locals             /* todo_flags_finish */
 109  }
 110 };
 111
 112 /* IPA passes, compilation of earlier functions or inlining
 113    might have changed some properties, such as marked functions nothrow,
 114    pure, const or noreturn.
 115    Remove redundant edges and basic blocks, and create new ones if necessary.
 116
 117    This pass can't be executed as stand alone pass from pass manager, because
 118    in between inlining and this fixup the verify_flow_info would fail.  */
 119
 120 unsigned int
 121 execute_fixup_cfg (void)
 122 {
 123   basic_block bb;
 124   gimple_stmt_iterator gsi;
 125   int todo = gimple_in_ssa_p (cfun) ? TODO_verify_ssa : 0;
 126   gcov_type count_scale;
 127   edge e;
 128   edge_iterator ei;
 129
 130   if (ENTRY_BLOCK_PTR->count)
 131     count_scale = ((cgraph_get_node (current_function_decl)->count
 132                     * REG_BR_PROB_BASE + ENTRY_BLOCK_PTR->count / 2)
 133                    / ENTRY_BLOCK_PTR->count);
 134   else
 135     count_scale = REG_BR_PROB_BASE;
 136
 137   ENTRY_BLOCK_PTR->count = cgraph_get_node (current_function_decl)->count;
 138   EXIT_BLOCK_PTR->count = (EXIT_BLOCK_PTR->count * count_scale
 139                            + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
 140
 141   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
 142     e->count = (e->count * count_scale
 143        + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
 144
 145   FOR_EACH_BB (bb)
 146     {
 147       bb->count = (bb->count * count_scale
 148                    + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
 149       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 150         {
 151           gimple stmt = gsi_stmt (gsi);
 152           tree decl = is_gimple_call (stmt)
 153                       ? gimple_call_fndecl (stmt)
 154                       : NULL;
 155           if (decl)
 156             {
 157               int flags = gimple_call_flags (stmt);
 158               if (flags & (ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE))
 159                 {
 160                   if (gimple_purge_dead_abnormal_call_edges (bb))
 161                     todo |= TODO_cleanup_cfg;
 162
 163                   if (gimple_in_ssa_p (cfun))
 164                     {
 165                       todo |= TODO_update_ssa | TODO_cleanup_cfg;
 166                       update_stmt (stmt);
 167                     }
 168                 }
 169
 170               if (flags & ECF_NORETURN
 171                   && fixup_noreturn_call (stmt))
 172                 todo |= TODO_cleanup_cfg;
 173              }
 174
 175           if (maybe_clean_eh_stmt (stmt)
 176               && gimple_purge_dead_eh_edges (bb))
 177             todo |= TODO_cleanup_cfg;
 178         }
 179
 180       FOR_EACH_EDGE (e, ei, bb->succs)
 181         e->count = (e->count * count_scale
 182                     + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
 183     }
 184   if (count_scale != REG_BR_PROB_BASE)
 185     compute_function_frequency ();
 186
 187   /* We just processed all calls.  */
 188   if (cfun->gimple_df)
 189     {
 190       VEC_free (gimple, gc, MODIFIED_NORETURN_CALLS (cfun));
 191       MODIFIED_NORETURN_CALLS (cfun) = NULL;
 192     }
 193
 194   /* Dump a textual representation of the flowgraph.  */
 195   if (dump_file)
 196     gimple_dump_cfg (dump_file, dump_flags);
 197
 198   return todo;
 199 }
 200
 201 struct gimple_opt_pass pass_fixup_cfg =
 202 {
 203  {
 204   GIMPLE_PASS,
 205   "*free_cfg_annotations",              /* name */
 206   NULL,                                 /* gate */
 207   execute_fixup_cfg,                    /* execute */
 208   NULL,                                 /* sub */
 209   NULL,                                 /* next */
 210   0,                                    /* static_pass_number */
 211   TV_NONE,                              /* tv_id */
 212   PROP_cfg,                             /* properties_required */
 213   0,                                    /* properties_provided */
 214   0,                                    /* properties_destroyed */
 215   0,                                    /* todo_flags_start */
 216   0                                     /* todo_flags_finish */
 217  }
 218 };