Simple giv combination improvement

[Jan Hubicka]

Hi
This patch adds some code to loop.c to let combine givs with constant (but non-CONST_INT)
delta.  This is benefical in reducting number of iterators in the loops traversing
static arrays.

In my favorite test loop w/o patch I get:

char a[1];
char b[1];
main()
{
  int i;
  for(i=1;i<10000;i++)
    a[i]=a[i+1]+b[i];
}


	.file	"t.c"
	.version	"01.01"
gcc2_compiled.:
	.comm	a,1,1
	.comm	b,1,1
.text
	.align 16
.globl main
	.type	 main,@function
main:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$a+2, %ecx
	pushl	%edi
	movl	$2, %edi
	pushl	%esi
	movl	$a+1, %esi
	pushl	%ebx
	movl	$b+1, %ebx
	.p2align 4
.L6:
	movzbl	(%ebx), %eax
	leal	8(%edi), %edx
	addl	$9, %edi
	addb	(%ecx), %al
<SNIP>
	movb	%al, 7(%esi)
	movzbl	8(%ebx), %eax
	addl	$9, %ebx
	addb	8(%ecx), %al
	addl	$9, %ecx
	movb	%al, 8(%esi)
	addl	$9, %esi
	cmpl	$9999, %edx
	jle	.L6
	popl	%ebx
	popl	%esi
	popl	%edi
	popl	%ebp
	ret
.Lfe1:
	.size	 main,.Lfe1-main
	.ident	"GCC: (GNU) 2.96 20000412 (experimental)"

So you can see number of extra iterators. With the patch I get


	.file	"t.c"
	.version	"01.01"
gcc2_compiled.:
	.comm	a,1,1
	.comm	b,1,1
.text
	.align 16
.globl main
	.type	 main,@function
main:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$2, %ecx
	.p2align 4
.L6:
	movzbl	b-1(%ecx), %eax
	movl	%ecx, %edx
	addb	a(%ecx), %al
	movb	%al, a-1(%ecx)
	movzbl	b(%edx), %eax
	addb	a+1(%edx), %al
	movb	%al, a(%edx)
	movzbl	b+1(%ecx), %eax
	leal	8(%ecx), %edx
	addb	a+2(%ecx), %al
	movb	%al, a+1(%ecx)
	movzbl	b+2(%ecx), %eax
	addb	a+3(%ecx), %al
	movb	%al, a+2(%ecx)
	movzbl	b+3(%ecx), %eax
	addb	a+4(%ecx), %al
	movb	%al, a+3(%ecx)
	movzbl	b+4(%ecx), %eax
	addb	a+5(%ecx), %al
	movb	%al, a+4(%ecx)
	movzbl	b+5(%ecx), %eax
	addb	a+6(%ecx), %al
	movb	%al, a+5(%ecx)
	movzbl	b+6(%ecx), %eax
	addb	a+7(%ecx), %al
	movb	%al, a+6(%ecx)
	movzbl	b+7(%ecx), %eax
	addb	a+8(%ecx), %al
	movb	%al, a+7(%ecx)
	addl	$9, %ecx
	cmpl	$9999, %edx
	jle	.L6
	popl	%ebp
	ret
.Lfe1:
	.size	 main,.Lfe1-main
	.ident	"GCC: (GNU) 2.96 20000412 (experimental)"
Basically I just use simplify_rtx to prove constantness of the values
and then just use CONSTANT_P instead of GET_CODE (x) == CONST_INT.

Fri Apr 14 10:25:55 CEST 2000  Jan Hubicka  <jh@suse.cz>
	* loop.c (strength_reduce): Simplify test to
	GET_RTX_CLASS (GET_CODE (p)) == 'i')
	(record_giv): Attempt to simplify the add value, use CONSTANT_P
	expressions instead of CONST_INT.
	(express_from_1): Likewise.
*** loop.c.old	Thu Apr 13 08:14:40 2000
--- loop.c	Fri Apr 14 10:10:58 2000
*************** strength_reduce (loop, insn_count, unrol
*** 3996,4003 ****
        if (GET_CODE (p) == CALL_INSN)
  	call_seen = 1;
  
!       if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
! 	  || GET_CODE (p) == CALL_INSN)
  	note_stores (PATTERN (p), record_initial, NULL);
  
        /* Record any test of a biv that branches around the loop if no store
--- 4377,4383 ----
        if (GET_CODE (p) == CALL_INSN)
  	call_seen = 1;
  
!       if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
  	note_stores (PATTERN (p), record_initial, NULL);
  
        /* Record any test of a biv that branches around the loop if no store
*************** record_giv (loop, v, insn, src_reg, dest
*** 5539,5544 ****
--- 5933,5950 ----
    struct induction *b;
    struct iv_class *bl;
    rtx set = single_set (insn);
+   rtx temp;
+ 
+   /* Attempt to prove constantness of the values.  */
+   temp = simplify_rtx (add_val);
+   if (temp)
+     add_val = temp;
  
    v->insn = insn;
    v->src_reg = src_reg;
*************** record_giv (loop, v, insn, src_reg, dest
*** 5697,5707 ****
      v->no_const_addval = 1;
      if (tem == const0_rtx)
        ;
!     else if (GET_CODE (tem) == CONST_INT)
        v->no_const_addval = 0;
!     else if (GET_CODE (tem) == PLUS)
        {
!         while (1)
  	  {
  	    if (GET_CODE (XEXP (tem, 0)) == PLUS)
  	      tem = XEXP (tem, 0);
--- 6103,6113 ----
      v->no_const_addval = 1;
      if (tem == const0_rtx)
        ;
!     else if (CONSTANT_P (add_val))
        v->no_const_addval = 0;
!     if (GET_CODE (tem) == PLUS)
        {
! 	while (1)
  	  {
  	    if (GET_CODE (XEXP (tem, 0)) == PLUS)
  	      tem = XEXP (tem, 0);
*************** record_giv (loop, v, insn, src_reg, dest
*** 5710,5717 ****
  	    else
  	      break;
  	  }
!         if (GET_CODE (XEXP (tem, 1)) == CONST_INT)
!           v->no_const_addval = 0;
        }
    }
  
--- 6116,6123 ----
  	    else
  	      break;
  	  }
! 	if (CONSTANT_P (XEXP (tem, 1)))
! 	  v->no_const_addval = 0;
        }
    }
  
*************** express_from_1 (a, b, mult)
*** 6948,6953 ****
--- 7354,7363 ----
      {
        return plus_constant (b, -INTVAL (a) * INTVAL (mult));
      }
+   else if (CONSTANT_P (a))
+     {
+       return simplify_gen_binary (MINUS, GET_MODE (b), const0_rtx, a);
+     }
    else if (GET_CODE (b) == PLUS)
      {
        if (rtx_equal_p (a, XEXP (b, 0)))