GCC -O3: Why does a 32-bit write to a uint64_t appear to be ignored?

Question

I expected this to print 11112222deadbeef (it does at -O0), but at -O3 it prints 1111222233334444.

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

__attribute__((noinline))
void MyFun(void *p)
{ 
    *(uint32_t*)p = 0xDEADBEEF;
}

int main(void){
    uint64_t x = 0x1111222233334444ULL;
    MyFun(&x);
    printf("%016llx\n", (unsigned long long)x);
}

Searching found a compiler option -fno-strict-aliasing which basically states:

With -fno-strict-aliasing, you are advising the compiler that you might have written some incorrect code, and to please be defensive with the optimizations it performs regarding aliasing.

Applying that option -O3 -fno-strict-aliasing does output the expected result 11112222deadbeef. Example

What's the correct, portable way to write 0xDEADBEEF into the low-addressed 4 bytes of a uint64_t so it does not get optimized away or is it safe to add -fno-strict-aliasing as a temporary stop-gap?

You are in the zone of undefined behavior. The keywords: strict aliasing rule. — 3CEZVQ
– 3CEZVQ, Commented Oct 11 at 14:47
"I expected this to print ..." - it's problematic to expect anything when UB is invoked. — wohlstad
– wohlstad, Commented Oct 11 at 14:56
Tip: Instead of printf( "%016llx\n", ( unsigned long long )x ), you can use printf( "%016" PRIx64 "\n", x );. No casting. You need to include inttypes.h, but you can omit stdint.h if you do. — ikegami
– ikegami, Commented Oct 11 at 15:37
@vengy "only the low 32 bits" --> do you want the lowest significant bits or the lowest addressed bytes? — chux
– chux, Commented Oct 11 at 16:55

chqrlie · Accepted Answer · 2025-10-13 09:55:24Z

9

The correct way to handle this kind of aliasing situation is to use memcpy:

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

void MyFun(void *p) {
    uint32_t val = 0xDEADBEEF;
    memcpy(p, &val, sizeof(val));
}

int main(void) {
    uint64_t x = 0x1111222233334444ULL;
    MyFun(&x);
    printf("%016" PRIu64 "\n", x);
}

Compilers generate optimal code for this unless optimisations are disabled, as can be verified with Godbolt's Compiler Explorer

edited Oct 13 at 9:55

answered Oct 11 at 15:08

chqrlie

152k12 gold badges145 silver badges231 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Toby Speight Oct 13 at 10:19

PRIx64 would be more revealing, and consistent with the question.

Peter - Reinstate Monica Oct 13 at 16:25

That is interesting. Per draft n3220, 6.5.1/7, an object can be accessed through an lvalue expression of a compatible type or of character type; but memcpy is declared with void* parameters. We must assume that its implementation copies to the destination through a char pointer, but that may factually not be the case at all (for example, it may be intrinsic machine code). (Of course this is exactly what memcpy is meant for, and before we had void, it was taking char* parameters, being in string.h. But still. I cannot see an exception for memcpy in the draft.)

Eric Postpischil Oct 13 at 19:03

C 2024 7.26.1 (about <string.h>) says “For all functions in this subclause, each character shall be interpreted as if it had the type unsigned char (and therefore every possible object representation is valid and has a different value)” and 7.26.2.1 (about memcpy) says “The memcpy function copies n characters from the object pointed to by s2 into the object pointed to by s1.” The wording could be better, but it is clear memcpy is intended to be able to copy bytes in arbitrary objects as if character lvalues were used, which is permitted for aliasing.

Collectives™ on Stack Overflow

GCC -O3: Why does a 32-bit write to a uint64_t appear to be ignored?

1 Answer 1

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related