This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Fix PR88148
- From: Richard Biener <rguenther at suse dot de>
- To: gcc-patches at gcc dot gnu dot org
- Date: Thu, 22 Nov 2018 15:06:28 +0100 (CET)
- Subject: [PATCH] Fix PR88148
The following fixes the missing VN elimination in loop->nb_iterations
which causes ICEs later on.
Bootstrapped and tested on x86_64-unknown-linux-gnu, applied to trunk.
Richard.
2018-11-22 Richard Biener <rguenther@suse.de>
PR tree-optimization/88148
* tree-ssa-loop-niter.c (simplify_replace_tree): Get optional
valueization callback parameter and handle it.
* tree-ssa-loop-niter.h (simplify_replace_tree): Export.
* tree-ssa-sccvn.c (process_bb): Eliminate in loop niter trees.
* gfortran.dg/pr88148.f90: New testcase.
>From 8eb9fcc2eb090fff909b21c7ded50bfd1304fcc5 Mon Sep 17 00:00:00 2001
From: Richard Guenther <rguenther@suse.de>
Date: Thu, 22 Nov 2018 12:11:09 +0100
Subject: [PATCH] fix-pr88148
diff --git a/gcc/testsuite/gfortran.dg/pr88148.f90 b/gcc/testsuite/gfortran.dg/pr88148.f90
new file mode 100644
index 00000000000..cd4cd897c61
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr88148.f90
@@ -0,0 +1,705 @@
+! { dg-do compile }
+! { dg-options "-O -fno-tree-fre -fno-tree-sra -ftree-loop-vectorize" }
+! { dg-additional-options "-mavx2" { target x86_64-*-* i?86-*-* } }
+
+module lfk_prec
+ integer, parameter :: dp=kind(1.d0)
+end module lfk_prec
+
+!***********************************************
+
+SUBROUTINE kernel(tk)
+!***********************************************************************
+! *
+! KERNEL executes 24 samples of Fortran computation *
+! TK(1) - total cpu time to execute only the 24 kernels. *
+! TK(2) - total Flops executed by the 24 Kernels *
+!***********************************************************************
+! *
+! L. L. N. L. F O R T R A N K E R N E L S: M F L O P S *
+! *
+! These kernels measure Fortran numerical computation rates for a *
+! spectrum of CPU-limited computational structures. Mathematical *
+! through-put is measured in units of millions of floating-point *
+! operations executed per Second, called Mega-Flops/Sec. *
+! *
+! This program measures a realistic CPU performance range for the *
+! Fortran programming system on a given day. The CPU performance *
+! rates depend strongly on the maturity of the Fortran compiler's *
+! ability to translate Fortran code into efficient machine code. *
+! [ The CPU hardware capability apart from compiler maturity (or *
+! availability), could be measured (or simulated) by programming the *
+! kernels in assembly or machine code directly. These measurements *
+! can also serve as a framework for tracking the maturation of the *
+! Fortran compiler during system development.] *
+! *
+! Fonzi's Law: There is not now and there never will be a language *
+! in which it is the least bit difficult to write *
+! bad programs. *
+! F.H.MCMAHON 1972 *
+!***********************************************************************
+
+! l1 := param-dimension governs the size of most 1-d arrays
+! l2 := param-dimension governs the size of most 2-d arrays
+
+! Loop := multiple pass control to execute kernel long enough to ti
+! me.
+! n := DO loop control for each kernel. Controls are set in subr.
+! SIZES
+
+! ******************************************************************
+use lfk_prec
+implicit double precision (a-h,o-z)
+!IBM IMPLICIT REAL*8 (A-H,O-Z)
+
+REAL(kind=dp), INTENT(inout) :: tk
+INTEGER :: test !!,AND
+
+COMMON/alpha/mk,ik,im,ml,il,mruns,nruns,jr,iovec,npfs(8,3,47)
+COMMON/beta/tic,times(8,3,47),see(5,3,8,3),terrs(8,3,47),csums(8,3 &
+ ,47),fopn(8,3,47),dos(8,3,47)
+
+COMMON/spaces/ion,j5,k2,k3,loop1,laps,loop,m,kr,lp,n13h,ibuf,nx,l, &
+ npass,nfail,n,n1,n2,n13,n213,n813,n14,n16,n416,n21,nt1,nt2,last,idebug &
+ ,mpy,loop2,mucho,mpylim,intbuf(16)
+
+COMMON/spacer/a11,a12,a13,a21,a22,a23,a31,a32,a33,ar,br,c0,cr,di,dk &
+ ,dm22,dm23,dm24,dm25,dm26,dm27,dm28,dn,e3,e6,expmax,flx,q,qa,r,ri &
+ ,s,scale,sig,stb5,t,xnc,xnei,xnm
+
+COMMON/space0/time(47),csum(47),ww(47),wt(47),ticks,fr(9),terr1(47 &
+ ),sumw(7),start,skale(47),bias(47),ws(95),total(47),flopn(47),iq(7 &
+ ),npf,npfs1(47)
+
+COMMON/spacei/wtp(3),mul(3),ispan(47,3),ipass(47,3)
+
+! ******************************************************************
+
+
+INTEGER :: e,f,zone
+COMMON/ispace/e(96),f(96),ix(1001),ir(1001),zone(300)
+
+COMMON/space1/u(1001),v(1001),w(1001),x(1001),y(1001),z(1001),g(1001) &
+ ,du1(101),du2(101),du3(101),grd(1001),dex(1001),xi(1001),ex(1001) &
+ ,ex1(1001),dex1(1001),vx(1001),xx(1001),rx(1001),rh(2048),vsp(101) &
+ ,vstp(101),vxne(101),vxnd(101),ve3(101),vlr(101),vlin(101),b5(101) &
+ ,plan(300),d(300),sa(101),sb(101)
+
+COMMON/space2/p(4,512),px(25,101),cx(25,101),vy(101,25),vh(101,7), &
+ vf(101,7),vg(101,7),vs(101,7),za(101,7),zp(101,7),zq(101,7),zr(101 &
+ ,7),zm(101,7),zb(101,7),zu(101,7),zv(101,7),zz(101,7),b(64,64),c(64,64) &
+ ,h(64,64),u1(5,101,2),u2(5,101,2),u3(5,101,2)
+
+! ******************************************************************
+
+dimension zx(1023),xz(447,3),tk(6),mtmp(1)
+EQUIVALENCE(zx(1),z(1)),(xz(1,1),x(1))
+double precision temp
+logical ltmp
+
+
+! ******************************************************************
+
+! STANDARD PRODUCT COMPILER DIRECTIVES MAY BE USED FOR OPTIMIZATION
+
+
+
+
+
+CALL trace('KERNEL ')
+
+CALL SPACE
+
+mpy= 1
+mpysav= mpylim
+loop2= 1
+mpylim= loop2
+l= 1
+loop= 1
+lp= loop
+it0= test(0)
+loop2= mpysav
+mpylim= loop2
+do
+
+!***********************************************************************
+!*** KERNEL 1 HYDRO FRAGMENT
+!***********************************************************************
+
+ x(:n)= q+y(:n)*(r*zx(11:n+10)+t*zx(12:n+11))
+IF(test(1) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+! we must execute DO k= 1,n repeatedly for accurat
+! e timing
+
+!***********************************************************************
+!*** KERNEL 2 ICCG EXCERPT (INCOMPLETE CHOLESKY - CONJUGATE GRADIE
+! NT)
+!***********************************************************************
+
+
+ii= n
+ipntp= 0
+
+do while(ii > 1)
+ipnt= ipntp
+ipntp= ipntp+ii
+ii= ishft(ii,-1)
+i= ipntp+1
+!dir$ vector always
+ x(ipntp+2:ipntp+ii+1)=x(ipnt+2:ipntp:2)-v(ipnt+2:ipntp:2) &
+ &*x(ipnt+1:ipntp-1:2)-v(ipnt+3:ipntp+1:2)*x(ipnt+3:ipntp+1:2)
+END DO
+IF(test(2) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 3 INNER PRODUCT
+!***********************************************************************
+
+
+q= dot_product(z(:n),x(:n))
+IF(test(3) <= 0)THEN
+ EXIT
+END IF
+END DO
+m= (1001-7)/2
+
+!***********************************************************************
+!*** KERNEL 4 BANDED LINEAR EQUATIONS
+!***********************************************************************
+
+fw= 1.000D-25
+
+do
+!dir$ vector always
+ xz(6,:3)= y(5)*(xz(6,:3)+matmul(y(5:n:5), xz(:n/5,:3)))
+
+IF(test(4) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 5 TRI-DIAGONAL ELIMINATION, BELOW DIAGONAL (NO VECTORS
+! )
+!***********************************************************************
+
+
+tmp= x(1)
+DO i= 2,n
+ tmp= z(i)*(y(i)-tmp)
+ x(i)= tmp
+END DO
+IF(test(5) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 6 GENERAL LINEAR RECURRENCE EQUATIONS
+!***********************************************************************
+
+
+DO i= 2,n
+ w(i)= 0.0100D0+dot_product(b(i,:i-1),w(i-1:1:-1))
+END DO
+IF(test(6) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 7 EQUATION OF STATE FRAGMENT
+!***********************************************************************
+
+
+ x(:n)= u(:n)+r*(z(:n)+r*y(:n))+t*(u(4:n+3)+r*(u(3:n+2)+r*u(2:n+1))+t*( &
+ u(7:n+6)+q*(u(6:n+5)+q*u(5:n+4))))
+IF(test(7) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+
+!***********************************************************************
+!*** KERNEL 8 A.D.I. INTEGRATION
+!***********************************************************************
+
+
+nl1= 1
+nl2= 2
+fw= 2.000D0
+ DO ky= 2,n
+DO kx= 2,3
+ du1ky= u1(kx,ky+1,nl1)-u1(kx,ky-1,nl1)
+ du2ky= u2(kx,ky+1,nl1)-u2(kx,ky-1,nl1)
+ du3ky= u3(kx,ky+1,nl1)-u3(kx,ky-1,nl1)
+ u1(kx,ky,nl2)= u1(kx,ky,nl1)+a11*du1ky+a12*du2ky+a13 &
+ *du3ky+sig*(u1(kx+1,ky,nl1)-fw*u1(kx,ky,nl1)+u1(kx-1,ky,nl1))
+ u2(kx,ky,nl2)= u2(kx,ky,nl1)+a21*du1ky+a22*du2ky+a23 &
+ *du3ky+sig*(u2(kx+1,ky,nl1)-fw*u2(kx,ky,nl1)+u2(kx-1,ky,nl1))
+ u3(kx,ky,nl2)= u3(kx,ky,nl1)+a31*du1ky+a32*du2ky+a33 &
+ *du3ky+sig*(u3(kx+1,ky,nl1)-fw*u3(kx,ky,nl1)+u3(kx-1,ky,nl1))
+ END DO
+END DO
+IF(test(8) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 9 INTEGRATE PREDICTORS
+!***********************************************************************
+
+
+ px(1,:n)= dm28*px(13,:n)+px(3,:n)+dm27*px(12,:n)+dm26*px(11,:n)+dm25*px(10 &
+ ,:n)+dm24*px(9,:n)+dm23*px(8,:n)+dm22*px(7,:n)+c0*(px(5,:n)+px(6,:n))
+IF(test(9) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 10 DIFFERENCE PREDICTORS
+!***********************************************************************
+
+!dir$ unroll(2)
+ do k= 1,n
+ br= cx(5,k)-px(5,k)
+ px(5,k)= cx(5,k)
+ cr= br-px(6,k)
+ px(6,k)= br
+ ar= cr-px(7,k)
+ px(7,k)= cr
+ br= ar-px(8,k)
+ px(8,k)= ar
+ cr= br-px(9,k)
+ px(9,k)= br
+ ar= cr-px(10,k)
+ px(10,k)= cr
+ br= ar-px(11,k)
+ px(11,k)= ar
+ cr= br-px(12,k)
+ px(12,k)= br
+ px(14,k)= cr-px(13,k)
+ px(13,k)= cr
+ enddo
+IF(test(10) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 11 FIRST SUM. PARTIAL SUMS. (NO VECTORS)
+!***********************************************************************
+
+
+temp= 0
+DO k= 1,n
+ temp= temp+y(k)
+ x(k)= temp
+END DO
+IF(test(11) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 12 FIRST DIFF.
+!***********************************************************************
+
+ x(:n)= y(2:n+1)-y(:n)
+IF(test(12) <= 0)THEN
+ EXIT
+END IF
+END DO
+fw= 1.000D0
+
+!***********************************************************************
+!*** KERNEL 13 2-D PIC Particle In Cell
+!***********************************************************************
+
+
+do
+
+! rounding modes for integerizing make no difference here
+ do k= 1,n
+ i1= 1+iand(int(p(1,k)),63)
+ j1= 1+iand(int(p(2,k)),63)
+ p(3,k)= p(3,k)+b(i1,j1)
+ p(1,k)= p(1,k)+p(3,k)
+ i2= iand(int(p(1,k)),63)
+ p(1,k)= p(1,k)+y(i2+32)
+ p(4,k)= p(4,k)+c(i1,j1)
+ p(2,k)= p(2,k)+p(4,k)
+ j2= iand(int(p(2,k)),63)
+ p(2,k)= p(2,k)+z(j2+32)
+ i2= i2+e(i2+32)
+ j2= j2+f(j2+32)
+ h(i2,j2)= h(i2,j2)+fw
+ enddo
+IF(test(13) <= 0)THEN
+ EXIT
+END IF
+END DO
+fw= 1.000D0
+
+!***********************************************************************
+!*** KERNEL 14 1-D PIC Particle In Cell
+!***********************************************************************
+
+
+
+do
+
+ ix(:n)= grd(:n)
+!dir$ ivdep
+ vx(:n)= ex(ix(:n))-ix(:n)*dex(ix(:n))
+ ir(:n)= vx(:n)+flx
+ rx(:n)= vx(:n)+flx-ir(:n)
+ ir(:n)= iand(ir(:n),2047)+1
+ xx(:n)= rx(:n)+ir(:n)
+DO k= 1,n
+ rh(ir(k))= rh(ir(k))+fw-rx(k)
+ rh(ir(k)+1)= rh(ir(k)+1)+rx(k)
+END DO
+IF(test(14) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 15 CASUAL FORTRAN. DEVELOPMENT VERSION.
+!***********************************************************************
+
+
+! CASUAL ORDERING OF SCALAR OPERATIONS IS TYPICAL PRACTICE.
+! THIS EXAMPLE DEMONSTRATES THE NON-TRIVIAL TRANSFORMATION
+! REQUIRED TO MAP INTO AN EFFICIENT MACHINE IMPLEMENTATION.
+
+
+ng= 7
+nz= n
+ar= 0.05300D0
+br= 0.07300D0
+!$omp parallel do private(t,j,k,r,s,i,ltmp) if(nz>98)
+do j= 2,ng-1
+ do k= 2,nz
+ i= merge(k-1,k,vf(k,j) < vf((k-1),j))
+ t= merge(br,ar,vh(k,(j+1)) <= vh(k,j))
+ r= MAX(vh(i,j),vh(i,j+1))
+ s= vf(i,j)
+ vy(k,j)= t/s*SQRT(vg(k,j)**2+r*r)
+ if(k < nz)then
+ ltmp=vf(k,j) >= vf(k,(j-1))
+ i= merge(j,j-1,ltmp)
+ t= merge(ar,br,ltmp)
+ r= MAX(vg(k,i),vg(k+1,i))
+ s= vf(k,i)
+ vs(k,j)= t/s*SQRT(vh(k,j)**2+r*r)
+ endif
+ END do
+ vs(nz,j)= 0.0D0
+END do
+ vy(2:nz,ng)= 0.0D0
+IF(test(15) <= 0)THEN
+ EXIT
+END IF
+END DO
+ii= n/3
+
+!***********************************************************************
+!*** KERNEL 16 MONTE CARLO SEARCH LOOP
+!***********************************************************************
+
+lb= ii+ii
+k2= 0
+k3= 0
+
+do
+DO m= 1,zone(1)
+ j2= (n+n)*(m-1)+1
+ DO k= 1,n
+ k2= k2+1
+ j4= j2+k+k
+ j5= zone(j4)
+ IF(j5 >= n)THEN
+ IF(j5 == n)THEN
+ EXIT
+ END IF
+ k3= k3+1
+ IF(d(j5) < d(j5-1)*(t-d(j5-2))**2+(s-d(j5-3))**2+ (r-d(j5-4))**2)THEN
+ go to 200
+ END IF
+ IF(d(j5) == d(j5-1)*(t-d(j5-2))**2+(s-d(j5-3))**2+ (r-d(j5-4))**2)THEN
+ EXIT
+ END IF
+ ELSE
+ IF(j5-n+lb < 0)THEN
+ IF(plan(j5) < t)THEN
+ go to 200
+ END IF
+ IF(plan(j5) == t)THEN
+ EXIT
+ END IF
+ ELSE
+ IF(j5-n+ii < 0)THEN
+ IF(plan(j5) < s)THEN
+ go to 200
+ END IF
+ IF(plan(j5) == s)THEN
+ EXIT
+ END IF
+ ELSE
+ IF(plan(j5) < r)THEN
+ go to 200
+ END IF
+ IF(plan(j5) == r)THEN
+ EXIT
+ END IF
+ END IF
+ END IF
+ END IF
+ IF(zone(j4-1) <= 0)THEN
+ go to 200
+ END IF
+ END DO
+ EXIT
+ 200 IF(zone(j4-1) == 0)THEN
+ EXIT
+ END IF
+END DO
+IF(test(16) <= 0)THEN
+ EXIT
+END IF
+END DO
+dw= 5.0000D0/3.0000D0
+
+!***********************************************************************
+!*** KERNEL 17 IMPLICIT, CONDITIONAL COMPUTATION (NO VECTORS)
+!***********************************************************************
+
+! RECURSIVE-DOUBLING VECTOR TECHNIQUES CAN NOT BE USED
+! BECAUSE CONDITIONAL OPERATIONS APPLY TO EACH ELEMENT.
+
+fw= 1.0000D0/3.0000D0
+tw= 1.0300D0/3.0700D0
+
+do
+scale= dw
+rtmp= fw
+e6= tw
+DO k= n,2,-1
+ e3= rtmp*vlr(k)+vlin(k)
+ xnei= vxne(k)
+ vxnd(k)= e6
+ xnc= scale*e3
+! SELECT MODEL
+ IF(max(rtmp,xnei) <= xnc)THEN
+! LINEAR MODEL
+ ve3(k)= e3
+ rtmp= e3+e3-rtmp
+ vxne(k)= e3+e3-xnei
+ ELSE
+ rtmp= rtmp*vsp(k)+vstp(k)
+! STEP MODEL
+ vxne(k)= rtmp
+ ve3(k)= rtmp
+ END IF
+ e6= rtmp
+END DO
+xnm= rtmp
+IF(test(17) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 18 2-D EXPLICIT HYDRODYNAMICS FRAGMENT
+!***********************************************************************
+
+
+t= 0.003700D0
+s= 0.004100D0
+kn= 6
+jn= n
+ zb(2:jn,2:kn)=(zr(2:jn,2:kn)+zr(2:jn,:kn-1))/(zm(2:jn,2:kn)+zm(:jn-1,2:kn)) &
+ *(zp(:jn-1,2:kn)-zp(2:jn,2:kn)+(zq(:jn-1,2:kn)-zq(2:jn,2:kn)))
+ za(2:jn,2:kn)=(zr(2:jn,2:kn)+zr(:jn-1,2:kn))/(zm(:jn-1,2:kn)+zm(:jn-1,3:kn+1)) &
+ *(zp(:jn-1,3:kn+1)-zp(:jn-1,2:kn)+(zq(:jn-1,3:kn+1)-zq(:jn-1,2:kn)))
+ zu(2:jn,2:kn)= zu(2:jn,2:kn)+ &
+ s*(za(2:jn,2:kn)*(zz(2:jn,2:kn)-zz(3:jn+1,2:kn)) &
+ -za(:jn-1,2:kn)*(zz(2:jn,2:kn)-zz(:jn-1,2:kn)) &
+ -zb(2:jn,2:kn)*(zz(2:jn,2:kn)-zz(2:jn,:kn-1))+ &
+ zb(2:jn,3:kn+1)*(zz(2:jn, 2:kn)-zz(2:jn,3:kn+1)))
+ zv(2:jn,2:kn)= zv(2:jn,2:kn)+ &
+ s*(za(2:jn,2:kn)*(zr(2:jn,2:kn)-zr(3:jn+1,2:kn)) &
+ -za(:jn-1,2:kn)*(zr(2:jn,2:kn)-zr(:jn-1,2:kn)) &
+ -zb(2:jn,2:kn)*(zr(2:jn,2:kn)-zr(2:jn,:kn-1))+ &
+ zb(2:jn,3:kn+1)*(zr(2:jn, 2:kn)-zr(2:jn,3:kn+1)))
+ zr(2:jn,2:kn)= zr(2:jn,2:kn)+t*zu(2:jn,2:kn)
+ zz(2:jn,2:kn)= zz(2:jn,2:kn)+t*zv(2:jn,2:kn)
+IF(test(18) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 19 GENERAL LINEAR RECURRENCE EQUATIONS (NO VECTORS)
+!***********************************************************************
+
+kb5i= 0
+
+DO k= 1,n
+ b5(k+kb5i)= sa(k)+stb5*sb(k)
+ stb5= b5(k+kb5i)-stb5
+END DO
+DO k= n,1,-1
+ b5(k+kb5i)= sa(k)+stb5*sb(k)
+ stb5= b5(k+kb5i)-stb5
+END DO
+IF(test(19) <= 0)THEN
+ EXIT
+END IF
+END DO
+dw= 0.200D0
+
+!***********************************************************************
+!*** KERNEL 20 DISCRETE ORDINATES TRANSPORT: RECURRENCE (NO VECTORS
+!***********************************************************************
+
+
+do
+
+rtmp= xx(1)
+DO k= 1,n
+ di= y(k)*(rtmp+dk)-g(k)
+ dn=merge( max(s,min(z(k)*(rtmp+dk)/di,t)),dw,di /= 0.0)
+ x(k)= ((w(k)+v(k)*dn)*rtmp+u(k))/(vx(k)+v(k)*dn)
+ rtmp= ((w(k)-vx(k))*rtmp+u(k))*DN/(vx(k)+v(k)*dn)+ rtmp
+ xx(k+1)= rtmp
+END DO
+IF(test(20) <= 0)THEN
+ EXIT
+END IF
+END DO
+
+do
+
+!***********************************************************************
+!*** KERNEL 21 MATRIX*MATRIX PRODUCT
+!***********************************************************************
+
+ px(:25,:n)= px(:25,:n)+matmul(vy(:25,:25),cx(:25,:n))
+IF(test(21) <= 0)THEN
+ EXIT
+END IF
+END DO
+expmax= 20.0000D0
+
+
+!***********************************************************************
+!*** KERNEL 22 PLANCKIAN DISTRIBUTION
+!***********************************************************************
+
+! EXPMAX= 234.500d0
+fw= 1.00000D0
+u(n)= 0.99000D0*expmax*v(n)
+
+do
+
+ y(:n)= u(:n)/v(:n)
+ w(:n)= x(:n)/(EXP(y(:n))-fw)
+IF(test(22) <= 0)THEN
+ EXIT
+END IF
+END DO
+fw= 0.17500D0
+
+!***********************************************************************
+!*** KERNEL 23 2-D IMPLICIT HYDRODYNAMICS FRAGMENT
+!***********************************************************************
+
+
+do
+
+ DO k= 2,n
+ do j=2,6
+ za(k,j)= za(k,j)+fw*(za(k,j+1)*zr(k,j)-za(k,j)+ &
+ & zv(k,j)*za(k-1,j)+(zz(k,j)+za(k+1,j)* &
+ & zu(k,j)+za(k,j-1)*zb(k,j)))
+ END DO
+ END DO
+IF(test(23) <= 0)THEN
+ EXIT
+END IF
+END DO
+x(n/2)= -1.000D+10
+
+!***********************************************************************
+!*** KERNEL 24 FIND LOCATION OF FIRST MINIMUM IN ARRAY
+!***********************************************************************
+
+! X( n/2)= -1.000d+50
+
+do
+ m= minloc(x(:n),DIM=1)
+
+IF(test(24) == 0)THEN
+ EXIT
+END IF
+END DO
+sum= 0.00D0
+som= 0.00D0
+DO k= 1,mk
+ sum= sum+time(k)
+ times(jr,il,k)= time(k)
+ terrs(jr,il,k)= terr1(k)
+ npfs(jr,il,k)= npfs1(k)
+ csums(jr,il,k)= csum(k)
+ dos(jr,il,k)= total(k)
+ fopn(jr,il,k)= flopn(k)
+ som= som+flopn(k)*total(k)
+END DO
+tk(1)= tk(1)+sum
+tk(2)= tk(2)+som
+! Dumpout Checksums: file "chksum"
+! WRITE ( 7,706) jr, il
+! 706 FORMAT(1X,2I3)
+! WRITE ( 7,707) ( CSUM(k), k= 1,mk)
+! 707 FORMAT(5X,'&',1PE23.16,',',1PE23.16,',',1PE23.16,',')
+
+CALL track('KERNEL ')
+RETURN
+END SUBROUTINE kernel
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 67a3d689463..78165f389cb 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -1919,10 +1919,14 @@ number_of_iterations_cond (struct loop *loop,
return ret;
}
-/* Substitute NEW for OLD in EXPR and fold the result. */
+/* Substitute NEW_TREE for OLD in EXPR and fold the result.
+ If VALUEIZE is non-NULL then OLD and NEW_TREE are ignored and instead
+ all SSA names are replaced with the result of calling the VALUEIZE
+ function with the SSA name as argument. */
-static tree
-simplify_replace_tree (tree expr, tree old, tree new_tree)
+tree
+simplify_replace_tree (tree expr, tree old, tree new_tree,
+ tree (*valueize) (tree))
{
unsigned i, n;
tree ret = NULL_TREE, e, se;
@@ -1931,11 +1935,20 @@ simplify_replace_tree (tree expr, tree old, tree new_tree)
return NULL_TREE;
/* Do not bother to replace constants. */
- if (CONSTANT_CLASS_P (old))
+ if (CONSTANT_CLASS_P (expr))
return expr;
- if (expr == old
- || operand_equal_p (expr, old, 0))
+ if (valueize)
+ {
+ if (TREE_CODE (expr) == SSA_NAME)
+ {
+ new_tree = valueize (expr);
+ if (new_tree != expr)
+ return new_tree;
+ }
+ }
+ else if (expr == old
+ || operand_equal_p (expr, old, 0))
return unshare_expr (new_tree);
if (!EXPR_P (expr))
@@ -1945,7 +1958,7 @@ simplify_replace_tree (tree expr, tree old, tree new_tree)
for (i = 0; i < n; i++)
{
e = TREE_OPERAND (expr, i);
- se = simplify_replace_tree (e, old, new_tree);
+ se = simplify_replace_tree (e, old, new_tree, valueize);
if (e == se)
continue;
diff --git a/gcc/tree-ssa-loop-niter.h b/gcc/tree-ssa-loop-niter.h
index c5c6a84a959..a7269d91fc1 100644
--- a/gcc/tree-ssa-loop-niter.h
+++ b/gcc/tree-ssa-loop-niter.h
@@ -53,6 +53,7 @@ extern bool scev_probably_wraps_p (tree, tree, tree, gimple *,
struct loop *, bool);
extern void free_numbers_of_iterations_estimates (struct loop *);
extern void free_numbers_of_iterations_estimates (function *);
+extern tree simplify_replace_tree (tree, tree, tree, tree (*)(tree) = NULL);
extern void substitute_in_loop_info (struct loop *, tree, tree);
#endif /* GCC_TREE_SSA_LOOP_NITER_H */
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 17d9f5e06d1..e0ff40555ea 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -68,6 +68,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfgcleanup.h"
#include "tree-ssa-loop.h"
#include "tree-scalar-evolution.h"
+#include "tree-ssa-loop-niter.h"
#include "tree-ssa-sccvn.h"
/* This algorithm is based on the SCC algorithm presented by Keith
@@ -5904,6 +5905,16 @@ process_bb (rpo_elim &avail, basic_block bb,
break;
}
+ /* When we visit a loop header substitute into loop info. */
+ if (!iterate && eliminate && bb->loop_father->header == bb)
+ {
+ /* Keep fields in sync with substitute_in_loop_info. */
+ if (bb->loop_father->nb_iterations)
+ bb->loop_father->nb_iterations
+ = simplify_replace_tree (bb->loop_father->nb_iterations,
+ NULL_TREE, NULL_TREE, vn_valueize);
+ }
+
/* Value-number all defs in the basic-block. */
for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
gsi_next (&gsi))