... Can a conforming implementation fold a and b if their uses
don't overlap, but the program examines their addresses? In other
words, the following program:
#include <stdio.h>
int main(void)
{
int a, b;
a = 10;
printf("a = %d, ", a);
b = 20;
printf("b = %d, ", b);
printf("addresses are %s\n", &a == &b ? "equal" : "unequal");
return 0;
}
should normally print
a = 10, b = 20, addresses are unequal
if a and b are not folded. If it prints
a = 10, b = 20, addresses are equal
does it imply that the compiler is non-conforming?
In C at least, yes it does. (I would be quite surprised if the
answer changes for C++.) Note that the compiler *can* still combine
the underlying storage space for "a" and "b", as long as it *also*
pretends that &a != &b even though then &a == &b. For instance,
suppose the compiler first tries to optimize the printf() call.
At this time, "a" and "b" are still separate entities in the
compiler's internal representation (e.g., separate RTL pseudo-registers
inside GCC). Thus the result of &a==&b is a known constant 0 (in
C). The next step is to replace:
printf("addresses are %s\n", 0 ? "equal" : "unequal");
with:
printf("addresses are %s\n", "unequal");
and perhaps even optimize this into:
puts("addresses are unequal"); /* note, puts() adds the \n */
Now that this has been done, there is no longer any occurrence of
&a or &b, so now the entities "a" and "b" can be folded together
to occupy the same hard-register-or-stack-slot. So now &a==&b even
though the code that prints whether &a==&b says they are not!
(Of course, if they are in a "hard register" they may not have an
address at all; and in the case of GCC, at least, constant propagation
would result in their removal entirely, at this point.)
If you were to replace the above printf() call with:
printf("addresses are %p and %p\n", (void *)&a, (void *)&b);
the system would have to print two different numbers, in general,
and this would probably preclude the sort of folding described
here.
