From e79eb02f2f09baecffb144bac6804f975065466f Mon Sep 17 00:00:00 2001 From: Andrew Burgess Date: Thu, 9 Jul 2020 16:26:23 +0100 Subject: gdb/fortran: resolve dynamic types when readjusting after an indirection After dereferencing a pointer (in value_ind) or following a reference (in coerce_ref) we call readjust_indirect_value_type to "fixup" the type of the resulting value object. This fixup handles cases relating to the type of the resulting object being different (a sub-class) of the original pointers target type. If we encounter a pointer to a dynamic type then after dereferencing a pointer (in value_ind) the type of the object created will have had its dynamic type resolved. However, in readjust_indirect_value_type, we use the target type of the original pointer to "fixup" the type of the resulting value. In this case, the target type will be a dynamic type, so the resulting value object, once again has a dynamic type. This then triggers an assertion later within GDB. The solution I propose here is that we call resolve_dynamic_type on the pointer's target type (within readjust_indirect_value_type) so that the resulting value is not converted back to a dynamic type. The test case is based on the original test in the bug report. gdb/ChangeLog: PR fortran/23051 PR fortran/26139 * valops.c (value_ind): Pass address to readjust_indirect_value_type. * value.c (readjust_indirect_value_type): Make parameter non-const, and add extra address parameter. Resolve original type before using it. * value.h (readjust_indirect_value_type): Update function signature and comment. gdb/testsuite/ChangeLog: PR fortran/23051 PR fortran/26139 * gdb.fortran/class-allocatable-array.exp: New file. * gdb.fortran/class-allocatable-array.f90: New file. * gdb.fortran/pointer-to-pointer.exp: New file. * gdb.fortran/pointer-to-pointer.f90: New file. --- .../gdb.fortran/class-allocatable-array.f90 | 54 ++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 gdb/testsuite/gdb.fortran/class-allocatable-array.f90 (limited to 'gdb/testsuite/gdb.fortran/class-allocatable-array.f90') diff --git a/gdb/testsuite/gdb.fortran/class-allocatable-array.f90 b/gdb/testsuite/gdb.fortran/class-allocatable-array.f90 new file mode 100644 index 0000000..26d5fab --- /dev/null +++ b/gdb/testsuite/gdb.fortran/class-allocatable-array.f90 @@ -0,0 +1,54 @@ +! Copyright 2020 Free Software Foundation, Inc. +! +! This program is free software; you can redistribute it and/or modify +! it under the terms of the GNU General Public License as published by +! the Free Software Foundation; either version 3 of the License, or +! (at your option) any later version. +! +! This program is distributed in the hope that it will be useful, +! but WITHOUT ANY WARRANTY; without even the implied warranty of +! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +! GNU General Public License for more details. +! +! You should have received a copy of the GNU General Public License +! along with this program. If not, see . + +module test_module + type test_type + integer a + real, allocatable :: b (:, :) + contains + procedure :: test_proc + end type test_type + +contains + + subroutine test_proc (this) + class(test_type), intent (inout) :: this + allocate (this%b (3, 2)) + call fill_array_2d (this%b) + print *, "" ! Break Here + contains + ! Helper subroutine to fill 2-dimensional array with unique + ! values. + subroutine fill_array_2d (array) + real, dimension (:,:) :: array + real :: counter + + counter = 1.0 + do i=LBOUND (array, 2), UBOUND (array, 2), 1 + do j=LBOUND (array, 1), UBOUND (array, 1), 1 + array (j,i) = counter + counter = counter + 1 + end do + end do + end subroutine fill_array_2d + end subroutine test_proc +end module + +program test + use test_module + implicit none + type(test_type) :: t + call t%test_proc () +end program test -- cgit v1.1