[gc-improv] Patch: easy parts of preparation to clear NEXT_INSN, PREV_INSN, JUMP_LABLE in deleted insns

Laurynas Biveinis laurynas.biveinis@gmail.com
Fri Sep 14 01:38:00 GMT 2007


Hello,

I'm committing the easy and obvious bits of
http://gcc.gnu.org/ml/gcc-patches/2007-09/msg00378.html to the
gc-improv branch. Bootstrapped/regtested on i686-pc-linux-gnu.

2007-09-13  Laurynas Biveinis  <laurynas.biveinis@gmail.com>

        * regrename.c (copyprop_hardreg_forward_1): New variable next.
        Use FOR_BB_INSNS_SAFE.
        * cse.c (cse_extended_basic_block): Likewise.
        * lower-subreg.c (decompose_multiword_subregs): Likewise.
        * postreload.c (reload_cse_regs_1): New variable next. Make sure
        that the for loop does not invoke NEXT_INSN on a deleted insn.
        * function.c (instantiate_virtual_regs): Likewise.
        * reload1.c (reload): New variable next. Make sure that the for
        loop does not invoke NEXT_INSN on a deleted insn.
        (delete_output_reload): New variable prev. Make sure the the for
        loops do not invoke PREV_INSN on a deleted insn.

Index: gcc/regrename.c
===================================================================
--- gcc/regrename.c     (revision 128389)
+++ gcc/regrename.c     (working copy)
@@ -1567,9 +1567,9 @@
 copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 {
   bool changed = false;
-  rtx insn;
+  rtx insn, next;

-  for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
+  FOR_BB_INSNS_SAFE (bb, insn, next)
     {
       int n_ops, i, alt, predicated;
       bool is_asm, any_replacements;
Index: gcc/postreload.c
===================================================================
--- gcc/postreload.c    (revision 128389)
+++ gcc/postreload.c    (working copy)
@@ -195,14 +195,15 @@
 static void
 reload_cse_regs_1 (rtx first)
 {
-  rtx insn;
+  rtx insn, next;
   rtx testreg = gen_rtx_REG (VOIDmode, -1);

   cselib_init (true);
   init_alias_analysis ();

-  for (insn = first; insn; insn = NEXT_INSN (insn))
+  for (insn = first; insn; insn = next)
     {
+      next = NEXT_INSN (insn);
       if (INSN_P (insn))
        reload_cse_simplify (insn, testreg);

Index: gcc/cse.c
===================================================================
--- gcc/cse.c   (revision 128389)
+++ gcc/cse.c   (working copy)
@@ -6019,12 +6019,12 @@
   for (path_entry = 0; path_entry < path_size; path_entry++)
     {
       basic_block bb;
-      rtx insn;
+      rtx insn, next;
       rtx libcall_insn = NULL_RTX;
       int no_conflict = 0;

       bb = ebb_data->path[path_entry].bb;
-      FOR_BB_INSNS (bb, insn)
+      FOR_BB_INSNS_SAFE (bb, insn, next)
        {
          /* If we have processed 1,000 insns, flush the hash table to
             avoid extreme quadratic behavior.  We must not include NOTEs
Index: gcc/function.c
===================================================================
--- gcc/function.c      (revision 128389)
+++ gcc/function.c      (working copy)
@@ -1666,7 +1666,7 @@
 static unsigned int
 instantiate_virtual_regs (void)
 {
-  rtx insn;
+  rtx insn, next;

   /* Compute the offsets to use for this function.  */
   in_arg_offset = FIRST_PARM_OFFSET (current_function_decl);
@@ -1684,30 +1684,34 @@

   /* Scan through all the insns, instantiating every virtual register still
      present.  */
-  for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
-    if (INSN_P (insn))
-      {
-       /* These patterns in the instruction stream can never be recognized.
-          Fortunately, they shouldn't contain virtual registers either.  */
-       if (GET_CODE (PATTERN (insn)) == USE
-           || GET_CODE (PATTERN (insn)) == CLOBBER
-           || GET_CODE (PATTERN (insn)) == ADDR_VEC
-           || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
-           || GET_CODE (PATTERN (insn)) == ASM_INPUT)
-         continue;
+  for (insn = get_insns (); insn; insn = next)
+    {
+      next = NEXT_INSN (insn);
+      if (INSN_P (insn))
+        {
+          /* These patterns in the instruction stream can never be recognized.
+             Fortunately, they shouldn't contain virtual registers either.  */
+          if (GET_CODE (PATTERN (insn)) == USE
+              || GET_CODE (PATTERN (insn)) == CLOBBER
+              || GET_CODE (PATTERN (insn)) == ADDR_VEC
+              || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
+              || GET_CODE (PATTERN (insn)) == ASM_INPUT)
+            continue;

-       instantiate_virtual_regs_in_insn (insn);
+          instantiate_virtual_regs_in_insn (insn);

-       if (INSN_DELETED_P (insn))
-         continue;
+          if (INSN_DELETED_P (insn))
+            continue;

-       for_each_rtx (&REG_NOTES (insn), instantiate_virtual_regs_in_rtx, NULL);
+          for_each_rtx (&REG_NOTES (insn), instantiate_virtual_regs_in_rtx,
+                        NULL);

-       /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
-       if (GET_CODE (insn) == CALL_INSN)
-         for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn),
-                       instantiate_virtual_regs_in_rtx, NULL);
-      }
+          /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
+          if (GET_CODE (insn) == CALL_INSN)
+            for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn),
+                          instantiate_virtual_regs_in_rtx, NULL);
+        }
+    }

   /* Instantiate the virtual registers in the DECLs for debugging purposes.  */
   instantiate_decls (current_function_decl);
Index: gcc/lower-subreg.c
===================================================================
--- gcc/lower-subreg.c  (revision 128389)
+++ gcc/lower-subreg.c  (working copy)
@@ -1254,9 +1254,9 @@

       FOR_EACH_BB (bb)
        {
-         rtx insn;
+          rtx insn, next_insn;

-         FOR_BB_INSNS (bb, insn)
+          FOR_BB_INSNS_SAFE (bb, insn, next_insn)
            {
              rtx next, pat;

Index: gcc/reload1.c
===================================================================
--- gcc/reload1.c       (revision 128389)
+++ gcc/reload1.c       (working copy)
@@ -702,7 +702,7 @@
 reload (rtx first, int global)
 {
   int i;
-  rtx insn;
+  rtx insn, next;
   struct elim_table *ep;
   basic_block bb;

@@ -1227,87 +1227,91 @@
      are no longer useful or accurate.  Strip and regenerate REG_INC notes
      that may have been moved around.  */

-  for (insn = first; insn; insn = NEXT_INSN (insn))
-    if (INSN_P (insn))
-      {
-       rtx *pnote;
+  for (insn = first; insn; insn = next)
+    {
+      next = NEXT_INSN (insn);
+      if (INSN_P (insn))
+        {
+          rtx *pnote;

-       if (CALL_P (insn))
-         replace_pseudos_in (& CALL_INSN_FUNCTION_USAGE (insn),
-                             VOIDmode, CALL_INSN_FUNCTION_USAGE (insn));
+          if (CALL_P (insn))
+            replace_pseudos_in (& CALL_INSN_FUNCTION_USAGE (insn),
+                                VOIDmode, CALL_INSN_FUNCTION_USAGE (insn));

-       if ((GET_CODE (PATTERN (insn)) == USE
-            /* We mark with QImode USEs introduced by reload itself.  */
-            && (GET_MODE (insn) == QImode
-                || find_reg_note (insn, REG_EQUAL, NULL_RTX)))
-           || (GET_CODE (PATTERN (insn)) == CLOBBER
-               && (!MEM_P (XEXP (PATTERN (insn), 0))
-                   || GET_MODE (XEXP (PATTERN (insn), 0)) != BLKmode
-                   || (GET_CODE (XEXP (XEXP (PATTERN (insn), 0), 0)) != SCRATCH
-                       && XEXP (XEXP (PATTERN (insn), 0), 0)
-                               != stack_pointer_rtx))
-               && (!REG_P (XEXP (PATTERN (insn), 0))
-                   || ! REG_FUNCTION_VALUE_P (XEXP (PATTERN (insn), 0)))))
-         {
-           delete_insn (insn);
-           continue;
-         }
+          if ((GET_CODE (PATTERN (insn)) == USE
+               /* We mark with QImode USEs introduced by reload itself.  */
+               && (GET_MODE (insn) == QImode
+                   || find_reg_note (insn, REG_EQUAL, NULL_RTX)))
+              || (GET_CODE (PATTERN (insn)) == CLOBBER
+                  && (!MEM_P (XEXP (PATTERN (insn), 0))
+                      || GET_MODE (XEXP (PATTERN (insn), 0)) != BLKmode
+                      || (GET_CODE (XEXP (XEXP (PATTERN (insn), 0), 0))
+                          != SCRATCH
+                          && XEXP (XEXP (PATTERN (insn), 0), 0)
+                          != stack_pointer_rtx))
+                  && (!REG_P (XEXP (PATTERN (insn), 0))
+                      || ! REG_FUNCTION_VALUE_P (XEXP (PATTERN (insn), 0)))))
+            {
+              delete_insn (insn);
+              continue;
+            }

-       /* Some CLOBBERs may survive until here and still reference unassigned
-          pseudos with const equivalent, which may in turn cause ICE in later
-          passes if the reference remains in place.  */
-       if (GET_CODE (PATTERN (insn)) == CLOBBER)
-         replace_pseudos_in (& XEXP (PATTERN (insn), 0),
-                             VOIDmode, PATTERN (insn));
+          /* Some CLOBBERs may survive until here and still reference
+             unassigned pseudos with const equivalent, which may in turn cause
+             ICE in later passes if the reference remains in place.  */
+          if (GET_CODE (PATTERN (insn)) == CLOBBER)
+            replace_pseudos_in (& XEXP (PATTERN (insn), 0),
+                                VOIDmode, PATTERN (insn));

-       /* Discard obvious no-ops, even without -O.  This optimization
-          is fast and doesn't interfere with debugging.  */
-       if (NONJUMP_INSN_P (insn)
-           && GET_CODE (PATTERN (insn)) == SET
-           && REG_P (SET_SRC (PATTERN (insn)))
-           && REG_P (SET_DEST (PATTERN (insn)))
-           && (REGNO (SET_SRC (PATTERN (insn)))
-               == REGNO (SET_DEST (PATTERN (insn)))))
-         {
-           delete_insn (insn);
-           continue;
-         }
+          /* Discard obvious no-ops, even without -O.  This optimization
+             is fast and doesn't interfere with debugging.  */
+          if (NONJUMP_INSN_P (insn)
+              && GET_CODE (PATTERN (insn)) == SET
+              && REG_P (SET_SRC (PATTERN (insn)))
+              && REG_P (SET_DEST (PATTERN (insn)))
+              && (REGNO (SET_SRC (PATTERN (insn)))
+                  == REGNO (SET_DEST (PATTERN (insn)))))
+            {
+              delete_insn (insn);
+              continue;
+            }

-       pnote = &REG_NOTES (insn);
-       while (*pnote != 0)
-         {
-           if (REG_NOTE_KIND (*pnote) == REG_DEAD
-               || REG_NOTE_KIND (*pnote) == REG_UNUSED
-               || REG_NOTE_KIND (*pnote) == REG_INC
-               || REG_NOTE_KIND (*pnote) == REG_RETVAL
-               || REG_NOTE_KIND (*pnote) == REG_LIBCALL_ID
-               || REG_NOTE_KIND (*pnote) == REG_LIBCALL)
-             *pnote = XEXP (*pnote, 1);
-           else
-             pnote = &XEXP (*pnote, 1);
-         }
+          pnote = &REG_NOTES (insn);
+          while (*pnote != 0)
+            {
+              if (REG_NOTE_KIND (*pnote) == REG_DEAD
+                  || REG_NOTE_KIND (*pnote) == REG_UNUSED
+                  || REG_NOTE_KIND (*pnote) == REG_INC
+                  || REG_NOTE_KIND (*pnote) == REG_RETVAL
+                  || REG_NOTE_KIND (*pnote) == REG_LIBCALL_ID
+                  || REG_NOTE_KIND (*pnote) == REG_LIBCALL)
+                *pnote = XEXP (*pnote, 1);
+              else
+                pnote = &XEXP (*pnote, 1);
+            }

 #ifdef AUTO_INC_DEC
-       add_auto_inc_notes (insn, PATTERN (insn));
+          add_auto_inc_notes (insn, PATTERN (insn));
 #endif

-       /* Simplify (subreg (reg)) if it appears as an operand.  */
-       cleanup_subreg_operands (insn);
+          /* Simplify (subreg (reg)) if it appears as an operand.  */
+          cleanup_subreg_operands (insn);

-       /* Clean up invalid ASMs so that they don't confuse later passes.
-          See PR 21299.  */
-       if (asm_noperands (PATTERN (insn)) >= 0)
-         {
-           extract_insn (insn);
-           if (!constrain_operands (1))
-             {
-               error_for_asm (insn,
-                              "%<asm%> operand has impossible constraints");
-               delete_insn (insn);
-               continue;
-             }
-         }
-      }
+          /* Clean up invalid ASMs so that they don't confuse later passes.
+             See PR 21299.  */
+          if (asm_noperands (PATTERN (insn)) >= 0)
+            {
+              extract_insn (insn);
+              if (!constrain_operands (1))
+                {
+                  error_for_asm (insn,
+                                 "%<asm%> operand has impossible constraints");
+                  delete_insn (insn);
+                  continue;
+                }
+            }
+        }
+    }

   /* If we are doing stack checking, give a warning if this function's
      frame size is larger than we expect.  */
@@ -8189,15 +8193,17 @@
       && REG_BASIC_BLOCK (REGNO (reg)) >= NUM_FIXED_BLOCKS
       && find_regno_note (insn, REG_DEAD, REGNO (reg)))
     {
-      rtx i2;
+      rtx i2, prev;

       /* We know that it was used only between here and the beginning of
         the current basic block.  (We also know that the last use before
         INSN was the output reload we are thinking of deleting, but never
         mind that.)  Search that range; see if any ref remains.  */
-      for (i2 = PREV_INSN (insn); i2; i2 = PREV_INSN (i2))
+      for (i2 = PREV_INSN (insn); i2; i2 = prev)
        {
-         rtx set = single_set (i2);
+          rtx set;
+          prev = PREV_INSN (i2);
+          set = single_set (i2);

          /* Uses which just store in the pseudo don't count,
             since if they are the only uses, they are dead.  */
@@ -8219,9 +8225,11 @@

       /* Delete the now-dead stores into this pseudo.  Note that this
         loop also takes care of deleting output_reload_insn.  */
-      for (i2 = PREV_INSN (insn); i2; i2 = PREV_INSN (i2))
+      for (i2 = PREV_INSN (insn); i2; i2 = prev)
        {
-         rtx set = single_set (i2);
+          rtx set;
+          prev = PREV_INSN (i2);
+          set = single_set (i2);

          if (set != 0 && SET_DEST (set) == reg)
            {

-- 
Laurynas



More information about the Gcc-patches mailing list