This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: PATCH: Lazy DECL_RTL
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;