Why is this addition being silently ignored?

Question

I have the following C code:

#include <stdint.h>
#include <stdio.h>

int i;
uint64_t a[] = { (uint64_t)&i, (uint64_t)&i + 0x8000000000000000 };

int main() {
    printf("%p %llx %llx\n", &i, a[0], a[1]);
}

If I compile this (as C or as C++) with Microsoft Visual Studio Community 2015 and then run it, the output is similar to the following:

013E9154 13e9154 13e9154

It seems that the code + 0x8000000000000000, which I expected to set the high bit of a[1], has been silently ignored.

However, if I move the initialization of a inside main, the output is what I would expect:

00179154 179154 8000000000179154

With a global, why is the addition being silently ignored? Should the attempted addition actually set the high bit of a[1] or should it cause a compiler error?

Interestingly, if + 0x8000000000000000 in the above code is replaced by | 0x8000000000000000, I get "error C2099: initializer is not a constant".

Edit: A similar issue can occur even in the absence of casts. Compiled for x64, the following code prints the same value (e.g. 000000013FB8D180) three times:

#include <stdio.h>

int i;
int * a[] = { &i, &i + 0x100000000 };

int main() {
    printf("%p %p %p\n", &i, a[0], a[1]);
}

Answer 1

The initializer

(uint64_t)&i + 0x8000000000000000

isn't a valid constant expression in C. It is neither an arithmetic constant expression which only allows integer constants, floating constants, enumeration constants, character constants, and sizeof expressions as operands; nor an address constant which doesn't allow casts to integer types.

That said, I'd expect Visual Studio to generate "error C2099: initializer is not a constant" like it does with | 0x8000000000000000.

I'm not sure about C++, though.

Answer 2

None of the initializers used in

uint64_t a[] = { (uint64_t)&i, (uint64_t)&i + 0x8000000000000000 };

are eligible constant expressions. The pedantic definition of constant expression in C does not allow casting pointer values to integer types, even if the pointer values satisfies requirements for address constant. Which means that formally (uint64_t)&i is already illegal in this context.

However, this compiler apparently accepts (uint64_t)&i in this context as an extension.

After that the fact that it complains when + is replaced with | operator is probably rooted directly in the language specification

6.6 Constant expressions

7 More latitude is permitted for constant expressions in initializers. Such a constant expression shall be, or evaluate to, one of the following:

— an arithmetic constant expression,

— a null pointer constant,

— an address constant, or

— an address constant for an object type plus or minus an integer constant expression.

Again, this is not an exact match, since the above wording allows adding fixed offset to address constants only, but for a compiler that accepts (uint64_t)&i as a constant expression in this context it wouldn't be unusual to continue to apply the "plus or minus" restriction. The ability to add something to (or subtract something from) an address constant in C is defined by the capabilities of loaders that perform address relocation at load time. Loaders can add or subtract, but they cannot perform bitwise operations on addresses.

And, finally, the fact that it has no effect at run time is apparently caused by the limitations of the loader, which is responsible for implementing C-style initialization of statics at startup time.