Re: Clarification on Gcc's strict aliasing rules

[Patrick Horgan <phorgan1 at yahoo dot com>]

On 11/06/2010 03:15 PM, Francis Moreau wrote:
> Hello,
>
> I'm trying to understand what '-fstrict-aliasing' actually means.
>
> Looking at the man page, one can read:
>
>     -fstrict-aliasing
>         Allow the compiler to assume the strictest aliasing
>         rules applicable to the language being compiled.  For C
>         [...]
>
> What does "the strictest aliasing rules ..." means ?
>
>     - Does it mean that Gcc allows only a subset of the standard aliasing
>       rules (which I believe is defined in 6.5p7 ? In this case, which
>       ones ?
GCC allows them all.
>       That would mean that Gcc also miss compiled conforming programs.
>
>     - Does it mean that the C standard has some 'gray' areas (undefined
>       behaviours) about aliasing and Gcc choose to specify the behaviour
>       for optimisation purposes ?
>
>     - or something else ?
>
>
> Also I don't really understand the examples provided by the man page. Ok
> type punning using union is still allowed.
>
> But the second example which is:
>
>      However, this code might not:
>
> 		  int f() {
> 		    union a_union t;
> 		    int* ip;
> 		    t.d = 3.0;
> 		    ip =&t.i;
> 		    return *ip;
> 		  }
>
> _might_ not work. Why using 'might' ? Does it work or not ?
> AFAIK, this type of aliasing is defined by the standard.
Might not means that it does something that breaks the 
aliasing rules, but it might compile into code that 
does what you want, but a later version of the compiler 
might not.  You can alias through the union is 
guaranteed to work, but aliasing through pointers to 
members of the union is not on the list in 6.5p7.   You 
don't want to rely on behavior that might not work.
> The third example is:
>
>      Similarly, access by taking the address, casting the
>      resulting pointer and dereferencing the result has
>      undefined behavior, even if the cast uses a union type,
>      e.g.:
>
> 		  int f() {
> 		    double d = 3.0;
> 		    return ((union a_union *)&d)->i;
> 		  }
>
> Again in my understanding of the standard, this is an undefined
> behaviour. So why does man page mention this case ?
It mentions it because a lot of people said that they 
thought the wording of the standard would allow this.  
If you google for strict aliasing you find it all over 
the place.  Now people can't say that.
If you look on the boost wiki you find a discussion of 
strict-aliasing and how gcc generates awesome code if 
you do things right.  (If you like it I wrote that 
section, if you don't it was probably random cosmic rays).

https://svn.boost.org/trac/boost/wiki/Guidelines/WarningsGuidelines

In general, if it's almost the same thing it will just 
work, otherwise use a union and don't try something 
fancy like using pointers.

Patrick