[gcc] GCC 4.5.0=>4.5.1

gcc/gcc/dce.c

 /* RTL dead code elimination.
    Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 Software Foundation; either version 3, or (at your option) any later
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "hashtab.h"
 #include "tm.h"
 #include "rtl.h"
 #include "tree.h"
 #include "regs.h"
 #include "hard-reg-set.h"
 #include "flags.h"
+#include "except.h"
 #include "df.h"
 #include "cselib.h"
 #include "dce.h"
 #include "timevar.h"
 #include "tree-pass.h"
 #include "dbgcnt.h"
 #include "tm_p.h"
 
-DEF_VEC_I(int);
-DEF_VEC_ALLOC_I(int,heap);
-
 
 /* -------------------------------------------------------------------------
    Core mark/delete routines
    ------------------------------------------------------------------------- */
 
 /* True if we are invoked while the df engine is running; in this case,
    we don't want to reenter it.  */
 static bool df_in_progress = false;
 
 /* Instructions that have been marked but whose dependencies have not
@@ skipping 23 matching lines @@
       /* The UNSPEC case was added here because the ia-64 claims that
          USEs do not work after reload and generates UNSPECS rather
          than USEs.  Since dce is run after reload we need to avoid
          deleting these even if they are dead.  If it turns out that
          USEs really do work after reload, the ia-64 should be
          changed, and the UNSPEC case can be removed.  */
     case UNSPEC:
       return false;
 
     default:
-      if (volatile_refs_p (body))
-        return false;
-
-      if (flag_non_call_exceptions && may_trap_p (body))
-        return false;
-
-      return true;
+      return !volatile_refs_p (body);
     }
 }
 
 
 /* Return true if INSN is a normal instruction that can be deleted by
    the DCE pass.  */
 
 static bool
 deletable_insn_p (rtx insn, bool fast, bitmap arg_stores)
 {
   rtx body, x;
   int i;
 
   if (CALL_P (insn)
       /* We cannot delete calls inside of the recursive dce because
          this may cause basic blocks to be deleted and this messes up
          the rest of the stack of optimization passes.  */
       && (!df_in_progress)
       /* We cannot delete pure or const sibling calls because it is
          hard to see the result.  */
       && (!SIBLING_CALL_P (insn))
       /* We can delete dead const or pure calls as long as they do not
          infinite loop.  */
       && (RTL_CONST_OR_PURE_CALL_P (insn)
           && !RTL_LOOPING_CONST_OR_PURE_CALL_P (insn)))
     return find_call_stack_args (insn, false, fast, arg_stores);
 
+  /* Don't delete jumps, notes and the like.  */
   if (!NONJUMP_INSN_P (insn))
     return false;
 
+  /* Don't delete insns that can throw.  */
+  if (!insn_nothrow_p (insn))
+    return false;
+
   body = PATTERN (insn);
   switch (GET_CODE (body))
     {
     case USE:
+    case VAR_LOCATION:
       return false;
 
     case CLOBBER:
       if (fast)
         {
           /* A CLOBBER of a dead pseudo register serves no purpose.
              That is not necessarily true for hard registers until
              after reload.  */
           x = XEXP (body, 0);
           return REG_P (x) && (!HARD_REGISTER_P (x) || reload_completed);
@@ skipping 210 matching lines @@
 
             for (defs = DF_REF_CHAIN (*use_rec); defs; defs = defs->next)
               if (! DF_REF_IS_ARTIFICIAL (defs->ref))
                 break;
 
             set = single_set (DF_REF_INSN (defs->ref));
             off += INTVAL (XEXP (SET_SRC (set), 1));
           }
         for (byte = off; byte < off + INTVAL (MEM_SIZE (mem)); byte++)
           {
-            gcc_assert (!bitmap_bit_p (sp_bytes, byte - min_sp_off));
-            bitmap_set_bit (sp_bytes, byte - min_sp_off);
+            if (!bitmap_set_bit (sp_bytes, byte - min_sp_off))
+              gcc_unreachable ();
           }
       }
 
   /* Walk backwards, looking for argument stores.  The search stops
      when seeing another call, sp adjustment or memory store other than
      argument store.  */
   ret = false;
   for (insn = PREV_INSN (call_insn); insn; insn = prev_insn)
     {
       rtx set, mem, addr;
@@ skipping 66 matching lines @@
             break;
         }
 
       if (GET_MODE_SIZE (GET_MODE (mem)) == 0)
         break;
 
       for (byte = off; byte < off + GET_MODE_SIZE (GET_MODE (mem)); byte++)
         {
           if (byte < min_sp_off
               || byte >= max_sp_off
-              || !bitmap_bit_p (sp_bytes, byte - min_sp_off))
+              || !bitmap_clear_bit (sp_bytes, byte - min_sp_off))
             break;
-          bitmap_clear_bit (sp_bytes, byte - min_sp_off);
         }
 
       if (!deletable_insn_p (insn, fast, NULL))
         break;
 
       if (do_mark)
         mark_insn (insn, fast);
       else
         bitmap_set_bit (arg_stores, INSN_UID (insn));
 
@@ skipping 162 matching lines @@
 
 static void
 mark_artificial_uses (void)
 {
   basic_block bb;
   struct df_link *defs;
   df_ref *use_rec;
 
   FOR_ALL_BB (bb)
     {
-      for (use_rec = df_get_artificial_uses (bb->index); 
+      for (use_rec = df_get_artificial_uses (bb->index);
            *use_rec; use_rec++)
         for (defs = DF_REF_CHAIN (*use_rec); defs; defs = defs->next)
           if (! DF_REF_IS_ARTIFICIAL (defs->ref))
             mark_insn (DF_REF_INSN (defs->ref), false);
     }
 }
 
 
 /* Mark every instruction that defines a register value that INSN uses.  */
 
 static void
 mark_reg_dependencies (rtx insn)
 {
   struct df_link *defs;
   df_ref *use_rec;
 
+  if (DEBUG_INSN_P (insn))
+    return;
+
   for (use_rec = DF_INSN_USES (insn); *use_rec; use_rec++)
     {
       df_ref use = *use_rec;
       if (dump_file)
         {
           fprintf (dump_file, "Processing use of ");
           print_simple_rtl (dump_file, DF_REF_REG (use));
           fprintf (dump_file, " in insn %d:\n", INSN_UID (insn));
         }
       for (defs = DF_REF_CHAIN (use); defs; defs = defs->next)
@@ skipping 76 matching lines @@
 gate_ud_dce (void)
 {
   return optimize > 1 && flag_dce
     && dbg_cnt (dce_ud);
 }
 
 struct rtl_opt_pass pass_ud_rtl_dce =
 {
  {
   RTL_PASS,
-  "dce",                                /* name */
-  gate_ud_dce,                        /* gate */
-  rest_of_handle_ud_dce,              /* execute */
+  "ud dce",                             /* name */
+  gate_ud_dce,                          /* gate */
+  rest_of_handle_ud_dce,                /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
   TV_DCE,                               /* tv_id */
   0,                                    /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_dump_func |
   TODO_df_finish | TODO_verify_rtl_sharing |
@@ skipping 64 matching lines @@
               {
                 start += sb;
                 len = lb - sb;
               }
 
             if (bitmap_bit_p (au, dregno))
               {
                 mark_insn (insn, true);
                 goto quickexit;
               }
-            
+
             last = start + len;
             while (start < last)
               if (bitmap_bit_p (local_live, start++))
                 {
                   mark_insn (insn, true);
                   goto quickexit;
                 }
           }
-        
-      quickexit: 
-        
+
+      quickexit:
+
         /* No matter if the instruction is needed or not, we remove
            any regno in the defs from the live set.  */
         df_byte_lr_simulate_defs (insn, local_live);
 
         /* On the other hand, we do not allow the dead uses to set
            anything in local_live.  */
         if (marked_insn_p (insn))
           df_byte_lr_simulate_uses (insn, local_live);
 
         if (dump_file)
           {
-            fprintf (dump_file, "finished processing insn %d live out = ", 
+            fprintf (dump_file, "finished processing insn %d live out = ",
                      INSN_UID (insn));
             df_print_byte_regset (dump_file, local_live);
           }
       }
-  
+
   df_byte_lr_simulate_artificial_refs_at_top (bb, local_live);
 
   block_changed = !bitmap_equal_p (local_live, DF_BYTE_LR_IN (bb));
   if (block_changed)
     bitmap_copy (DF_BYTE_LR_IN (bb), local_live);
   BITMAP_FREE (local_live);
   return block_changed;
 }
 
 
@@ skipping 39 matching lines @@
         bool needed = false;
 
         /* The insn is needed if there is someone who uses the output.  */
         for (def_rec = DF_INSN_DEFS (insn); *def_rec; def_rec++)
           if (bitmap_bit_p (local_live, DF_REF_REGNO (*def_rec))
               || bitmap_bit_p (au, DF_REF_REGNO (*def_rec)))
             {
               needed = true;
               break;
             }
-            
+
         if (needed)
           mark_insn (insn, true);
-        
+
         /* No matter if the instruction is needed or not, we remove
            any regno in the defs from the live set.  */
         df_simulate_defs (insn, local_live);
 
         /* On the other hand, we do not allow the dead uses to set
            anything in local_live.  */
         if (marked_insn_p (insn))
           df_simulate_uses (insn, local_live);
       }
-  
+
   df_simulate_finalize_backwards (bb, local_live);
 
   block_changed = !bitmap_equal_p (local_live, DF_LR_IN (bb));
   if (block_changed)
     bitmap_copy (DF_LR_IN (bb), local_live);
 
   BITMAP_FREE (local_live);
   return block_changed;
 }
 
@@ skipping 39 matching lines @@
           basic_block bb = BASIC_BLOCK (index);
           bool local_changed;
 
           if (index < NUM_FIXED_BLOCKS)
             {
               bitmap_set_bit (processed, index);
               continue;
             }
 
           if (byte_level)
-            local_changed 
+            local_changed
               = byte_dce_process_block (bb, bitmap_bit_p (redo_out, index),
                                           bb_has_eh_pred (bb) ? au_eh : au);
           else
-            local_changed 
+            local_changed
               = dce_process_block (bb, bitmap_bit_p (redo_out, index),
                                    bb_has_eh_pred (bb) ? au_eh : au);
           bitmap_set_bit (processed, index);
-          
+
           if (local_changed)
             {
               edge e;
               edge_iterator ei;
               FOR_EACH_EDGE (e, ei, bb->preds)
                 if (bitmap_bit_p (processed, e->src->index))
                   /* Be tricky about when we need to iterate the
                      analysis.  We only have redo the analysis if the
                      bitmaps change at the top of a block that is the
                      entry to a loop.  */
                   global_changed = true;
                 else
                   bitmap_set_bit (redo_out, e->src->index);
             }
         }
-      
+
       if (global_changed)
         {
           /* Turn off the RUN_DCE flag to prevent recursive calls to
              dce.  */
           int old_flag = df_clear_flags (DF_LR_RUN_DCE);
 
           /* So something was deleted that requires a redo.  Do it on
              the cheap.  */
           delete_unmarked_insns ();
           sbitmap_zero (marked);
           bitmap_clear (processed);
           bitmap_clear (redo_out);
-          
+
           /* We do not need to rescan any instructions.  We only need
              to redo the dataflow equations for the blocks that had a
              change at the top of the block.  Then we need to redo the
-             iteration.  */ 
+             iteration.  */
           if (byte_level)
             df_analyze_problem (df_byte_lr, all_blocks, postorder, n_blocks);
           else
             df_analyze_problem (df_lr, all_blocks, postorder, n_blocks);
 
           if (old_flag & DF_LR_RUN_DCE)
             df_set_flags (DF_LR_RUN_DCE);
 
           prescan_insns_for_dce (true);
         }
@@ skipping 42 matching lines @@
    vectors for any other problems than LR.  */
 
 void
 run_fast_df_dce (void)
 {
   if (flag_dce)
     {
       /* If dce is able to delete something, it has to happen
          immediately.  Otherwise there will be problems handling the
          eq_notes.  */
-      enum df_changeable_flags old_flags 
-        = df_clear_flags (DF_DEFER_INSN_RESCAN + DF_NO_INSN_RESCAN);
-      
+      int old_flags =
+        df_clear_flags (DF_DEFER_INSN_RESCAN + DF_NO_INSN_RESCAN);
+
       df_in_progress = true;
       rest_of_handle_fast_dce ();
       df_in_progress = false;
 
       df_set_flags (old_flags);
     }
 }
 
 
 /* Run a fast DCE pass.  */
@@ skipping 10 matching lines @@
 gate_fast_dce (void)
 {
   return optimize > 0 && flag_dce
     && dbg_cnt (dce_fast);
 }
 
 struct rtl_opt_pass pass_fast_rtl_dce =
 {
  {
   RTL_PASS,
-  "dce",                                /* name */
+  "rtl dce",                            /* name */
   gate_fast_dce,                        /* gate */
   rest_of_handle_fast_dce,              /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
   TV_DCE,                               /* tv_id */
   0,                                    /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
@@ skipping 16 matching lines @@
   TV_DCE,                               /* tv_id */
   0,                                    /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_dump_func |
   TODO_df_finish | TODO_verify_rtl_sharing |
   TODO_ggc_collect                      /* todo_flags_finish */
  }
 };