Am Dienstag, dem 02.04.2024 um 20:42 +0000 schrieb Joseph Myers:
> On Tue, 2 Apr 2024, Martin Uecker wrote:
>
> > [C23]fix aliasing for structures/unions with incomplete types
> >
> > When incomplete structure/union types are completed later, compatibility
> > of struct types that contain pointers to such types changes. When forming
> > equivalence classes for TYPE_CANONICAL, we therefor need to be conservative
> > and treat all structs with the same tag which are pointer targets as
> > equivalent.
>
> I don't see how what it done is actually about "which are pointer
> targets".
Right, I see now that the description needs to be improved. This refers
only to targets of pointers included somewhere in the type we process
for purposes of determining the equivalence class of this type (but
not for other contexts).
>
> > @@ -1355,6 +1356,7 @@ comptypes_internal (const_tree type1, const_tree
> > type2,
> > /* Do not remove mode information. */
> > if (TYPE_MODE (t1) != TYPE_MODE (t2))
> > return false;
> > + data->pointedto = true;
> > return comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2), data);
>
> This appears to be more like "which are the targets of pointers that *have
> just been compared in the present comptypes call*". Not which are targets
> of some other pointers not involved in that call.
Correct.
>
> Maybe some such logic based only on pointers compared in the present call
> makes sense for some purposes, but it's not clear to me that either this
> or any similar approach is a good approach for TYPE_CANONICAL - couldn't
> that mean that two types are considered equivalent for TYPE_CANONICAL at
> one point in the translation unit, but no longer equivalent at some later
> point when the comparison takes place in the context of comparing two
> other pointer types?
They would always be considered equivalent when pointed to from another
struct (or indirectly from a type nested in this struct) for purposes
of determining the equivalence class of this struct.
When not a pointer target, i.e. when considering the struct type itself
for which we compute TYPE_CANONICAL or another struct type directly used
for a member, then the types are compared by recursing into them. Such
types can never be incomplete at this point, so this is also stable property.
To summarize: for determining equivalence classes we always stop
the recursion after following pointers into other structs. We give
the same TYPE_CANONICAL to the following two structs foo:
struct foo { struct aa { int x; } *p; };
struct foo { struct aa { float x; } *p; };
while we give different TYPE_CANONICAL to
struct bar { struct aa { int x; } p; };
struct bar { struct aa { float x; } p; };
(not pointer). The reason is that for the struct foo's there
could be a
struct foo { struct aa *p; };
with incomplete type struct aa that later turns out to be compatible
with either of them. So we have to put them all into the same
equivalence class.
(a potential alternative is to compute the classes only at the very end
when all types have stablized, but this would require much more changes
and another pass over all the types.)
Note that the TYPE_CANONICAL for the aa's is not affected in any case and
always computed based on *their* content independent of whether they are
pointer targets or not. (but this reminds me to double check what
happens with types that are never completed in a TU.).
I hope this explanation makes sense.
Martin
>
