procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fortran: Separate associate character lengths earlier [PR104570]

Browse source 
This change workarounds an ICE in the evaluation of the character length
of an array expression referencing an associate variable; the code is
not prepared to see a non-scalar expression as it doesn’t initialize the
scalarizer.

Before this change, associate length symbols get a new gfc_charlen at
resolution stage to unshare them from the associate expression, so that
at translation stage it is a decl specific to the associate symbol that
is initialized, not the decl of some other symbol.  This
reinitialization of gfc_charlen happens after expressions referencing
the associate symbol have been parsed, so that those expressions retain
the original gfc_charlen they have copied from the symbol.
At translation stage, the gfc_charlen for the associate symbol is setup
with the decl holding the actual length value, but the expressions have
retained the original gfc_charlen without any decl.  So they need to
evaluate the character length, and this is where the ICE happens.

This change moves the reinitialization of gfc_charlen earlier at parsing
stage, so that at resolution stage the gfc_charlen can be retained as
it’s already not shared with any other symbol, and the expressions which
now share their gfc_charlen with the symbol are automatically updated
when the length decl is setup at translation stage.  There is no need
any more to evaluate the character length as it has all the required
information, and the ICE doesn’t happen.

The first resolve.cc hunk is necessary to avoid regressing on the
associate_35.f90 testcase.

	PR fortran/104228
	PR fortran/104570

gcc/fortran/ChangeLog:

	* parse.cc (parse_associate): Use a new distinct gfc_charlen if the
	copied type has one whose length is not known to be constant.
	* resolve.cc (resolve_assoc_var): Reset charlen if it’s shared with
	the associate target regardless of the expression type.
	Don’t reinitialize charlen if it’s deferred.

gcc/testsuite/ChangeLog:

	* gfortran.dg/associate_58.f90: New test.
This commit is contained in:
Mikael Morin 2022-03-13 22:22:55 +01:00
parent 638e630142
commit 907811ddc3
3 changed files with 45 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
gcc/fortran/parse.cc
View file

@ -4924,6 +4924,24 @@ parse_associate (void)
in case of association to a derived-type. */
sym->ts = a->target->ts;
/* Don’t share the character length information between associate
variable and target if the length is not a compile-time constant,
as we don’t want to touch some other character length variable when
we try to initialize the associate variable’s character length
variable.
We do it here rather than later so that expressions referencing the
associate variable will automatically have the correctly setup length
information. If we did it at resolution stage the expressions would
use the original length information, and the variable a new different
one, but only the latter one would be correctly initialized at
translation stage, and the former one would need some additional setup
there. */
if (sym->ts.type == BT_CHARACTER
&& sym->ts.u.cl
&& !(sym->ts.u.cl->length
&& sym->ts.u.cl->length->expr_type == EXPR_CONSTANT))
sym->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
/* Check if the target expression is array valued. This cannot always
be done by looking at target.rank, because that might not have been
set yet. Therefore traverse the chain of refs, looking for the last

9
gcc/fortran/resolve.cc
View file

@ -9232,7 +9232,7 @@ resolve_assoc_var (gfc_symbol* sym, bool resolve_target)
if (!sym->ts.u.cl)
sym->ts.u.cl = target->ts.u.cl;
if (sym->ts.deferred && target->expr_type == EXPR_VARIABLE
if (sym->ts.deferred
&& sym->ts.u.cl == target->ts.u.cl)
{
sym->ts.u.cl = gfc_new_charlen (sym->ns, NULL);
@ -9251,8 +9251,11 @@ resolve_assoc_var (gfc_symbol* sym, bool resolve_target)
|| sym->ts.u.cl->length->expr_type != EXPR_CONSTANT)
&& target->expr_type != EXPR_VARIABLE)
{
sym->ts.u.cl = gfc_new_charlen (sym->ns, NULL);
sym->ts.deferred = 1;
if (!sym->ts.deferred)
{
sym->ts.u.cl = gfc_new_charlen (sym->ns, NULL);
sym->ts.deferred = 1;
}
/* This is reset in trans-stmt.cc after the assignment
of the target expression to the associate name. */

21
gcc/testsuite/gfortran.dg/associate_58.f90 Normal file
View file

@ -0,0 +1,21 @@
! { dg-do compile }
!
! PR fortran/104570
! The following used to cause an ICE because the string length
! evaluation of the (y) expression was not prepared to handle
! a non-scalar expression.
program p
character(:), allocatable :: x(:)
x = ['abc']
call s
contains
subroutine s
associate (y => x)
associate (z => (y))
print *, z
end associate
end associate
end
end