* recog.c (split_insn): Break out from ...

	(split_all_insns): ... here; do not use basic block information
	when it is broken.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@43009 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 535c965..45f1eb2 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+Fri Jun  8 14:16:33 CEST 2001  Jan Hubicka  <jh@suse.cz>
+
+       * recog.c (split_insn): Break out from ...
+       (split_all_insns): ... here; do not use basic block information
+       when it is broken.
+
 Thu Jun  7 18:27:53 CEST 2001  Jan Hubicka  <jh@suse.cz>
 
        * simplify-rtx.c (simplify_subreg):  Fix verification of

diff --git a/gcc/recog.c b/gcc/recog.c
index 888a2f5..c823ea1 100644 (file)
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -57,6 +57,7 @@ static void validate_replace_rtx_1    PARAMS ((rtx *, rtx, rtx, rtx));
 static rtx *find_single_use_1          PARAMS ((rtx, rtx *));
 static rtx *find_constant_term_loc     PARAMS ((rtx *));
 static void validate_replace_src_1     PARAMS ((rtx *, void *));
+static rtx split_insn                  PARAMS ((rtx));
 
 /* Nonzero means allow operands to be volatile.
    This should be 0 if you are generating rtl, such as if you are calling
@@ -2700,6 +2701,66 @@ reg_fits_class_p (operand, class, offset, mode)
   return 0;
 }
 \f
+/* Split single instruction.  Helper function for split_all_insns.
+   Return last insn in the sequence if succesfull, or NULL if unsuccesfull.  */
+static rtx
+split_insn (insn)
+     rtx insn;
+{
+  rtx set;
+  if (!INSN_P (insn))
+    ;
+  /* Don't split no-op move insns.  These should silently
+     disappear later in final.  Splitting such insns would
+     break the code that handles REG_NO_CONFLICT blocks.  */
+
+  else if ((set = single_set (insn)) != NULL && set_noop_p (set))
+    {
+      /* Nops get in the way while scheduling, so delete them
+         now if register allocation has already been done.  It
+         is too risky to try to do this before register
+         allocation, and there are unlikely to be very many
+         nops then anyways.  */
+      if (reload_completed)
+       {
+         PUT_CODE (insn, NOTE);
+         NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
+         NOTE_SOURCE_FILE (insn) = 0;
+       }
+    }
+  else
+    {
+      /* Split insns here to get max fine-grain parallelism.  */
+      rtx first = PREV_INSN (insn);
+      rtx last = try_split (PATTERN (insn), insn, 1);
+
+      if (last != insn)
+       {
+         /* try_split returns the NOTE that INSN became.  */
+         PUT_CODE (insn, NOTE);
+         NOTE_SOURCE_FILE (insn) = 0;
+         NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
+
+         /* ??? Coddle to md files that generate subregs in post-
+            reload splitters instead of computing the proper 
+            hard register.  */
+         if (reload_completed && first != last)
+           {
+             first = NEXT_INSN (first);
+             while (1)
+               {
+                 if (INSN_P (first))
+                   cleanup_subreg_operands (first);
+                 if (first == last)
+                   break;
+                 first = NEXT_INSN (first);
+               }
+           }
+         return last;
+       }
+    }
+  return NULL_RTX;
+}
 /* Split all insns in the function.  If UPD_LIFE, update life info after.  */
 
 void
@@ -2710,6 +2771,22 @@ split_all_insns (upd_life)
   int changed;
   int i;
 
+  if (!upd_life)
+    {
+      rtx next, insn;
+
+      for (insn = get_insns (); insn ; insn = next)
+       {
+         rtx last;
+
+         /* Can't use `next_real_insn' because that might go across
+            CODE_LABELS and short-out basic blocks.  */
+         next = NEXT_INSN (insn);
+         last = split_insn (insn);
+       }
+      return;
+    }
+
   blocks = sbitmap_alloc (n_basic_blocks);
   sbitmap_zero (blocks);
   changed = 0;
@@ -2721,82 +2798,26 @@ split_all_insns (upd_life)
 
       for (insn = bb->head; insn ; insn = next)
        {
-         rtx set;
+         rtx last;
 
          /* Can't use `next_real_insn' because that might go across
             CODE_LABELS and short-out basic blocks.  */
          next = NEXT_INSN (insn);
-         if (! INSN_P (insn))
-           ;
-
-         /* Don't split no-op move insns.  These should silently
-            disappear later in final.  Splitting such insns would
-            break the code that handles REG_NO_CONFLICT blocks.  */
-
-         else if ((set = single_set (insn)) != NULL
-                  && set_noop_p (set))
+         last = split_insn (insn);
+         if (last)
            {
-             /* Nops get in the way while scheduling, so delete them
-                now if register allocation has already been done.  It
-                is too risky to try to do this before register
-                allocation, and there are unlikely to be very many
-                nops then anyways.  */
-             if (reload_completed)
-               {
-                 PUT_CODE (insn, NOTE);
-                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
-                 NOTE_SOURCE_FILE (insn) = 0;
-               }
-           }
-         else
-           {
-             /* Split insns here to get max fine-grain parallelism.  */
-             rtx first = PREV_INSN (insn);
-             rtx last = try_split (PATTERN (insn), insn, 1);
-
-             if (last != insn)
-               {
-                 SET_BIT (blocks, i);
-                 changed = 1;
-
-                 /* try_split returns the NOTE that INSN became.  */
-                 PUT_CODE (insn, NOTE);
-                 NOTE_SOURCE_FILE (insn) = 0;
-                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
-
-                 /* ??? Coddle to md files that generate subregs in post-
-                    reload splitters instead of computing the proper 
-                    hard register.  */
-                 if (reload_completed && first != last)
-                   {
-                     first = NEXT_INSN (first);
-                     while (1)
-                       {
-                         if (INSN_P (first))
-                           cleanup_subreg_operands (first);
-                         if (first == last)
-                           break;
-                         first = NEXT_INSN (first);
-                       }
-                   }
-
-                 if (insn == bb->end)
-                   {
-                     bb->end = last;
-                     break;
-                   }
-               }
+             SET_BIT (blocks, i);
+             changed = 1;
+             if (insn == bb->end)
+               bb->end = last;
+             insn = last;
            }
 
          if (insn == bb->end)
            break;
        }
 
-      /* ??? When we're called from just after reload, the CFG is in bad
-        shape, and we may have fallen off the end.  This could be fixed
-        by having reload not try to delete unreachable code.  Otherwise
-        assert we found the end insn.  */
-      if (insn == NULL && upd_life)
+      if (insn == NULL)
        abort ();
     }