On Tue, Mar 17, 2015 at 3:32 PM, Jeroen Dobbelaere < [email protected]> wrote:
> > > On Tue, Mar 17, 2015 at 11:15 PM, Daniel Berlin <[email protected]> > 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 >
_______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
