strict-aliasing

While learning c I have implemented my own memcpy functions. I have used a wider type( uint32_t ) in the function. (For simplicity the function is restricted to types that are multiples of 4 and the data is properly aligned ) void memcpy4( void* dst , void* src , int size ) { size /= 4; for ( int i = 0 ; i < size ; i++ ) ((uint32_t*)dst)[i] = ((uint32_t*)src)[i]; } I did some reading on type punning and strict aliasing and I believe the function above breaks the rule. The correct implementation would be this since you can use a char: void memcpy4( void* dst , void* src , int size ) { for ( int

My company uses a messaging server which gets a message into a const char* and then casts it to the message type. I've become concerned about this after asking this question . I'm not aware of any bad behavior in the messaging server. Is it possible that const variables do not incur aliasing problems? For example say that foo is defined in MessageServer in one of these ways: As a parameter: void MessageServer(const char* foo) Or as const variable at the top of MessageServer : const char* foo = PopMessage(); Now MessageServer is a huge function, but it never assigns anything to foo , however at

As far as I understand, GCC supports all of its C99 features in C++. But how is C99 strict aliasing handled in C++ code? I know that casting with C casts between unrelated types is not strict-aliasing-safe and may generate incorrect code, but what about C++? Since strict aliasing is not part of C++ standard (is that correct?), GCC must be specifying the semantics itself. I figure const_cast and static_cast cast between related types, hence they are safe, while reinterpret_cast can break strict aliasing rules. Is this a correct understanding? No, you are probably mixing different things. Strict

Just a couple weeks ago, I learned that the C++ Standard had a strict aliasing rule. Basically, I had asked a question about shifting bits -- rather than shifting each byte one at a time, to maximize performance I wanted to load my processor's native register's with (32 or 64 bits, respectively) and perform the shift of 4/8 bytes all in a single instruction. This is the code I wanted to avoid: unsigned char buffer[] = { 0xab, 0xcd, 0xef, 0x46 }; for (int i = 0; i < 3; ++i) { buffer[i] <<= 4; buffer[i] |= (buffer[i + 1] >> 4); } buffer[3] <<= 4; And instead, I wanted to use something like:

I have a problem understanding what can and cannot be done using unions with GCC. I read the questions (in particular here and here ) about it but they focus the C++ standard, I feel there's a mismatch between the C++ standard and the practice (the commonly used compilers). In particular, I recently found confusing informations in the GCC online doc while reading about the compilation flag -fstrict-aliasing . It says: -fstrict-aliasing Allow the compiler to assume the strictest aliasing rules applicable to the language being compiled. For C (and C++), this activates optimizations based on the

Strict aliasing prevents us from accessing the same memory location using an incompatible type. int* i = malloc( sizeof( int ) ) ; //assuming sizeof( int ) >= sizeof( float ) *i = 123 ; float* f = ( float* )i ; *f = 3.14f ; this would be illegal according to C standard, because the compiler "knows" that int cannot accessed by a float lvalue. What if I use that pointer to point to correct memory, like this: int* i = malloc( sizeof( int ) + sizeof( float ) + MAX_PAD ) ; *i = 456 ; First I allocate memory for int , float and the last part is memory which will allow float to be stored on aligned