[cfe-dev] [PATCH] Fix for bug 21725: wrong results with union and strict-aliasing

[Daniel Berlin]

On Tue, Mar 17, 2015 at 3:32 PM, Jeroen Dobbelaere <
jeroen.dobbelaere at gmail.com> wrote:

>
>
> On Tue, Mar 17, 2015 at 11:15 PM, Daniel Berlin <dberlin at dberlin.org>
> wrote:
>
>>
>> [..]
>> I don't understand what this means. How should they do that?
>>
>> So, his point was the arrays have no connections to the union. This is
>> not the only case this occurs in.
>>
>> Let's take the canonical example:
>>
>>
>> For example
>>
>> union foo {
>> int a;
>> float b;
>> };
>>
>> int ihateunions(int *a, float *b)
>> {
>> <do a thing with a and b>
>> }
>>
>> int passtounion()
>> {
>> union foo bar;
>> ihateunions(&bar.a, &bar.b);
>>
>> }
>>
>> Inside ihateunions, you will have no idea that a and b are connected to
>> unions.
>>
>> Let's say this example is easy, i mean, they are both at offset 0, so
>> they can alias, right?
>>
>>
> My understanding is that if you access members of a union in this way,
> the compiler is allowed
> to assume that a and b do not alias.
>


In theory, the last time i remember, you weren't allow to set one member of
a union and read another.
But uh, that's not real user code :)

(and IIRC, it does not say anything real)


>
> If you access a member (or nested member) of a union, starting from the
> union itself, then it depends if the other type is also accessible through
> the union.
>
>
> So:
>
> int foo(union foo* a, float* b, int* c) {
>   a->a=1;
>   *b=2;
>   // compiler must assume a->a and *b can alias
>   // compiler must not assume *b and *c alias (access not through union)
> }
>
> (Also see section 3.10 of the c++03 standard;
>


This, IMHO, does not say what you seem to think it does :)

For C++03,  3.10 only includes the word "union" here: "If a program
attempts to access the stored value of an object through an lvalue of other
than one of the following types the behavior is undefined:

— the dynamic type of the object,
— a cv-qualified version of the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to the dynamic
type of the object,
 — a type that is the signed or unsigned type corresponding to a
cv-qualified version of the dynamic type of the object,
— an aggregate or union type that includes one of the aforementioned types
among its members (including, recursively, a member of a subaggregate or
contained union),
 — a type that is a (possibly cv-qualified) base class type of the dynamic
type of the object,
 — a char or unsigned char type."


C++ standard experts, at least on the GCC side, did not view this as saying
"all accesses must have an explicit union access", but that "It must be
part of a union type", but about whether you try to access it through a
union that doesn't have the right actual types in it.

The type of those objects is right the type of the object. There is, IMHO,
 nothing illegal about those accesses.




> and
> http://stackoverflow.com/questions/98650/what-is-the-strict-aliasing-rule
> )
>

Stackoverflow is not really a good resource for this type of question.


>
>
> Greetings,
>
> Jeroen Dobbelaere
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-dev/attachments/20150317/31580c7a/attachment.html>