This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

kill jump_optimize



Hi,
this patch removes the jump pass. On number of places it introduces new CFG
rebuilds, but once cse is modified to preserve cse (this is easy to do), we
will result in very few cfg rebuilds - basically only after loop and reload.

Also it does not replace the functionality of code to copy loop headers, as
I think it does not make sense to do it this way until loop is updated to
use CFG and loop discovery code.

I've also verified that all today changes together improve the code quality,
at least on few testcases, so I hope I didn't left out something important.

Bootstrapped/regtested i686 together with other today patches.

Ne čec 15 22:45:37 CEST 2001  Jan Hubicka  <jh@suse.cz>
	* jump.c: Update comments.
	(delete_barrier_successors, delete_unreferenced_labels,
	delete_noop_moves, tension_vector_labels, delete_from_jump_chain,
	delete_labelref_insn, redirect_tablejump, jump_optimize_1,
	jump_optimize, jump_optimize_minimal): Kill.
	(rebuild_jump_labels): Move code from jump_optimize_1.
	(purge_line_number_notes): Likewise.
	(copy_loop_headers): Likewise.
	* reg-stack.c: Update comment.
	* stmt.c: Likewise.
	* rtl.h (jump_optimize, jump_optimize_1, JUMP_NOOP_MOVES,
	JUMP_AFTER_REGSCAN): Kill.
	* toplev.c (rest_of_compilation): Use cleanup_cfg, call
	purge_line_number_notes and copy_loop_headers.


*** /p1/jumpr2/jumpr/egcs/gcc/jump.c	Sat Jul 14 20:59:50 2001
--- jump.c	Sun Jul 15 21:40:34 2001
*************** along with GNU CC; see the file COPYING.
*** 19,32 ****
  the Free Software Foundation, 59 Temple Place - Suite 330,
  Boston, MA 02111-1307, USA.  */
  
! /* This is the jump-optimization pass of the compiler.
!    It is run two or three times: once before cse, sometimes once after cse,
!    and once after reload (before final).
! 
!    jump_optimize deletes unreachable code and labels that are not used.
!    It also deletes jumps that jump to the following insn,
!    and simplifies jumps around unconditional jumps and jumps
!    to unconditional jumps.
  
     Each CODE_LABEL has a count of the times it is used
     stored in the LABEL_NUSES internal field, and each JUMP_INSN
--- 19,27 ----
  the Free Software Foundation, 59 Temple Place - Suite 330,
  Boston, MA 02111-1307, USA.  */
  
! /* This is the pathetic reminder of old fame of the jump-optimization pass
!    of the compiler.  Now it contains basically set of utility function to
!    operate with jumps.
  
     Each CODE_LABEL has a count of the times it is used
     stored in the LABEL_NUSES internal field, and each JUMP_INSN
*************** Boston, MA 02111-1307, USA.  */
*** 36,48 ****
     formerly used them.  The JUMP_LABEL info is sometimes looked
     at by later passes.
  
-    Jump optimization is done after cse when cse's constant-propagation
-    causes jumps to become unconditional or to be deleted.
- 
-    Unreachable loops are not detected here, because the labels
-    have references and the insns appear reachable from the labels.
-    find_basic_blocks in flow.c finds and deletes such loops.
- 
     The subroutines delete_insn, redirect_jump, and invert_jump are used
     from other passes as well.  */
  
--- 31,36 ----
*************** Boston, MA 02111-1307, USA.  */
*** 64,75 ****
  #include "reload.h"
  #include "predict.h"
  
- /* ??? Eventually must record somehow the labels used by jumps
-    from nested functions.  */
- /* Pre-record the next or previous real insn for each label?
-    No, this pass is very fast anyway.  */
- /* Condense consecutive labels?
-    This would make life analysis faster, maybe.  */
  /* Optimize jump y; x: ... y: jumpif... x?
     Don't know if it is worth bothering with.  */
  /* Optimize two cases of conditional jump to conditional jump?
--- 52,57 ----
*************** Boston, MA 02111-1307, USA.  */
*** 77,125 ****
     or even change what is live at any point.
     So perhaps let combiner do it.  */
  
- /* Vector indexed by uid.
-    For each CODE_LABEL, index by its uid to get first unconditional jump
-    that jumps to the label.
-    For each JUMP_INSN, index by its uid to get the next unconditional jump
-    that jumps to the same label.
-    Element 0 is the start of a chain of all return insns.
-    (It is safe to use element 0 because insn uid 0 is not used.  */
- 
- static rtx *jump_chain;
- 
- /* Maximum index in jump_chain.  */
- 
- static int max_jump_chain;
- 
  static int init_label_info		PARAMS ((rtx));
- static void delete_barrier_successors	PARAMS ((rtx));
  static void mark_all_labels		PARAMS ((rtx));
- static rtx delete_unreferenced_labels	PARAMS ((rtx));
- static void delete_noop_moves		PARAMS ((rtx));
  static int duplicate_loop_exit_test	PARAMS ((rtx));
- static int tension_vector_labels	PARAMS ((rtx, int));
  static void delete_computation		PARAMS ((rtx));
  static void redirect_exp_1		PARAMS ((rtx *, rtx, rtx, rtx));
  static int redirect_exp			PARAMS ((rtx, rtx, rtx));
  static void invert_exp_1		PARAMS ((rtx));
  static int invert_exp			PARAMS ((rtx));
- static void delete_from_jump_chain	PARAMS ((rtx));
- static int delete_labelref_insn		PARAMS ((rtx, rtx, int));
- static void redirect_tablejump		PARAMS ((rtx, rtx));
- static void jump_optimize_1		PARAMS ((rtx, int, int, int, int));
  static int returnjump_p_1	        PARAMS ((rtx *, void *));
  static void delete_prior_computation    PARAMS ((rtx, rtx));
  
- /* Main external entry point into the jump optimizer.  See comments before
-    jump_optimize_1 for descriptions of the arguments.  */
- void
- jump_optimize (f, noop_moves, after_regscan)
-      rtx f;
-      int noop_moves;
-      int after_regscan;
- {
-   jump_optimize_1 (f, noop_moves, after_regscan, 0, 0);
- }
  
  /* Alternate entry into the jump optimizer.  This entry point only rebuilds
     the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
--- 59,75 ----
*************** void
*** 128,201 ****
  rebuild_jump_labels (f)
       rtx f;
  {
!   jump_optimize_1 (f, 0, 0, 1, 0);
! }
! 
! /* Alternate entry into the jump optimizer.  Do only trivial optimizations.  */
! 
! void
! jump_optimize_minimal (f)
!      rtx f;
! {
!   jump_optimize_1 (f, 0, 0, 0, 1);
! }
! 
! /* Delete no-op jumps and optimize jumps to jumps
!    and jumps around jumps.
!    Delete unused labels and unreachable code.
! 
!    If NOOP_MOVES is nonzero, delete no-op move insns.
! 
!    If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
!    after regscan, and it is safe to use regno_first_uid and regno_last_uid.
! 
!    If MARK_LABELS_ONLY is nonzero, then we only rebuild the jump chain
!    and JUMP_LABEL field for jumping insns.
! 
!    If `optimize' is zero, don't change any code,
!    just determine whether control drops off the end of the function.
!    This case occurs when we have -W and not -O.
!    It works because `delete_insn' checks the value of `optimize'
!    and refrains from actually deleting when that is 0.
! 
!    If MINIMAL is nonzero, then we only perform trivial optimizations:
! 
!      * Removal of unreachable code after BARRIERs.
!      * Removal of unreferenced CODE_LABELs.
!      * Removal of a jump to the next instruction.
!      * Removal of a conditional jump followed by an unconditional jump
!        to the same target as the conditional jump.
!      * Simplify a conditional jump around an unconditional jump.
!      * Simplify a jump to a jump.
!      * Delete extraneous line number notes.
!   */
! 
! static void
! jump_optimize_1 (f, noop_moves, after_regscan,
! 		 mark_labels_only, minimal)
!      rtx f;
!      int noop_moves;
!      int after_regscan;
!      int mark_labels_only;
!      int minimal;
! {
!   register rtx insn, next;
!   int changed;
!   int old_max_reg;
!   int first = 1;
    int max_uid = 0;
-   rtx last_insn;
- #ifdef HAVE_trap
-   enum rtx_code reversed_code;
- #endif
- 
    max_uid = init_label_info (f) + 1;
  
-   /* Leave some extra room for labels and duplicate exit test insns
-      we make.  */
-   max_jump_chain = max_uid * 14 / 10;
-   jump_chain = (rtx *) xcalloc (max_jump_chain, sizeof (rtx));
- 
    mark_all_labels (f);
  
    /* Keep track of labels used from static data; we don't track them
--- 78,87 ----
  rebuild_jump_labels (f)
       rtx f;
  {
!   register rtx insn;
    int max_uid = 0;
    max_uid = init_label_info (f) + 1;
  
    mark_all_labels (f);
  
    /* Keep track of labels used from static data; we don't track them
*************** jump_optimize_1 (f, noop_moves, after_re
*** 212,246 ****
    for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
      if (GET_CODE (XEXP (insn, 0)) == CODE_LABEL)
        LABEL_NUSES (XEXP (insn, 0))++;
! 
!   /* Quit now if we just wanted to rebuild the JUMP_LABEL and REG_LABEL
!      notes and recompute LABEL_NUSES.  */
!   if (mark_labels_only)
!     goto end;
! 
!   delete_barrier_successors (f);
! 
!   last_insn = delete_unreferenced_labels (f);
! 
!   if (noop_moves)
!     delete_noop_moves (f);
! 
    /* Now iterate optimizing jumps until nothing changes over one pass.  */
    changed = 1;
-   old_max_reg = max_reg_num ();
    while (changed)
      {
        changed = 0;
  
        for (insn = f; insn; insn = next)
  	{
! 	  rtx reallabelprev;
! 	  rtx temp, temp1, temp2 = NULL_RTX;
! 	  rtx temp4 ATTRIBUTE_UNUSED;
! 	  rtx nlabel;
! 	  int this_is_any_uncondjump;
! 	  int this_is_any_condjump;
! 	  int this_is_onlyjump;
  
  	  next = NEXT_INSN (insn);
  
--- 98,120 ----
    for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
      if (GET_CODE (XEXP (insn, 0)) == CODE_LABEL)
        LABEL_NUSES (XEXP (insn, 0))++;
! }
! 
! void
! copy_loop_headers (f)
!      rtx f;
! {
!   register rtx insn, next;
!   int changed;
    /* Now iterate optimizing jumps until nothing changes over one pass.  */
    changed = 1;
    while (changed)
      {
        changed = 0;
  
        for (insn = f; insn; insn = next)
  	{
! 	  rtx temp, temp1;
  
  	  next = NEXT_INSN (insn);
  
*************** jump_optimize_1 (f, noop_moves, after_re
*** 248,258 ****
  	     jump.  Try to optimize by duplicating the loop exit test if so.
  	     This is only safe immediately after regscan, because it uses
  	     the values of regno_first_uid and regno_last_uid.  */
! 	  if (after_regscan && GET_CODE (insn) == NOTE
  	      && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
  	      && (temp1 = next_nonnote_insn (insn)) != 0
! 	      && any_uncondjump_p (temp1)
! 	      && onlyjump_p (temp1))
  	    {
  	      temp = PREV_INSN (insn);
  	      if (duplicate_loop_exit_test (insn))
--- 122,131 ----
  	     jump.  Try to optimize by duplicating the loop exit test if so.
  	     This is only safe immediately after regscan, because it uses
  	     the values of regno_first_uid and regno_last_uid.  */
! 	  if (GET_CODE (insn) == NOTE
  	      && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
  	      && (temp1 = next_nonnote_insn (insn)) != 0
! 	      && any_uncondjump_p (temp1) && onlyjump_p (temp1))
  	    {
  	      temp = PREV_INSN (insn);
  	      if (duplicate_loop_exit_test (insn))
*************** jump_optimize_1 (f, noop_moves, after_re
*** 263,595 ****
  		}
  	    }
  
! 	  if (GET_CODE (insn) != JUMP_INSN)
! 	    continue;
! 
! 	  this_is_any_condjump = any_condjump_p (insn);
! 	  this_is_any_uncondjump = any_uncondjump_p (insn);
! 	  this_is_onlyjump = onlyjump_p (insn);
! 
! 	  /* Tension the labels in dispatch tables.  */
! 
! 	  if (GET_CODE (PATTERN (insn)) == ADDR_VEC)
! 	    changed |= tension_vector_labels (PATTERN (insn), 0);
! 	  if (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
! 	    changed |= tension_vector_labels (PATTERN (insn), 1);
! 
! 	  /* See if this jump goes to another jump and redirect if so.  */
! 	  nlabel = follow_jumps (JUMP_LABEL (insn));
! 	  if (nlabel != JUMP_LABEL (insn))
! 	    changed |= redirect_jump (insn, nlabel, 1);
! 
! 	  if (! optimize || minimal)
! 	    continue;
! 
! 	  /* If a dispatch table always goes to the same place,
! 	     get rid of it and replace the insn that uses it.  */
! 
! 	  if (GET_CODE (PATTERN (insn)) == ADDR_VEC
! 	      || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
! 	    {
! 	      int i;
! 	      rtx pat = PATTERN (insn);
! 	      int diff_vec_p = GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC;
! 	      int len = XVECLEN (pat, diff_vec_p);
! 	      rtx dispatch = prev_real_insn (insn);
! 	      rtx set;
! 
! 	      for (i = 0; i < len; i++)
! 		if (XEXP (XVECEXP (pat, diff_vec_p, i), 0)
! 		    != XEXP (XVECEXP (pat, diff_vec_p, 0), 0))
! 		  break;
! 
! 	      if (i == len
! 		  && dispatch != 0
! 		  && GET_CODE (dispatch) == JUMP_INSN
! 		  && JUMP_LABEL (dispatch) != 0
! 		  /* Don't mess with a casesi insn.
! 		     XXX according to the comment before computed_jump_p(),
! 		     all casesi insns should be a parallel of the jump
! 		     and a USE of a LABEL_REF.  */
! 		  && ! ((set = single_set (dispatch)) != NULL
! 			&& (GET_CODE (SET_SRC (set)) == IF_THEN_ELSE))
! 		  && next_real_insn (JUMP_LABEL (dispatch)) == insn)
! 		{
! 		  redirect_tablejump (dispatch,
! 				      XEXP (XVECEXP (pat, diff_vec_p, 0), 0));
! 		  changed = 1;
! 		}
! 	    }
! 
! 	  reallabelprev = prev_active_insn (JUMP_LABEL (insn));
! 
! 	  /* Detect jump to following insn.  */
! 	  if (reallabelprev == insn
! 	      && (this_is_any_condjump || this_is_any_uncondjump)
! 	      && this_is_onlyjump)
! 	    {
! 	      next = next_real_insn (JUMP_LABEL (insn));
! 	      delete_jump (insn);
! 
! 	      /* Remove the "inactive" but "real" insns (i.e. uses and
! 	         clobbers) in between here and there.  */
! 	      temp = insn;
! 	      while ((temp = next_real_insn (temp)) != next)
! 		delete_insn (temp);
! 
! 	      changed = 1;
! 	      continue;
! 	    }
! 
! 	  /* Detect a conditional jump going to the same place
! 	     as an immediately following unconditional jump.  */
! 	  else if (this_is_any_condjump && this_is_onlyjump
! 		   && (temp = next_active_insn (insn)) != 0
! 		   && simplejump_p (temp)
! 		   && (next_active_insn (JUMP_LABEL (insn))
! 		       == next_active_insn (JUMP_LABEL (temp))))
! 	    {
! 	      /* Don't mess up test coverage analysis.  */
! 	      temp2 = temp;
! 	      if (flag_test_coverage && !reload_completed)
! 		for (temp2 = insn; temp2 != temp; temp2 = NEXT_INSN (temp2))
! 		  if (GET_CODE (temp2) == NOTE && NOTE_LINE_NUMBER (temp2) > 0)
! 		    break;
! 
! 	      if (temp2 == temp)
! 		{
! 		  /* Ensure that we jump to the later of the two labels.  
! 		     Consider:
! 
! 			if (test) goto L2;
! 			goto L1;
! 			...
! 		      L1:
! 			(clobber return-reg)
! 		      L2:
! 			(use return-reg)
! 
! 		     If we leave the goto L1, we'll incorrectly leave
! 		     return-reg dead for TEST true.  */
! 
! 		  temp2 = next_active_insn (JUMP_LABEL (insn));
! 		  if (!temp2)
! 		    temp2 = get_last_insn ();
! 		  if (GET_CODE (temp2) != CODE_LABEL)
! 		    temp2 = prev_label (temp2);
! 		  if (temp2 != JUMP_LABEL (temp))
! 		    redirect_jump (temp, temp2, 1);
! 
! 		  delete_jump (insn);
! 		  changed = 1;
! 		  continue;
! 		}
! 	    }
! 
! 	  /* Detect a conditional jump jumping over an unconditional jump.  */
! 
! 	  else if (this_is_any_condjump
! 		   && reallabelprev != 0
! 		   && GET_CODE (reallabelprev) == JUMP_INSN
! 		   && prev_active_insn (reallabelprev) == insn
! 		   && no_labels_between_p (insn, reallabelprev)
! 		   && any_uncondjump_p (reallabelprev)
! 		   && onlyjump_p (reallabelprev))
! 	    {
! 	      /* When we invert the unconditional jump, we will be
! 		 decrementing the usage count of its old label.
! 		 Make sure that we don't delete it now because that
! 		 might cause the following code to be deleted.  */
! 	      rtx prev_uses = prev_nonnote_insn (reallabelprev);
! 	      rtx prev_label = JUMP_LABEL (insn);
! 
! 	      if (prev_label)
! 		++LABEL_NUSES (prev_label);
! 
! 	      if (invert_jump (insn, JUMP_LABEL (reallabelprev), 1))
! 		{
! 		  /* It is very likely that if there are USE insns before
! 		     this jump, they hold REG_DEAD notes.  These REG_DEAD
! 		     notes are no longer valid due to this optimization,
! 		     and will cause the life-analysis that following passes
! 		     (notably delayed-branch scheduling) to think that
! 		     these registers are dead when they are not.
! 
! 		     To prevent this trouble, we just remove the USE insns
! 		     from the insn chain.  */
! 
! 		  while (prev_uses && GET_CODE (prev_uses) == INSN
! 			 && GET_CODE (PATTERN (prev_uses)) == USE)
! 		    {
! 		      rtx useless = prev_uses;
! 		      prev_uses = prev_nonnote_insn (prev_uses);
! 		      delete_insn (useless);
! 		    }
! 
! 		  delete_insn (reallabelprev);
! 		  changed = 1;
! 		}
! 
! 	      /* We can now safely delete the label if it is unreferenced
! 		 since the delete_insn above has deleted the BARRIER.  */
! 	      if (prev_label && --LABEL_NUSES (prev_label) == 0)
! 		delete_insn (prev_label);
  
! 	      next = NEXT_INSN (insn);
! 	    }
  
! 	  /* If we have an unconditional jump preceded by a USE, try to put
! 	     the USE before the target and jump there.  This simplifies many
! 	     of the optimizations below since we don't have to worry about
! 	     dealing with these USE insns.  We only do this if the label
! 	     being branch to already has the identical USE or if code
! 	     never falls through to that label.  */
! 
! 	  else if (this_is_any_uncondjump
! 		   && (temp = prev_nonnote_insn (insn)) != 0
! 		   && GET_CODE (temp) == INSN
! 		   && GET_CODE (PATTERN (temp)) == USE
! 		   && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0
! 		   && (GET_CODE (temp1) == BARRIER
! 		       || (GET_CODE (temp1) == INSN
! 			   && rtx_equal_p (PATTERN (temp), PATTERN (temp1))))
! 		   /* Don't do this optimization if we have a loop containing
! 		      only the USE instruction, and the loop start label has
! 		      a usage count of 1.  This is because we will redo this
! 		      optimization everytime through the outer loop, and jump
! 		      opt will never exit.  */
! 		   && ! ((temp2 = prev_nonnote_insn (temp)) != 0
! 			 && temp2 == JUMP_LABEL (insn)
! 			 && LABEL_NUSES (temp2) == 1))
! 	    {
! 	      if (GET_CODE (temp1) == BARRIER)
! 		{
! 		  emit_insn_after (PATTERN (temp), temp1);
! 		  temp1 = NEXT_INSN (temp1);
! 		}
  
! 	      delete_insn (temp);
! 	      redirect_jump (insn, get_label_before (temp1), 1);
! 	      reallabelprev = prev_real_insn (temp1);
! 	      changed = 1;
! 	      next = NEXT_INSN (insn);
! 	    }
  
! #ifdef HAVE_trap
! 	  /* Detect a conditional jump jumping over an unconditional trap.  */
! 	  if (HAVE_trap
! 	      && this_is_any_condjump && this_is_onlyjump
! 	      && reallabelprev != 0
! 	      && GET_CODE (reallabelprev) == INSN
! 	      && GET_CODE (PATTERN (reallabelprev)) == TRAP_IF
! 	      && TRAP_CONDITION (PATTERN (reallabelprev)) == const_true_rtx
! 	      && prev_active_insn (reallabelprev) == insn
! 	      && no_labels_between_p (insn, reallabelprev)
! 	      && (temp2 = get_condition (insn, &temp4))
! 	      && ((reversed_code = reversed_comparison_code (temp2, insn))
! 		  != UNKNOWN))
! 	    {
! 	      rtx new = gen_cond_trap (reversed_code,
! 				       XEXP (temp2, 0), XEXP (temp2, 1),
! 				       TRAP_CODE (PATTERN (reallabelprev)));
  
! 	      if (new)
! 		{
! 		  emit_insn_before (new, temp4);
! 		  delete_insn (reallabelprev);
! 		  delete_jump (insn);
! 		  changed = 1;
! 		  continue;
! 		}
! 	    }
! 	  /* Detect a jump jumping to an unconditional trap.  */
! 	  else if (HAVE_trap && this_is_onlyjump
! 		   && (temp = next_active_insn (JUMP_LABEL (insn)))
! 		   && GET_CODE (temp) == INSN
! 		   && GET_CODE (PATTERN (temp)) == TRAP_IF
! 		   && (this_is_any_uncondjump
! 		       || (this_is_any_condjump
! 			   && (temp2 = get_condition (insn, &temp4)))))
! 	    {
! 	      rtx tc = TRAP_CONDITION (PATTERN (temp));
  
! 	      if (tc == const_true_rtx
! 		  || (! this_is_any_uncondjump && rtx_equal_p (temp2, tc)))
! 		{
! 		  rtx new;
! 		  /* Replace an unconditional jump to a trap with a trap.  */
! 		  if (this_is_any_uncondjump)
! 		    {
! 		      emit_barrier_after (emit_insn_before (gen_trap (), insn));
! 		      delete_jump (insn);
! 		      changed = 1;
! 		      continue;
! 		    }
! 		  new = gen_cond_trap (GET_CODE (temp2), XEXP (temp2, 0),
! 				       XEXP (temp2, 1),
! 				       TRAP_CODE (PATTERN (temp)));
! 		  if (new)
! 		    {
! 		      emit_insn_before (new, temp4);
! 		      delete_jump (insn);
! 		      changed = 1;
! 		      continue;
! 		    }
! 		}
! 	      /* If the trap condition and jump condition are mutually
! 		 exclusive, redirect the jump to the following insn.  */
! 	      else if (GET_RTX_CLASS (GET_CODE (tc)) == '<'
! 		       && this_is_any_condjump
! 		       && swap_condition (GET_CODE (temp2)) == GET_CODE (tc)
! 		       && rtx_equal_p (XEXP (tc, 0), XEXP (temp2, 0))
! 		       && rtx_equal_p (XEXP (tc, 1), XEXP (temp2, 1))
! 		       && redirect_jump (insn, get_label_after (temp), 1))
! 		{
! 		  changed = 1;
! 		  continue;
! 		}
! 	    }
! #endif
! 	}
  
!       first = 0;
!     }
  
    /* Delete extraneous line number notes.
       Note that two consecutive notes for different lines are not really
       extraneous.  There should be some indication where that line belonged,
       even if it became empty.  */
  
-   {
-     rtx last_note = 0;
  
!     for (insn = f; insn; insn = NEXT_INSN (insn))
!       if (GET_CODE (insn) == NOTE)
! 	{
! 	  if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
! 	    /* Any previous line note was for the prologue; gdb wants a new
! 	       note after the prologue even if it is for the same line.  */
! 	    last_note = NULL_RTX;
! 	  else if (NOTE_LINE_NUMBER (insn) >= 0)
! 	    {
! 	      /* Delete this note if it is identical to previous note.  */
! 	      if (last_note
! 		  && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
! 		  && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note))
! 		{
! 		  delete_insn (insn);
! 		  continue;
! 		}
! 
! 	      last_note = insn;
! 	    }
! 	}
!   }
  
! end:
!   /* Clean up.  */
!   free (jump_chain);
!   jump_chain = 0;
  }
  
  /* Initialize LABEL_NUSES and JUMP_LABEL fields.  Delete any REG_LABEL
--- 136,208 ----
  		}
  	    }
  
! 	}
!     }
  
! }
! /* Delete no-op jumps and optimize jumps to jumps
!    and jumps around jumps.
!    Delete unused labels and unreachable code.
  
!    If NOOP_MOVES is nonzero, delete no-op move insns.
  
!    If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
!    after regscan, and it is safe to use regno_first_uid and regno_last_uid.
  
!    If MARK_LABELS_ONLY is nonzero, then we only rebuild the jump chain
!    and JUMP_LABEL field for jumping insns.
  
!    If `optimize' is zero, don't change any code,
!    just determine whether control drops off the end of the function.
!    This case occurs when we have -W and not -O.
!    It works because `delete_insn' checks the value of `optimize'
!    and refrains from actually deleting when that is 0.
  
!    If MINIMAL is nonzero, then we only perform trivial optimizations:
  
!      * Removal of unreachable code after BARRIERs.
!      * Removal of unreferenced CODE_LABELs.
!      * Removal of a jump to the next instruction.
!      * Removal of a conditional jump followed by an unconditional jump
!        to the same target as the conditional jump.
!      * Simplify a conditional jump around an unconditional jump.
!      * Simplify a jump to a jump.
!      * Delete extraneous line number notes.
!   */
  
+ void
+ purge_line_number_notes (f)
+      rtx f;
+ {
+   rtx last_note = 0;
+   rtx insn;
    /* Delete extraneous line number notes.
       Note that two consecutive notes for different lines are not really
       extraneous.  There should be some indication where that line belonged,
       even if it became empty.  */
  
  
!   for (insn = f; insn; insn = NEXT_INSN (insn))
!     if (GET_CODE (insn) == NOTE)
!       {
! 	if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
! 	  /* Any previous line note was for the prologue; gdb wants a new
! 	     note after the prologue even if it is for the same line.  */
! 	  last_note = NULL_RTX;
! 	else if (NOTE_LINE_NUMBER (insn) >= 0)
! 	  {
! 	    /* Delete this note if it is identical to previous note.  */
! 	    if (last_note
! 		&& NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
! 		&& NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note))
! 	      {
! 		delete_insn (insn);
! 		continue;
! 	      }
  
! 	    last_note = insn;
! 	  }
!       }
  }
  
  /* Initialize LABEL_NUSES and JUMP_LABEL fields.  Delete any REG_LABEL
*************** init_label_info (f)
*** 627,700 ****
    return largest_uid;
  }
  
- /* Delete insns following barriers, up to next label.
- 
-    Also delete no-op jumps created by gcse.  */
- 
- static void
- delete_barrier_successors (f)
-      rtx f;
- {
-   rtx insn;
-   rtx set;
- 
-   for (insn = f; insn;)
-     {
-       if (GET_CODE (insn) == BARRIER)
- 	{
- 	  insn = NEXT_INSN (insn);
- 
- 	  never_reached_warning (insn);
- 
- 	  while (insn != 0 && GET_CODE (insn) != CODE_LABEL)
- 	    {
- 	      if (GET_CODE (insn) == JUMP_INSN)
- 		{
- 		  /* Detect when we're deleting a tablejump; get rid of
- 		     the jump table as well.  */
- 		  rtx next1 = next_nonnote_insn (insn);
- 		  rtx next2 = next1 ? next_nonnote_insn (next1) : 0;
- 		  if (next2 && GET_CODE (next1) == CODE_LABEL
- 		      && GET_CODE (next2) == JUMP_INSN
- 		      && (GET_CODE (PATTERN (next2)) == ADDR_VEC
- 			  || GET_CODE (PATTERN (next2)) == ADDR_DIFF_VEC))
- 		    {
- 		      delete_insn (insn);
- 		      insn = next2;
- 		    }
- 		  else
- 		    insn = delete_insn (insn);
- 		}
- 	      else if (GET_CODE (insn) == NOTE
- 		  && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)
- 		insn = NEXT_INSN (insn);
- 	      else
- 		insn = delete_insn (insn);
- 	    }
- 	  /* INSN is now the code_label.  */
- 	}
- 
-       /* Also remove (set (pc) (pc)) insns which can be created by
- 	 gcse.  We eliminate such insns now to avoid having them
- 	 cause problems later.  */
-       else if (GET_CODE (insn) == JUMP_INSN
- 	       && (set = pc_set (insn)) != NULL
- 	       && SET_SRC (set) == pc_rtx
- 	       && SET_DEST (set) == pc_rtx
- 	       && onlyjump_p (insn))
- 	insn = delete_insn (insn);
- 
-       else
- 	insn = NEXT_INSN (insn);
-     }
- }
- 
  /* Mark the label each jump jumps to.
!    Combine consecutive labels, and count uses of labels.
! 
!    For each label, make a chain (using `jump_chain')
!    of all the *unconditional* jumps that jump to it;
!    also make a chain of all returns.  */
  
  static void
  mark_all_labels (f)
--- 240,247 ----
    return largest_uid;
  }
  
  /* Mark the label each jump jumps to.
!    Combine consecutive labels, and count uses of labels.  */
  
  static void
  mark_all_labels (f)
*************** mark_all_labels (f)
*** 746,925 ****
  		    JUMP_LABEL (insn) = XEXP (label_note, 0);
  		  }
  	      }
- 	    if (JUMP_LABEL (insn) != 0 && simplejump_p (insn))
- 	      {
- 		jump_chain[INSN_UID (insn)]
- 		  = jump_chain[INSN_UID (JUMP_LABEL (insn))];
- 		jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
- 	      }
- 	    if (GET_CODE (PATTERN (insn)) == RETURN)
- 	      {
- 		jump_chain[INSN_UID (insn)] = jump_chain[0];
- 		jump_chain[0] = insn;
- 	      }
  	  }
        }
  }
  
- /* Delete all labels already not referenced.
-    Also find and return the last insn.  */
- 
- static rtx
- delete_unreferenced_labels (f)
-      rtx f;
- {
-   rtx final = NULL_RTX;
-   rtx insn;
- 
-   for (insn = f; insn;)
-     {
-       if (GET_CODE (insn) == CODE_LABEL
- 	  && LABEL_NUSES (insn) == 0
- 	  && LABEL_ALTERNATE_NAME (insn) == NULL)
- 	insn = delete_insn (insn);
-       else
- 	{
- 	  final = insn;
- 	  insn = NEXT_INSN (insn);
- 	}
-     }
- 
-   return final;
- }
- 
- /* Delete various simple forms of moves which have no necessary
-    side effect.  */
- 
- static void
- delete_noop_moves (f)
-      rtx f;
- {
-   rtx insn, next;
- 
-   for (insn = f; insn;)
-     {
-       next = NEXT_INSN (insn);
- 
-       if (GET_CODE (insn) == INSN)
- 	{
- 	  register rtx body = PATTERN (insn);
- 
- 	  /* Detect and delete no-op move instructions
- 	     resulting from not allocating a parameter in a register.  */
- 
- 	  if (GET_CODE (body) == SET && set_noop_p (body))
- 	    delete_computation (insn);
- 
- 	  /* Detect and ignore no-op move instructions
- 	     resulting from smart or fortuitous register allocation.  */
- 
- 	  else if (GET_CODE (body) == SET)
- 	    {
- 	      int sreg = true_regnum (SET_SRC (body));
- 	      int dreg = true_regnum (SET_DEST (body));
- 
- 	      if (sreg == dreg && sreg >= 0)
- 		delete_insn (insn);
- 	      else if (sreg >= 0 && dreg >= 0)
- 		{
- 		  rtx trial;
- 		  rtx tem = find_equiv_reg (NULL_RTX, insn, 0,
- 					    sreg, NULL, dreg,
- 					    GET_MODE (SET_SRC (body)));
- 
- 		  if (tem != 0
- 		      && GET_MODE (tem) == GET_MODE (SET_DEST (body)))
- 		    {
- 		      /* DREG may have been the target of a REG_DEAD note in
- 			 the insn which makes INSN redundant.  If so, reorg
- 			 would still think it is dead.  So search for such a
- 			 note and delete it if we find it.  */
- 		      if (! find_regno_note (insn, REG_UNUSED, dreg))
- 			for (trial = prev_nonnote_insn (insn);
- 			     trial && GET_CODE (trial) != CODE_LABEL;
- 			     trial = prev_nonnote_insn (trial))
- 			  if (find_regno_note (trial, REG_DEAD, dreg))
- 			    {
- 			      remove_death (dreg, trial);
- 			      break;
- 			    }
- 
- 		      /* Deleting insn could lose a death-note for SREG.  */
- 		      if ((trial = find_regno_note (insn, REG_DEAD, sreg)))
- 			{
- 			  /* Change this into a USE so that we won't emit
- 			     code for it, but still can keep the note.  */
- 			  PATTERN (insn)
- 			    = gen_rtx_USE (VOIDmode, XEXP (trial, 0));
- 			  INSN_CODE (insn) = -1;
- 			  /* Remove all reg notes but the REG_DEAD one.  */
- 			  REG_NOTES (insn) = trial;
- 			  XEXP (trial, 1) = NULL_RTX;
- 			}
- 		      else
- 			delete_insn (insn);
- 		    }
- 		}
- 	      else if (dreg >= 0 && CONSTANT_P (SET_SRC (body))
- 		       && find_equiv_reg (SET_SRC (body), insn, 0, dreg,
- 					  NULL, 0, GET_MODE (SET_DEST (body))))
- 		{
- 		  /* This handles the case where we have two consecutive
- 		     assignments of the same constant to pseudos that didn't
- 		     get a hard reg.  Each SET from the constant will be
- 		     converted into a SET of the spill register and an
- 		     output reload will be made following it.  This produces
- 		     two loads of the same constant into the same spill
- 		     register.  */
- 
- 		  rtx in_insn = insn;
- 
- 		  /* Look back for a death note for the first reg.
- 		     If there is one, it is no longer accurate.  */
- 		  while (in_insn && GET_CODE (in_insn) != CODE_LABEL)
- 		    {
- 		      if ((GET_CODE (in_insn) == INSN
- 			   || GET_CODE (in_insn) == JUMP_INSN)
- 			  && find_regno_note (in_insn, REG_DEAD, dreg))
- 			{
- 			  remove_death (dreg, in_insn);
- 			  break;
- 			}
- 		      in_insn = PREV_INSN (in_insn);
- 		    }
- 
- 		  /* Delete the second load of the value.  */
- 		  delete_insn (insn);
- 		}
- 	    }
- 	  else if (GET_CODE (body) == PARALLEL)
- 	    {
- 	      /* If each part is a set between two identical registers or
- 		 a USE or CLOBBER, delete the insn.  */
- 	      int i, sreg, dreg;
- 	      rtx tem;
- 
- 	      for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
- 		{
- 		  tem = XVECEXP (body, 0, i);
- 		  if (GET_CODE (tem) == USE || GET_CODE (tem) == CLOBBER)
- 		    continue;
- 
- 		  if (GET_CODE (tem) != SET
- 		      || (sreg = true_regnum (SET_SRC (tem))) < 0
- 		      || (dreg = true_regnum (SET_DEST (tem))) < 0
- 		      || dreg != sreg)
- 		    break;
- 		}
- 
- 	      if (i < 0)
- 		delete_insn (insn);
- 	    }
- 	}
-       insn = next;
-     }
- }
- 
  /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
     jump.  Assume that this unconditional jump is to the exit test code.  If
     the code is sufficiently simple, make a copy of it before INSN,
--- 293,302 ----
*************** duplicate_loop_exit_test (loop_start)
*** 1119,1133 ****
  		    predict_insn_def (copy, PRED_LOOP_HEADER, NOT_TAKEN);
  		}
  	    }
- 	  /* If this is a simple jump, add it to the jump chain.  */
- 
- 	  if (INSN_UID (copy) < max_jump_chain && JUMP_LABEL (copy)
- 	      && simplejump_p (copy))
- 	    {
- 	      jump_chain[INSN_UID (copy)]
- 		= jump_chain[INSN_UID (JUMP_LABEL (copy))];
- 	      jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
- 	    }
  	  break;
  
  	default:
--- 496,501 ----
*************** duplicate_loop_exit_test (loop_start)
*** 1155,1167 ****
  	first_copy = copy;
  
        mark_jump_label (PATTERN (copy), copy, 0);
-       if (INSN_UID (copy) < max_jump_chain
- 	  && INSN_UID (JUMP_LABEL (copy)) < max_jump_chain)
- 	{
- 	  jump_chain[INSN_UID (copy)]
- 	    = jump_chain[INSN_UID (JUMP_LABEL (copy))];
- 	  jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
- 	}
        emit_barrier_before (loop_start);
      }
  
--- 523,528 ----
*************** follow_jumps (label)
*** 1998,2030 ****
    return value;
  }
  
- /* Assuming that field IDX of X is a vector of label_refs,
-    replace each of them by the ultimate label reached by it.
-    Return nonzero if a change is made.
-    If IGNORE_LOOPS is 0, we do not chain across a NOTE_INSN_LOOP_BEG.  */
- 
- static int
- tension_vector_labels (x, idx)
-      register rtx x;
-      register int idx;
- {
-   int changed = 0;
-   register int i;
-   for (i = XVECLEN (x, idx) - 1; i >= 0; i--)
-     {
-       register rtx olabel = XEXP (XVECEXP (x, idx, i), 0);
-       register rtx nlabel = follow_jumps (olabel);
-       if (nlabel && nlabel != olabel)
- 	{
- 	  XEXP (XVECEXP (x, idx, i), 0) = nlabel;
- 	  ++LABEL_NUSES (nlabel);
- 	  if (--LABEL_NUSES (olabel) == 0)
- 	    delete_insn (olabel);
- 	  changed = 1;
- 	}
-     }
-   return changed;
- }
  
  /* Find all CODE_LABELs referred to in X, and increment their use counts.
     If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
--- 1359,1364 ----
*************** delete_insn (insn)
*** 2429,2438 ****
      /* Mark this insn as deleted.  */
      INSN_DELETED_P (insn) = 1;
  
-   /* If this is an unconditional jump, delete it from the jump chain.  */
-   if (simplejump_p (insn))
-     delete_from_jump_chain (insn);
- 
    /* If instruction is followed by a barrier,
       delete the barrier too.  */
  
--- 1763,1768 ----
*************** redirect_jump (jump, nlabel, delete_unus
*** 2791,2813 ****
    if (! redirect_exp (olabel, nlabel, jump))
      return 0;
  
-   /* If this is an unconditional branch, delete it from the jump_chain of
-      OLABEL and add it to the jump_chain of NLABEL (assuming both labels
-      have UID's in range and JUMP_CHAIN is valid).  */
-   if (jump_chain && (simplejump_p (jump)
- 		     || GET_CODE (PATTERN (jump)) == RETURN))
-     {
-       int label_index = nlabel ? INSN_UID (nlabel) : 0;
- 
-       delete_from_jump_chain (jump);
-       if (label_index < max_jump_chain
- 	  && INSN_UID (jump) < max_jump_chain)
- 	{
- 	  jump_chain[INSN_UID (jump)] = jump_chain[label_index];
- 	  jump_chain[label_index] = jump;
- 	}
-     }
- 
    JUMP_LABEL (jump) = nlabel;
    if (nlabel)
      ++LABEL_NUSES (nlabel);
--- 2121,2126 ----
*************** invert_jump (jump, nlabel, delete_unused
*** 2938,3068 ****
    return 0;
  }
  
- /* Delete the instruction JUMP from any jump chain it might be on.  */
- 
- static void
- delete_from_jump_chain (jump)
-      rtx jump;
- {
-   int index;
-   rtx olabel = JUMP_LABEL (jump);
- 
-   /* Handle unconditional jumps.  */
-   if (jump_chain && olabel != 0
-       && INSN_UID (olabel) < max_jump_chain
-       && simplejump_p (jump))
-     index = INSN_UID (olabel);
-   /* Handle return insns.  */
-   else if (jump_chain && GET_CODE (PATTERN (jump)) == RETURN)
-     index = 0;
-   else
-     return;
- 
-   if (jump_chain[index] == jump)
-     jump_chain[index] = jump_chain[INSN_UID (jump)];
-   else
-     {
-       rtx insn;
- 
-       for (insn = jump_chain[index];
- 	   insn != 0;
- 	   insn = jump_chain[INSN_UID (insn)])
- 	if (jump_chain[INSN_UID (insn)] == jump)
- 	  {
- 	    jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (jump)];
- 	    break;
- 	  }
-     }
- }
- 
- /* Make jump JUMP jump to label NLABEL, assuming it used to be a tablejump.
- 
-    If the old jump target label (before the dispatch table) becomes unused,
-    it and the dispatch table may be deleted.  In that case, find the insn
-    before the jump references that label and delete it and logical successors
-    too.  */
- 
- static void
- redirect_tablejump (jump, nlabel)
-      rtx jump, nlabel;
- {
-   register rtx olabel = JUMP_LABEL (jump);
-   rtx *notep, note, next;
- 
-   /* Add this jump to the jump_chain of NLABEL.  */
-   if (jump_chain && INSN_UID (nlabel) < max_jump_chain
-       && INSN_UID (jump) < max_jump_chain)
-     {
-       jump_chain[INSN_UID (jump)] = jump_chain[INSN_UID (nlabel)];
-       jump_chain[INSN_UID (nlabel)] = jump;
-     }
- 
-   for (notep = &REG_NOTES (jump), note = *notep; note; note = next)
-     {
-       next = XEXP (note, 1);
- 
-       if (REG_NOTE_KIND (note) != REG_DEAD
- 	  /* Verify that the REG_NOTE is legitimate.  */
- 	  || GET_CODE (XEXP (note, 0)) != REG
- 	  || ! reg_mentioned_p (XEXP (note, 0), PATTERN (jump)))
- 	notep = &XEXP (note, 1);
-       else
- 	{
- 	  delete_prior_computation (note, jump);
- 	  *notep = next;
- 	}
-     }
- 
-   PATTERN (jump) = gen_jump (nlabel);
-   JUMP_LABEL (jump) = nlabel;
-   ++LABEL_NUSES (nlabel);
-   INSN_CODE (jump) = -1;
- 
-   if (--LABEL_NUSES (olabel) == 0)
-     {
-       delete_labelref_insn (jump, olabel, 0);
-       delete_insn (olabel);
-     }
- }
- 
- /* Find the insn referencing LABEL that is a logical predecessor of INSN.
-    If we found one, delete it and then delete this insn if DELETE_THIS is
-    non-zero.  Return non-zero if INSN or a predecessor references LABEL.  */
- 
- static int
- delete_labelref_insn (insn, label, delete_this)
-      rtx insn, label;
-      int delete_this;
- {
-   int deleted = 0;
-   rtx link;
- 
-   if (GET_CODE (insn) != NOTE
-       && reg_mentioned_p (label, PATTERN (insn)))
-     {
-       if (delete_this)
- 	{
- 	  delete_insn (insn);
- 	  deleted = 1;
- 	}
-       else
- 	return 1;
-     }
- 
-   for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
-     if (delete_labelref_insn (XEXP (link, 0), label, 1))
-       {
- 	if (delete_this)
- 	  {
- 	    delete_insn (insn);
- 	    deleted = 1;
- 	  }
- 	else
- 	  return 1;
-       }
- 
-   return deleted;
- }
  
  /* Like rtx_equal_p except that it considers two REGs as equal
     if they renumber to the same value and considers two commutative
--- 2251,2256 ----
*** /p1/jumpr2/jumpr/egcs/gcc/reg-stack.c	Thu Jul 12 18:03:44 2001
--- reg-stack.c	Sun Jul 15 20:29:26 2001
*************** pop_stack (regstack, regno)
*** 406,412 ****
     dump file, if used.
  
     Construct a CFG and run life analysis.  Then convert each insn one
!    by one.  Run a last jump_optimize pass, if optimizing, to eliminate
     code duplication created when the converter inserts pop insns on
     the edges.  */
  
--- 406,412 ----
     dump file, if used.
  
     Construct a CFG and run life analysis.  Then convert each insn one
!    by one.  Run a last cleanup_cfg pass, if optimizing, to eliminate
     code duplication created when the converter inserts pop insns on
     the edges.  */
  
*** /p1/jumpr2/jumpr/egcs/gcc/rtl.h	Sat Jul 14 21:00:04 2001
--- rtl.h	Sun Jul 15 21:30:08 2001
*************** extern int rtx_renumbered_equal_p	PARAMS
*** 1715,1722 ****
  extern int true_regnum			PARAMS ((rtx));
  extern int redirect_jump_1		PARAMS ((rtx, rtx));
  extern int redirect_jump		PARAMS ((rtx, rtx, int));
- extern void jump_optimize		PARAMS ((rtx, int, int));
- extern void jump_optimize_minimal	PARAMS ((rtx));
  extern void rebuild_jump_labels		PARAMS ((rtx));
  extern int can_reverse_comparison_p	PARAMS ((rtx, rtx));
  extern enum rtx_code reversed_comparison_code PARAMS ((rtx, rtx));
--- 1715,1720 ----
*************** extern enum rtx_code reversed_comparison
*** 1725,1734 ****
  extern void delete_for_peephole		PARAMS ((rtx, rtx));
  extern int condjump_in_parallel_p	PARAMS ((rtx));
  extern void never_reached_warning	PARAMS ((rtx));
! 
! /* Flags for jump_optimize() */
! #define JUMP_NOOP_MOVES			1
! #define JUMP_AFTER_REGSCAN		1
  
  /* In emit-rtl.c. */
  extern int max_reg_num				PARAMS ((void));
--- 1723,1730 ----
  extern void delete_for_peephole		PARAMS ((rtx, rtx));
  extern int condjump_in_parallel_p	PARAMS ((rtx));
  extern void never_reached_warning	PARAMS ((rtx));
! extern void purge_line_number_notes	PARAMS ((rtx));
! extern void copy_loop_headers		PARAMS ((rtx));
  
  /* In emit-rtl.c. */
  extern int max_reg_num				PARAMS ((void));
*** /p1/jumpr2/jumpr/egcs/gcc/stmt.c	Thu Jul 12 18:03:44 2001
--- stmt.c	Sun Jul 15 20:29:55 2001
*************** expand_nl_handler_label (slot, before_in
*** 3467,3473 ****
    rtx insns;
    rtx handler_label = gen_label_rtx ();
  
!   /* Don't let jump_optimize delete the handler.  */
    LABEL_PRESERVE_P (handler_label) = 1;
  
    start_sequence ();
--- 3467,3473 ----
    rtx insns;
    rtx handler_label = gen_label_rtx ();
  
!   /* Don't let cleanup_cfg delete the handler.  */
    LABEL_PRESERVE_P (handler_label) = 1;
  
    start_sequence ();
*** /p1/jumpr2/jumpr/egcs/gcc/toplev.c	Sat Jul 14 14:57:44 2001
--- toplev.c	Sun Jul 15 22:40:56 2001
*************** rest_of_compilation (decl)
*** 2879,2885 ****
    purge_hard_subreg_sets (get_insns ());
    emit_initial_value_sets ();
  
!   /* Don't return yet if -Wreturn-type; we need to do jump_optimize.  */
    if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
      goto exit_rest_of_compilation;
  
--- 2880,2886 ----
    purge_hard_subreg_sets (get_insns ());
    emit_initial_value_sets ();
  
!   /* Don't return yet if -Wreturn-type; we need to do cleanup_cfg.  */
    if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
      goto exit_rest_of_compilation;
  
*************** rest_of_compilation (decl)
*** 2944,2950 ****
    expected_value_to_br_prob ();
  
    reg_scan (insns, max_reg_num (), 0);
!   jump_optimize (insns, !JUMP_NOOP_MOVES, JUMP_AFTER_REGSCAN);
  
    timevar_pop (TV_JUMP);
  
--- 2945,2955 ----
    expected_value_to_br_prob ();
  
    reg_scan (insns, max_reg_num (), 0);
!   rebuild_jump_labels (insns);
!   find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
!   cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
!   copy_loop_headers (insns);
!   purge_line_number_notes (insns);
  
    timevar_pop (TV_JUMP);
  
*************** rest_of_compilation (decl)
*** 3080,3086 ****
        if (tem || optimize > 1)
  	{
  	  timevar_push (TV_JUMP);
! 	  jump_optimize (insns, !JUMP_NOOP_MOVES, !JUMP_AFTER_REGSCAN);
  	  timevar_pop (TV_JUMP);
  	}
  
--- 3085,3093 ----
        if (tem || optimize > 1)
  	{
  	  timevar_push (TV_JUMP);
! 	  rebuild_jump_labels (insns);
! 	  find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
! 	  cleanup_cfg (CLEANUP_EXPENSIVE);
  	  timevar_pop (TV_JUMP);
  	}
  
*************** rest_of_compilation (decl)
*** 3154,3160 ****
  	{
  	  tem = tem2 = 0;
  	  timevar_push (TV_JUMP);
! 	  jump_optimize (insns, !JUMP_NOOP_MOVES, !JUMP_AFTER_REGSCAN);
  	  timevar_pop (TV_JUMP);
  
  	  if (flag_expensive_optimizations)
--- 3161,3168 ----
  	{
  	  tem = tem2 = 0;
  	  timevar_push (TV_JUMP);
! 	  rebuild_jump_labels (insns);
! 	  cleanup_cfg (CLEANUP_EXPENSIVE);
  	  timevar_pop (TV_JUMP);
  
  	  if (flag_expensive_optimizations)
*************** rest_of_compilation (decl)
*** 3227,3233 ****
  	  delete_trivially_dead_insns (insns, max_reg_num ());
  
  	  reg_scan (insns, max_reg_num (), 0);
- 	  jump_optimize (insns, !JUMP_NOOP_MOVES, JUMP_AFTER_REGSCAN);
  
  	  timevar_push (TV_IFCVT);
  
--- 3235,3240 ----
*************** rest_of_compilation (decl)
*** 3245,3251 ****
  	  if (tem)
  	    {
  	      timevar_push (TV_JUMP);
! 	      jump_optimize (insns, !JUMP_NOOP_MOVES, !JUMP_AFTER_REGSCAN);
  	      timevar_pop (TV_JUMP);
  	    }
  	}
--- 3252,3260 ----
  	  if (tem)
  	    {
  	      timevar_push (TV_JUMP);
! 	      rebuild_jump_labels (insns);
! 	      find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
! 	      cleanup_cfg (CLEANUP_EXPENSIVE);
  	      timevar_pop (TV_JUMP);
  	    }
  	}
*************** rest_of_compilation (decl)
*** 3552,3559 ****
    timevar_push (TV_FLOW2);
    open_dump_file (DFI_flow2, decl);
  
-   jump_optimize (insns, JUMP_NOOP_MOVES, !JUMP_AFTER_REGSCAN);
    find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
  
    /* On some machines, the prologue and epilogue code, or parts thereof,
       can be represented as RTL.  Doing so lets us schedule insns between
--- 3561,3568 ----
    timevar_push (TV_FLOW2);
    open_dump_file (DFI_flow2, decl);
  
    find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+   cleanup_cfg (0);
  
    /* On some machines, the prologue and epilogue code, or parts thereof,
       can be represented as RTL.  Doing so lets us schedule insns between
*************** rest_of_compilation (decl)
*** 3682,3687 ****
--- 3691,3698 ----
  #endif
  
    /* CFG no longer kept up to date.  */
+ 
+   purge_line_number_notes (insns);
  
    /* If a scheduling pass for delayed branches is to be done,
       call the scheduling code.  */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]