[Bug fortran/52117] allocated arrays give incorrect results when used with RESHAPE in gcc v4.6.2

["burnus at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

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

--- Comment #5 from Tobias Burnus <burnus at gcc dot gnu.org> 2012-02-06 20:01:15 UTC ---
(In reply to comment #4)
> Thanks. I tried the -std=f95 flag and it gave the same (wrong) answer as
> without it, in the test code I sent you. What is not Fortran95 compatible with
> the code snippet I sent you?

I works for me both with GCC 4.6 and GCC 4.7 both with the current version but
also with a version which still had bug 52012.

Can you please answer the following question? You only kind of answered the
third question, namely that you used the original program (of comment 0).
Additional, could you provide more information about the version you used
("gfortran -v"), of interest are the complete of "Target" and of "gcc version".


(In reply to comment #3)
> Can you provides more details?
> 
> In particular:
> - How does it fail? At compile time? At run time? With which error?
> - Which version/platform of the compiler are you using?
> - Is that with the code of comment 0 with only "B = RESHAPE..." changed to
> "B(:) = RESHAPE..." or is it for some other code?


Example on my system for a 4.6 version which has still the bug:

$ gfortran-4.6 -v |& grep -E 'gcc version|Target'
Target: x86_64-suse-linux
gcc version 4.6.2 20111212 [gcc-4_6-branch revision 182222] (SUSE Linux) 

$ gfortran-4.6 -std=f95 test.f90 
test.f90:37.11:
      PAUSE
           1
Error: Deleted feature: PAUSE statement at (1)

And after commenting that line:

$ gfortran-4.6 -std=f95 test.f90
 A(           1 ,           1 ) =    1.00000000      B =    1.00000000    
 A(           2 ,           1 ) =    2.00000000      B =    2.00000000    
 A(           1 ,           2 ) =    3.00000000      B =    3.00000000    
 A(           2 ,           2 ) =    4.00000000      B =    4.00000000    
 A(           1 ,           3 ) =    5.00000000      B =    5.00000000    
 A(           2 ,           3 ) =    6.00000000      B =    6.00000000    
 A(           1 ,           4 ) =    7.00000000      B =    7.00000000    
 A(           2 ,           4 ) =    8.00000000      B =    8.00000000    

The output looks correct and is the same as with other compilers. However, if I
use the buggy version of the compiler without -std=f95, I get:

$ gfortran-4.6 hj4.f90  && ./a.out 
 A(           1 ,           1 ) =    1.00000000      B =    3.00000000    
 A(           2 ,           1 ) =    2.00000000      B =    4.00000000    
 A(           1 ,           2 ) =    3.00000000      B =    5.00000000    
 A(           2 ,           2 ) =    4.00000000      B =    6.00000000    
 A(           1 ,           3 ) =    5.00000000      B =    7.00000000    
 A(           2 ,           3 ) =    6.00000000      B =    8.00000000    
 A(           1 ,           4 ) =    7.00000000      B =    3.36311631E-44
 A(           2 ,           4 ) =    8.00000000      B =    9.62964972E-35


As written, using "(:)" - or to be more precise (it's a rank-3 array) -
"B(:,:,:) = ", -fno-realloc-lhs, or a newer version of the compiler solves the
problem as well.