What is the strict aliasing rule?
When asking about common undefined behavior in C, souls more enlightened than I referred to the strict aliasing rule. What are they talking about? ...
strict-aliasing
When is char* safe for strict pointer aliasing?
I've been trying to understand the strict aliasing rules as they apply to the char pointer. Here this is stated: It is always presumed that a char* may refer to an alias of any object. Ok so in the context of socket code, I can do this: struct SocketMsg { int a; int b; }; int main() { ... SocketMsg msgToSend; msgT...
Message-dispatch system in C that doesn't break strict aliasing and alignment
I'm writing an embedded control system in C that consists of multiple tasks that send messages to each other (a fairly common idiom, I believe!), but I'm having a hard time designing a mechanism which: is neat is generic is relatively efficient most importantly: is platform independent (specifically, doesn't violate strict-aliasing or ...
How to cast sockaddr_storage and avoid breaking strict-aliasing rules
I'm using Beej's Guide to Networking and came across an aliasing issue. He proposes a function to return either the IPv4 or IPv6 address of a particular struct: 1 void *get_in_addr( struct sockaddr *sa ) 2 { 3 if (sa->sa_family == AF_INET) 4 return &(((struct sockaddr_in*)sa)->sin_addr); 5 else 6 return &(((st...
Using (void*) as a type of an identifier
In my program, I have objects (of the same class) that must all have a unique identifier. For simplicity and performance, I chose to use the address of the object as identifier. And to keep the types simple, I use (void*) as a type for this identifier. In the end I have code like this: class MyClass { public: typedef void* identity_t;...
Does moving values of one type with another type violate strict aliasing?
Does it violate strict aliasing rules to move items of any type around using uint32_t, then read them back? If so, does it also violate strict aliasing rules to memcpy from an array of uint32_ts to an array of any type, then read the elements back? The following code sample demonstrates both cases: #include <assert.h> #include <stdio....
Trying to understand a GCC error
I have the following bit of code: #include <iostream> #include <list> #include <algorithm> #include <iterator> template<typename Iterator> void foo(Iterator begin, Iterator end) { typedef typename std::iterator_traits<Iterator>::value_type type; type smallest = (*std::min_element(begin,end)); std::cout << smallest << std::endl...
C99 strict aliasing rules in C++ (GCC)
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 ...
gcc, strict-aliasing, and casting through a union
Do you have any horror stories to tell? The GCC Manual recently added a warning regarding -fstrict-aliasing and casting a pointer through a union: [...] Taking the address, casting the resulting pointer and dereferencing the result has undefined behavior [emphasis added], even if the cast uses a union type, e.g.: union a_union...
gcc, strict-aliasing, and horror stories
In http://stackoverflow.com/questions/2906365/gcc-strict-aliasing-and-casting-through-a-union I asked whether anyone had encountered problems with union punning through pointers. So far, the answer seems to be No. This question is broader: do you have any horror stories about gcc and strict-aliasing? Background: Quoting from AndreyT's...
Strict pointer aliasing: any solution for a specific problem?
I have a problem caused by breaking strict pointer aliasing rule. I have a type T that comes from a template and some integral type Int of the same size (as with sizeof). My code essentially does the following: T x = some_other_t; if (*reinterpret_cast <Int*> (&x) == 0) ... Because T is some arbitary (other than the size restricti...
Strict pointer aliasing: is access through a 'volatile' pointer/reference a solution?
On the heels of a specific problem, a self-answer and comments to it, I'd like to understand if it is a proper solution, workaround/hack or just plain wrong. Specifically, I rewrote code: T x = ...; if (*reinterpret_cast <int*> (&x) == 0) ... As: T x = ...; if (*reinterpret_cast <volatile int*> (&x) == 0) ... with a volatile q...
boost::bind breaks strict-aliasing rules?
Using Boost 1.43 and GCC 4.4.3, the following code boost::bind(&SomeObject::memberFunc, this, _1)); Generates the following warning boost/function/function_base.hpp:321: warning: dereferencing type-punned pointer will break strict-aliasing rules What's the correct way to eliminate these warnings without setting -fno-strict...
Dereferencing type-punned pointer will break strict-aliasing rules
Hi there, I used the following piece of code to read data from files as part of a larger program. double data_read(FILE *stream,int code) { char data[8]; switch(code) { case 0x08: return (unsigned char)fgetc(stream); case 0x09: return (signed char)fgetc(stream); case 0x0b:...
C aliasing rules and memcpy
While answering another question, I thought of the following example: void *p; unsigned x = 17; assert(sizeof(void*) >= sizeof(unsigned)); *(unsigned*)&p = 17; // (1) memcpy(&p, &x, sizeof(x)); // (2) Line 1 breaks aliasing rules. Line 2, however, is OK wrt. aliasing rules. The question is: why? Does the compiler have special...
A cast that is breaking strict-aliasing rules
I have a function that takes a unsigned long* and needs to pass it to a external library that takes a unsigned int* and on this platform unsigned int/long are the same size. void UpdateVar(unsigned long* var) { // this function will change the value at the address of var ExternalLibAtomicUpdateVar((unsigned int*)var); // lib atomi...
Is unsigned char a[4][5]; a[1][7]; undefined behavior?
One of the examples of undefined behavior from the C standard reads (J.2): — An array subscript is out of range, even if an object is apparently accessible with the given subscript (as in the lvalue expression a[1][7] given the declaration int a[4][5]) (6.5.6) If the declaration is changed from int a[4][5] to unsigned char a[4]...
Why are no strict-aliasing warnings generated for this code?
I have the following code: struct A { short b; }; struct B { double a; }; void foo (struct B* src) { struct B* b = src; struct A* a = (struct A*)src; b->a = sin(rand()); if(a->b == rand()) { printf("Where are you strict aliasing warnings?\n"); } } I'm compiling the code with the following c...