[Bug fortran/47051] New: [4.6 Regression] wrong reallocate

[Bug fortran/47051] New: [4.6 Regression] wrong reallocate

[Joost.VandeVondele at pci dot uzh.ch]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

           Summary: [4.6 Regression] wrong reallocate
           Product: gcc
           Version: 4.6.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: fortran
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: Joost.VandeVondele@pci.uzh.ch


In the following a reallocation seems to happen, changing the bounds of a.
However the size of a and b are the same, so I would not expect this.

 INTEGER, DIMENSION(:), ALLOCATABLE :: a,b
 ALLOCATE(a(-1:1),b(1:3))
 b=0
 a=b
 write(6,*) LBOUND(a)
 IF(LBOUND(a,1).NE.-1) STOP "BUG"
END

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[dominiq at lps dot ens.fr]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #1 from Dominique d'Humieres <dominiq at lps dot ens.fr> 2010-12-23 13:36:40 UTC ---
> ... so I would not expect this.

Why?

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[Joost.VandeVondele at pci dot uzh.ch]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #2 from Joost VandeVondele <Joost.VandeVondele at pci dot uzh.ch> 2010-12-23 13:46:50 UTC ---
(In reply to comment #1)
> > ... so I would not expect this.
> 
> Why?

that would imply that F95 code and F2003 code are not compatible ? Or was this
not allowed in F95 (certainly that was in CP2K, and no compiler ever gave a
bounds check error)

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[Joost.VandeVondele at pci dot uzh.ch]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #3 from Joost VandeVondele <Joost.VandeVondele at pci dot uzh.ch> 2010-12-23 13:56:29 UTC ---
OK, more checking. F2003 specifies that the lhs should only be deallocated if
it differs in shape. a and b have the same shape here.

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[dominiq at lps dot ens.fr]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #4 from Dominique d'Humieres <dominiq at lps dot ens.fr> 2010-12-23 15:13:46 UTC ---
I have raised a similar question in

http://gcc.gnu.org/ml/fortran/2010-11/msg00004.html answered in the following
posts in this thread.

The relevant part of the standard (from f2008 draft) is

7.2.1.3 Interpretation of intrinsic assignments

...

3 If the variable is an unallocated allocatable array, expr shall have the same
rank. If the variable is an allocated allocatable variable, it is deallocated
if expr is an array of diff\verent shape, any of the corresponding length type
parameter values of the variable and expr diff\ver, or the variable is
polymorphic and the dynamic type of the variable and expr diff\ver. If the
variable is or becomes an unallocated allocatable variable, it is then
allocated with
\x0f if the variable is polymorphic, the same dynamic type as expr,
\x0f each deferred type parameter equal to the corresponding type parameter of
expr,
\x0f if the variable is an array and expr is scalar, the same bounds as before,
and
\x0f if expr is an array, the shape of expr with each lower bound equal to the
corresponding element of
LBOUND (expr).
NOTE 7.36
For example, given the declaration
CHARACTER(:),ALLOCATABLE :: NAME
then after the assignment statement
NAME = 'Dr. '//FIRST_NAME//' '//SURNAME
NAME will have the length LEN(FIRST NAME)+LEN(SURNAME)+5, even if it had
previously been
unallocated, or allocated with a di\verent length. However, for the assignment
statement
NAME(:) = 'Dr. '//FIRST_NAME//' '//SURNAME
NAME must already be allocated at the time of the assignment; the assigned
value is truncated or blank
padded to the previously allocated length of NAME.

For which a strict reading of " If the variable is or becomes an unallocated
allocatable variable, ... the shape of expr with each lower bound equal to the
corresponding element of
LBOUND (expr)." support this PR since a is not deallocated. If this reading is
right it will be a very strong restriction for "reallocate on assignement":

 INTEGER, DIMENSION(:), ALLOCATABLE :: a,b,c,d
 ALLOCATE(a(-1:1),b(1:3),c(2:3),d(3:6))
 b=0
 c=0
 d=0
 a=b
 write(6,*) LBOUND(a), size(a)
 a=c
 write(6,*) LBOUND(a), size(a)
 a=d
 write(6,*) LBOUND(a), size(a)
END

will give

          -1           3
           2           2
           3           4

Note that there are two work-around:
(1) compile with -fno-realloc-lhs,
(2) use a(:).

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[Joost.VandeVondele at pci dot uzh.ch]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #5 from Joost VandeVondele <Joost.VandeVondele at pci dot uzh.ch> 2010-12-23 15:32:14 UTC ---
(In reply to comment #4)
Hi Dominique,

I have read exactly this:

> 3 If the variable is an unallocated allocatable array, expr shall have the same
> rank. If the variable is an allocated allocatable variable, it is deallocated
> if expr is an array of diff\verent shape, any of the corresponding length type
> parameter values of the variable and expr diff\ver, or the variable is
> polymorphic and the dynamic type of the variable and expr diff\ver. 

this section explicitly says it is deallocated only if the shape is different.
In my example, the shape is the same (even if the bounds are different). 

There is thus no need to deallocate a, and reallocate afterwards with the
bounds of b.

Joost

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[pault at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Paul Thomas <pault at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |pault at gcc dot gnu.org

--- Comment #6 from Paul Thomas <pault at gcc dot gnu.org> 2010-12-23 17:51:00 UTC ---
(In reply to comment #4)

>  INTEGER, DIMENSION(:), ALLOCATABLE :: a,b,c,d
>  ALLOCATE(a(-1:1),b(1:3),c(2:3),d(3:6))
>  b=0
>  c=0
>  d=0
>  a=b
>  write(6,*) LBOUND(a), size(a)
>  a=c
>  write(6,*) LBOUND(a), size(a)
>  a=d
>  write(6,*) LBOUND(a), size(a)
> END
> 
> will give
> 
>           -1           3
>            2           2
>            3           4
> 
> Note that there are two work-around:
> (1) compile with -fno-realloc-lhs,
> (2) use a(:).

extending this example slightly:

 INTEGER, DIMENSION(:), ALLOCATABLE :: a,b,c,d
 ALLOCATE(a(-1:1),b(1:3),c(2:3),d(3:6))
 b=0
 c=0
 d=0
 write(6,*) LBOUND(a), size(a), loc(a(lbound(a)))
 a=b
 write(6,*) LBOUND(a), size(a), loc(a(lbound(a)))
 a=c
 write(6,*) LBOUND(a), size(a), loc(a(lbound(a)))
 a=d
 write(6,*) LBOUND(a), size(a), loc(a(lbound(a)))
END

gives

[prt@localhost pr47051]# ifort --version
ifort (IFORT) 11.1 20090630
Copyright (C) 1985-2009 Intel Corporation.  All rights reserved.

[prt@localhost pr47051]# ifort -assume realloc-lhs pr47051a.f90
[prt@localhost pr47051]# ./a.out
          -1           3              17346660
           1           3              17346652
           2           2              17346648
           3           4              17346644

and for gfortran:
          -1           3      140736566840176
           1           3      140736566840128
           2           2      140736566840080
           3           4      140736566840032

Thus the bounds are the same and it was this comparison that made me stop where
I did.  Worryingly, though, the array is being reallocated at each assignment. 
If you examine the code, the address should be the same for the first two
lines, since the array sizes are the same.

In summary, the reallocation should NOT occur and the setting of the bounds
should be sorted out.

Cheers

Paul

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[rguenth at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Richard Guenther <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |4.6.0

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[jakub at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Priority|P3                          |P4
                 CC|                            |jakub at gcc dot gnu.org

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[jvdelisle at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Jerry DeLisle <jvdelisle at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jvdelisle at gcc dot
                   |                            |gnu.org

--- Comment #7 from Jerry DeLisle <jvdelisle at gcc dot gnu.org> 2010-12-30 03:19:55 UTC ---
Whys is this a regression? When did it work last?

[Bug fortran/47051] [4.6 Regression] wrong reallocate

[mikael at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Mikael Morin <mikael at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |mikael at gcc dot gnu.org

--- Comment #8 from Mikael Morin <mikael at gcc dot gnu.org> 2010-12-30 14:43:46 UTC ---
(In reply to comment #7)
> When did it work last?

When automatic/implicit reallocation on assignment was not supported. ;-)

[Bug fortran/47051] Wrong reallocate

[tkoenig at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Thomas Koenig <tkoenig at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2010.12.30 16:53:55
            Summary|[4.6 Regression] wrong      |Wrong reallocate
                   |reallocate                  |
     Ever Confirmed|0                           |1

--- Comment #9 from Thomas Koenig <tkoenig at gcc dot gnu.org> 2010-12-30 16:53:55 UTC ---
Not a regression, adjusting subject, confirming.

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[Joost.VandeVondele at pci dot uzh.ch]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Joost VandeVondele <Joost.VandeVondele at pci dot uzh.ch> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |wrong-code
            Summary|Wrong reallocate            |[4.6 Regression] Wrong
                   |                            |reallocate

--- Comment #10 from Joost VandeVondele <Joost.VandeVondele at pci dot uzh.ch> 2011-01-02 11:54:52 UTC ---
The testcase in comment #0 is just Fortran95 (i.e. is well defined without
reallocation), and works fine with all versions of gfortran prior to 4.6. It is
thus a regression, and a quite serious one IMO since it can affect any code
using array assignment. It was found with CP2K, if that matters.

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[tkoenig at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Thomas Koenig <tkoenig at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Blocks|                            |32834

--- Comment #11 from Thomas Koenig <tkoenig at gcc dot gnu.org> 2011-01-02 22:17:32 UTC ---
Joost, you're right.

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[pault at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Paul Thomas <pault at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot       |pault at gcc dot gnu.org
                   |gnu.org                     |

--- Comment #12 from Paul Thomas <pault at gcc dot gnu.org> 2011-01-04 19:24:18 UTC ---
Obviously, I should take this one.  As soon as I have done with PR46896, I will
turn to this one.

Paul

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[pault at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #13 from Paul Thomas <pault at gcc dot gnu.org> 2011-01-09 21:02:50 UTC ---
Created attachment 22936
  --> http://gcc.gnu.org/bugzilla/attachment.cgi?id=22936
This patch fixes the PR

I need to go through this with a fine toothed comb.  It regtests OK and
represents a big simplification of the code.

I'll submit tomorrow.

Paul

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[pault at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #14 from Paul Thomas <pault at gcc dot gnu.org> 2011-01-10 07:31:42 UTC ---
(In reply to comment #13)

> I'll submit tomorrow.

Done http://gcc.gnu.org/ml/fortran/2011-01/msg00075.html

Paul

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[pault at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

--- Comment #15 from Paul Thomas <pault at gcc dot gnu.org> 2011-01-11 05:19:24 UTC ---
Author: pault
Date: Tue Jan 11 05:19:20 2011
New Revision: 168650

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=168650
Log:
2011-01-11  Paul Thomas  <pault@gcc.gnu.org>

    PR fortran/47051
    * trans-array.c (gfc_alloc_allocatable_for_assignment): Change
    to be standard compliant by testing for shape rather than size
    before skipping reallocation. Improve comments.

2011-01-11  Paul Thomas  <pault@gcc.gnu.org>

    PR fortran/47051
    * gfortran.dg/realloc_on_assign_2.f03 : Modify 'test1' to be
    standard compliant and comment.

Modified:
    trunk/gcc/fortran/ChangeLog
    trunk/gcc/fortran/trans-array.c
    trunk/gcc/testsuite/ChangeLog
    trunk/gcc/testsuite/gfortran.dg/realloc_on_assign_2.f03

[Bug fortran/47051] [4.6 Regression] Wrong reallocate

[pault at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47051

Paul Thomas <pault at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
         Resolution|                            |FIXED

--- Comment #16 from Paul Thomas <pault at gcc dot gnu.org> 2011-01-11 05:20:48 UTC ---
Fixed.  Thanks for the report Joost!

Paul