PATCH: Lazy DECL_RTL

[Mark Mitchell]

Rod --

  I'm now testing the following patch on your box, as well as on my
local box.

  Hopefully, this will fix the problem.  Comments from CSE experts
welcome.

  Thanks,

--
Mark Mitchell                   mark@codesourcery.com
CodeSourcery, LLC               http://www.codesourcery.com

Index: cse.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cse.c,v
retrieving revision 1.174
diff -c -p -r1.174 cse.c
*** cse.c	2001/02/06 12:55:06	1.174
--- cse.c	2001/03/19 08:14:17
*************** find_best_addr (insn, loc, mode)
*** 3083,3099 ****
  #endif
  }
  
! /* Given an operation (CODE, *PARG1, *PARG2), where code is a comparison
!    operation (EQ, NE, GT, etc.), follow it back through the hash table and
!    what values are being compared.
! 
!    *PARG1 and *PARG2 are updated to contain the rtx representing the values
!    actually being compared.  For example, if *PARG1 was (cc0) and *PARG2
!    was (const_int 0), *PARG1 and *PARG2 will be set to the objects that were
!    compared to produce cc0.
  
!    The return value is the comparison operator and is either the code of
!    A or the code corresponding to the inverse of the comparison.  */
  
  static enum rtx_code
  find_comparison_args (code, parg1, parg2, pmode1, pmode2)
--- 3083,3107 ----
  #endif
  }
  
! /* This routine accepts a comparison as input and attempts to return a
!    comparision that is cheaper to compute.
  
!    On input, *PARG1 and *PARG2 should be set to the first and second
!    arguments to the comparison, respectively.  CODE is the comparision
!    code.  For example, if the comparison is:
! 
!      (ne:SI (reg:CC 24 cc)
!             (const_int 0 [0x0])))
! 
!    The CODE should be NE, *PARG1 should be `(reg:CC 24 cc)' and 
!    *PARG2 should be `(const_int 0)'.
! 
!    Upon return, *PARG1 and and *PARG2 may have new values, indicating
!    arguments to a cheaper comparison.  *PMODE1 and *PMODE2 will be the
!    modes that should be used for those arguments.  The return value
!    itself will be the comparison code that should be used to compare
!    *PARG1 and *PARG2 in order to obtain a value equivalent to that
!    given by the original comparison.  */
  
  static enum rtx_code
  find_comparison_args (code, parg1, parg2, pmode1, pmode2)
*************** find_comparison_args (code, parg1, parg2
*** 3184,3213 ****
  	  if (! exp_equiv_p (p->exp, p->exp, 1, 0))
  	    continue;
  
! 	  if (GET_CODE (p->exp) == COMPARE
! 	      /* Another possibility is that this machine has a compare insn
! 		 that includes the comparison code.  In that case, ARG1 would
! 		 be equivalent to a comparison operation that would set ARG1 to
! 		 either STORE_FLAG_VALUE or zero.  If this is an NE operation,
! 		 ORIG_CODE is the actual comparison being done; if it is an EQ,
! 		 we must reverse ORIG_CODE.  On machine with a negative value
! 		 for STORE_FLAG_VALUE, also look at LT and GE operations.  */
! 	      || ((code == NE
! 		   || (code == LT
! 		       && GET_MODE_CLASS (inner_mode) == MODE_INT
! 		       && (GET_MODE_BITSIZE (inner_mode)
! 			   <= HOST_BITS_PER_WIDE_INT)
! 		       && (STORE_FLAG_VALUE
! 			   & ((HOST_WIDE_INT) 1
! 			      << (GET_MODE_BITSIZE (inner_mode) - 1))))
  #ifdef FLOAT_STORE_FLAG_VALUE
! 		   || (code == LT
! 		       && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
! 		       && (REAL_VALUE_NEGATIVE
! 			   (FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)))))
  #endif
! 		   )
! 		  && GET_RTX_CLASS (GET_CODE (p->exp)) == '<'))
  	    {
  	      x = p->exp;
  	      break;
--- 3192,3229 ----
  	  if (! exp_equiv_p (p->exp, p->exp, 1, 0))
  	    continue;
  
! 	  /* `(COMPARE A B) != 0)' is equivalent to `(COMPARE A B)'.
! 	     If CODE is EQ, rather than NE, then we are out of luck;
! 	     there is no way to reverse the sense of a COMPARE.  */
! 	  if (code == NE && GET_CODE (p->exp) == COMPARE)
! 	    {
! 	      x = p->exp;
! 	      break;
! 	    }
! 	  /* Another possibility is that this machine has a compare
! 	     insn that includes the comparison code.  In that case,
! 	     ARG1 would be equivalent to a comparison operation that
! 	     would set ARG1 to either STORE_FLAG_VALUE or zero.  If
! 	     this is an NE operation, ORIG_CODE is the actual
! 	     comparison being done; if it is an EQ, we must reverse
! 	     ORIG_CODE.  On machine with a negative value for
! 	     STORE_FLAG_VALUE, also look at LT and GE operations.  */
! 	  else if ((code == NE
! 		    || (code == LT
! 			&& GET_MODE_CLASS (inner_mode) == MODE_INT
! 			&& (GET_MODE_BITSIZE (inner_mode)
! 			    <= HOST_BITS_PER_WIDE_INT)
! 			&& (STORE_FLAG_VALUE
! 			    & ((HOST_WIDE_INT) 1
! 			       << (GET_MODE_BITSIZE (inner_mode) - 1))))
  #ifdef FLOAT_STORE_FLAG_VALUE
! 		    || (code == LT
! 			&& GET_MODE_CLASS (inner_mode) == MODE_FLOAT
! 			&& (REAL_VALUE_NEGATIVE
! 			    (FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)))))
  #endif
! 		    )
! 		   && GET_RTX_CLASS (GET_CODE (p->exp)) == '<')
  	    {
  	      x = p->exp;
  	      break;