Thread: pointer to pointer to void - dereferencing type-punned pointer, strict-aliasing rule

Code:

int
dequeue_shared_queue(struct shared_queue *q, void **elem)
{
   pthread_mutex_lock(&(q->access));
  *elem = fifoQueueDequeue(q->queue);
  pthread_mutex_unlock(&(q->access));
}

struct packet *
dequeue_packet(struct channel *chnl)
{
  int ret;
  struct packet *p = NULL;
//  void *p = NULL;
    
  ret = dequeue_shared_queue(chnl->packet_queue, (void **)&p);
  ...
  return p;
}

I use gcc 3.4.4 on Solaris 9 and I got a warning: "dereferencing type-punned pointer will break strict-aliasing rules". By declaring p as "void *" rather than "struct packet *", the warning disappears amd there is no other warning.
I googled "dereferencing type-punned pointer will break strict-aliasing rules" and based on the search results I read, it appears that gcc issues the warning because the compiler does not like the fact that the same 'memory location' is accessed by both a void * and a struct packet *, correct me if i am wrong. (Well, I am not eaxctly sure what the 'memory location' is at issue here.)
There was an old post http://cboard.cprogramming.com/showthread.php?t=91958 that mentions a function that, like dequeue_shared_queue() above, also has a parameter of the type void **. And the poster also passes a '(void **)&data' to it. So I guess it is okay (or even common) to have a void ** as a parameter. But that post does not mention any compiler warning like mine.
Now, my questions are:
1. Would the code in that old post also generate a similar warning? If not, why not?
2. If I do the following, then there is no warning:

Code:

struct packet *
dequeue_packet(struct receiving_channel *chnl)
{
  int ret;
  struct packet *q = NULL;
  void *p = NULL;
    
  ret = dequeue_shared_queue(chnl->packet_queue, (void **)&p);
  q = p;
  ...
  return q;
}

Why?
Could someone kindly explain all these void ** and casting business to me (preferably, in relation to the "strict aliaing rules")? Other than introducing an additional void pointer like in the last piece of code above, is there any way to eliminate the warning?

There is an implicit assumption in the first version of your code that all pointers are represented in the same way.

> *elem = fifoQueueDequeue(q->queue);
If a void* pointer were larger than a struct packet * pointer say, then this assignment would end up trashing some memory. Even if it fits, there's no guarantee of equal representation.

Given int a, b;
It's analogous to doing memcpy(&b, &a, sizeof a) rather than b = a;
Now imagine that b is a short rather than an int. You'd expect assignment to do the right thing, but the memcpy() approach is broken.

Remember that void* (and only void*) is special in that it is a kind of union of all possible pointer types (to permit the void* to anytype* and back again assignments).

A void** pointer behaves like every other kind of pointer. The fact that you needed to use a void** cast should be alerting you to the possibility of trouble.

> is there any way to eliminate the warning?
Either make it type-correct as brewbuck suggests, or use the extra assignment route you proposed.

> Don't all pointers have the same size?
The C standard doesn't say that they should, doesn't rely on them being the same, and some real machines have had different pointer sizes.
http://www.c-faq.com/null/machexamp.html

I guess you need to use your 2nd example then, the one with the extra assignment.