https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82996
--- Comment #10 from Neil Carlson <neil.n.carlson at gmail dot com> ---
A reader on c.l.f suggested this workaround for the bug. I'm sharing it here
because I think it may help to isolate where the problem is. The suggestion
was to make the B array component allocatable and allocate it inside SUB. This
allows more control over when its finalizer is called. Here's a modified
version the runs without error (with -fsanitize=address,undefined) and valgrind
shows nothing amiss. (I'm using the 9.0 trunk)
module mod
type foo
integer, pointer :: f(:) => null()
contains
final :: foo_destroy
end type
type bar
type(foo), allocatable :: b(:)
end type
contains
elemental subroutine foo_destroy(this)
type(foo), intent(inout) :: this
if (associated(this%f)) deallocate(this%f)
end subroutine
end module
program main
use mod
type(bar) :: x
call sub(x) ! x%b not allocated
call sub(x) ! x%b is allocated
contains
subroutine sub(x)
type(bar), intent(out) :: x
allocate(x%b(2))
end subroutine
end program
The interesting thing is that the finalizer works just fine when the %B
component is allocatable and allocated (the second call to SUB), but not when
it is not allocatable.
