https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65892

--- Comment #46 from James Kuyper Jr. <jameskuyper at alumni dot caltech.edu> 
---
(In reply to Andrew Haley from comment #42)
...
> In order to use type-based alias analysis in any LTO framework it's
> necessary to save type information, and this is just more type
> information. ...

Speaking from a developer's perspective rather than an implementor's
perspective, the implementation already needs to keep track of where the
union's completed definition is in scope, because it's only in those locations
where it would be permitted to define an object having the union's type. This
is just a different use for the same information; it shouldn't require storing
any additional information; nor should it require holding on to that
information for any longer than is already required.
As a matter of efficient implementation, rather than correctness, I think it
might be useful to store, for each struct type, a list of the union definitions
for which this might be an issue, a list that would not be needed for any other
reason. However, most of the time, that list would be empty - only when it's
not empty would the compiler need to review that list to determine which other
struct types might be permitted to alias this type, to a limited extent.

> ... The question is, I suppose, how to handle the scopes of
> union declarations.  I'd just treat them as being global, which in
> practice isn't unrealistic because such declarations are in header
> files in global scope and shared anyway.

Why not use the actual scope of the completed union declaration, which is what
the relevant rule refers to?

> So, if any union types with a common initial sequence are declared
> anywhere in a program, then their member types alias.

As I understand it, the visibility rule was added specifically for the purpose
of NOT requiring that the entire program be covered by this exception.
Knowledgeable people writing code intended to take advantage of this feature of
C are likely to carefully place completed declarations of the union's type so
they disable those optimizations only where they need to be disabled, and to
minimize the amount of code where this exception would unnecessarily disable
useful optimizations.

Reply via email to