Le 21/04/2022 à 23:14, Mikael Morin a écrit :
Hello,
this is a fix for PR103662, a TBAA issue with unlimited polymorphic types.
I attached a draft patch to the PR which was accumulating all unlimited
polymorphic symbols to a single namespace, avoiding duplicate symbols
and thus eliminating the problem.
After reviewing the code more in detail, I was afraid that some symbols
could still end up in the local namespace, and that the problem would
remain for them after all.
Despite not being able to generate a testcase where it happened, I
decided to produce a patch based on Jakub’s analysis in the PR audit
trail, as that way supports duplicates by design.
On top of Jakub’s patch, there are a couple more types registrations
just in case (they handle duplicates so that’s fine), and the type
comparison fix that he was too fortran-uncomfortable to do.
The testcase had to be fixed as we found out in the PR audit trail.
Regression tested on x86_64-pc-linux-gnu. OK for master?
Mikael
I have read Jakub’s analysis again, and it says the type registration is
useless for unlimited polymorphic fake symbols, as they are all
translated as ptr_type_node.
So it can be dropped, which brings this v2 patch closer to Jakub’s original.
Regression tested again. OK?From e53ecc979ec2a798626eb94c60d18b015d6f52e5 Mon Sep 17 00:00:00 2001
From: Mikael Morin
Date: Wed, 20 Apr 2022 12:04:38 +0200
Subject: [PATCH v2] fortran: Detect duplicate unlimited polymorphic types
[PR103662]
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
This fixes a type-based alias analysis issue with unlimited polymorphic
class descriptors (types behind class(*)) causing data initialisation to
be removed by optimization.
The fortran front-end may create multiple declarations for types, for
example if a type is redeclared in each program unit it is used in.
To avoid optimization seeing them as non-aliasing, a list of derived
types is created at resolution time, and used at translation to set
the same TYPE_CANONICAL type for each duplicate type declaration.
This mechanism didn’t work for unlimited polymorphic descriptors types,
as there is a short-circuit return skipping all the resolution handling
for them, including the type registration.
This change adds type registration at the short-circuit return, and
updates type comparison to handle specifically unlimited polymorphic
fake symbols, class descriptor types and virtual table types.
The test, which exhibited mismatching dynamic types had to be fixed as
well.
PR fortran/103662
gcc/fortran/ChangeLog:
* interface.cc (gfc_compare_derived_types): Support comparing
unlimited polymorphic fake symbols. Recursively compare class
descriptor types and virtual table types.
* resolve.cc (resolve_fl_derived): Add type to the types list
on unlimited polymorphic short-circuit return.
gcc/testsuite/ChangeLog:
* gfortran.dg/unlimited_polymorphic_3.f03 (foo): Separate
bind(c) and sequence checks to...
(foo_bc, foo_sq): ... two different procedures.
(main, foo*): Change type declarations so that type name,
component name, and either bind(c) or sequence attribute match
between the main type declarations and the procedure type
declarations.
(toplevel): Add optimization dump checks.
Co-Authored-By: Jakub Jelinek
---
gcc/fortran/interface.cc | 19 +--
gcc/fortran/resolve.cc| 5 +-
.../gfortran.dg/unlimited_polymorphic_3.f03 | 56 +--
3 files changed, 58 insertions(+), 22 deletions(-)
diff --git a/gcc/fortran/interface.cc b/gcc/fortran/interface.cc
index 000a530cba4..7ed6e13711f 100644
--- a/gcc/fortran/interface.cc
+++ b/gcc/fortran/interface.cc
@@ -618,6 +618,14 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2)
if (!derived1 || !derived2)
gfc_internal_error ("gfc_compare_derived_types: invalid derived type");
+ if (derived1->attr.unlimited_polymorphic
+ && derived2->attr.unlimited_polymorphic)
+return true;
+
+ if (derived1->attr.unlimited_polymorphic
+ != derived2->attr.unlimited_polymorphic)
+return false;
+
/* Compare UNION types specially. */
if (derived1->attr.flavor == FL_UNION || derived2->attr.flavor == FL_UNION)
return compare_union_types (derived1, derived2);
@@ -630,10 +638,11 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2)
&& strcmp (derived1->module, derived2->module) == 0)
return true;
- /* Compare type via the rules of the standard. Both types must have
- the SEQUENCE or BIND(C) attribute to be equal. STRUCTUREs are special
- because they can be anonymous; therefore two structures with different
- names may be equal. */
+ /* Compare type via the rules of the standard. Both types must have the
+ SEQUENCE or BIND(C) attribute to be equal. We also compare types
+ recursively if they are class descriptors types or virtual tables types.
+
