cse.c: Update comments.

        * cse.c: Update comments.
        (cse_insn): When converting a conditional/computed jump into
        an unconditional jump, always make sure a BARRIER immediately
        follows the converted jump.  Do not delete unreachable code.
        (cse_basic_block): Do not delete unreachable code.
        * toplev.c (rest_of_compilation): Move call to
        delete_trivially_dead_insns after the conditional call to
        jump_optimize.

From-SVN: r29665

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 258efbb..13ee0e9 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+Sat Sep 25 13:11:07 1999  Jeffrey A Law  (law@cygnus.com)
+
+       * cse.c: Update comments.
+       (cse_insn): When converting a conditional/computed jump into
+       an unconditional jump, always make sure a BARRIER immediately
+       follows the converted jump.  Do not delete unreachable code.
+       (cse_basic_block): Do not delete unreachable code.
+       * toplev.c (rest_of_compilation): Move call to 
+       delete_trivially_dead_insns after the conditional call to
+       jump_optimize.
+
 Sat Sep 25 09:03:17 1999  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
        * collect2.c (make_temp_file): Don't prototype.

diff --git a/gcc/cse.c b/gcc/cse.c
index 8275974..d9ed625 100644 (file)
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -45,12 +45,14 @@ Boston, MA 02111-1307, USA.  */
    expressions encountered with the cheapest equivalent expression.
 
    It is too complicated to keep track of the different possibilities
-   when control paths merge; so, at each label, we forget all that is
-   known and start fresh.  This can be described as processing each
-   basic block separately.  Note, however, that these are not quite
-   the same as the basic blocks found by a later pass and used for
-   data flow analysis and register packing.  We do not need to start fresh
-   after a conditional jump instruction if there is no label there.
+   when control paths merge in this code; so, at each label, we forget all
+   that is known and start fresh.  This can be described as processing each
+   extended basic block separately.  We have a separate pass to perform
+   global CSE.
+
+   Note CSE can turn a conditional or computed jump into a nop or
+   an unconditional jump.  When this occurs we arrange to run the jump
+   optimizer after CSE to delete the unreachable code.
 
    We use two data structures to record the equivalent expressions:
    a hash table for most expressions, and several vectors together
@@ -7417,7 +7419,6 @@ cse_insn (insn, libcall_insn)
              rtx new = emit_jump_insn_before (gen_jump (XEXP (src, 0)), insn);
              JUMP_LABEL (new) = XEXP (src, 0);
              LABEL_NUSES (XEXP (src, 0))++;
-             delete_insn (insn);
              insn = new;
            }
          else
@@ -7428,44 +7429,13 @@ cse_insn (insn, libcall_insn)
               Until the right place is found, might as well do this here.  */
            INSN_CODE (insn) = -1;
 
-         /* Now that we've converted this jump to an unconditional jump,
-            there is dead code after it.  Delete the dead code until we
-            reach a BARRIER, the end of the function, or a label.  Do
-            not delete NOTEs except for NOTE_INSN_DELETED since later
-            phases assume these notes are retained.  */
-
          never_reached_warning (insn);
 
-         p = insn;
-
-         while (NEXT_INSN (p) != 0
-                && GET_CODE (NEXT_INSN (p)) != BARRIER
-                && GET_CODE (NEXT_INSN (p)) != CODE_LABEL)
-           {
-             /* Note, we must update P with the return value from
-                delete_insn, otherwise we could get an infinite loop
-                if NEXT_INSN (p) had INSN_DELETED_P set.  */
-             if (GET_CODE (NEXT_INSN (p)) != NOTE
-                 || NOTE_LINE_NUMBER (NEXT_INSN (p)) == NOTE_INSN_DELETED)
-               p = PREV_INSN (delete_insn (NEXT_INSN (p)));
-             else
-               p = NEXT_INSN (p);
-           }
-
-         /* If we don't have a BARRIER immediately after INSN, put one there.
-            Much code assumes that there are no NOTEs between a JUMP_INSN and
-            BARRIER.  */
-
-         if (NEXT_INSN (insn) == 0
-             || GET_CODE (NEXT_INSN (insn)) != BARRIER)
-           emit_barrier_before (NEXT_INSN (insn));
-
-         /* We might have two BARRIERs separated by notes.  Delete the second
-            one if so.  */
-
-         if (p != insn && NEXT_INSN (p) != 0
-             && GET_CODE (NEXT_INSN (p)) == BARRIER)
-           delete_insn (NEXT_INSN (p));
+         /* Now emit a BARRIER after the unconditional jump.  Do not bother
+            deleting any unreachable code, let jump/flow do that.  */
+         if (NEXT_INSN (insn) != 0
+             && GET_CODE (NEXT_INSN (insn)) != BARRIER)
+           emit_barrier_after (insn);
 
          cse_jumps_altered = 1;
          sets[i].rtl = 0;
@@ -8968,9 +8938,6 @@ cse_basic_block (from, to, next_branch, around_loop)
 
          insn = NEXT_INSN (to);
 
-         if (LABEL_NUSES (to) == 0)
-           insn = delete_insn (to);
-
          /* If TO was the last insn in the function, we are done.  */
          if (insn == 0)
            return 0;

diff --git a/gcc/toplev.c b/gcc/toplev.c
index 55c48da..b4e65c7 100644 (file)
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -3745,8 +3745,6 @@ rest_of_compilation (decl)
 
       TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
                                         0, rtl_dump_file));
-      TIMEVAR (cse_time, delete_trivially_dead_insns (insns, max_reg_num ()));
-
       /* If we are not running the second CSE pass, then we are no longer
         expecting CSE to be run.  */
       cse_not_expected = !flag_rerun_cse_after_loop;
@@ -3756,6 +3754,10 @@ rest_of_compilation (decl)
                                           !JUMP_NOOP_MOVES,
                                           !JUMP_AFTER_REGSCAN));
  
+      /* Run this after jump optmizations remove all the unreachable code
+        so that unreachable code will not keep values live.  */
+      TIMEVAR (cse_time, delete_trivially_dead_insns (insns, max_reg_num ()));
+
       /* Try to identify useless null pointer tests and delete them.  */
       if (flag_delete_null_pointer_checks)
        TIMEVAR (jump_time, delete_null_pointer_checks (get_insns ()));