I'm trying to iron out some of the strict-aliasing warnings that come
up when building the code under Python 3. (Strict aliasing is a C rule
against using the same pointer as two different types, which, when
followed, gives the optimizer a huge advantage. This didn't come up
under Python 2, because Python 2 code couldn't be built with strict
aliasing on, so it becomes an issue in Python 3 code where strict
aliasing is on by default.)
I came across this strange function in Quant.c:
static void
rehash_collide(HashTable h,
void **keyp,
void **valp,
void *newkey,
void *newval)
{
*valp=(void *)((*(int *)valp)+(*(int *)&newval));
}
This function sets off red flags in my brain. It's essentially casting
two void pointers to ints to add them and then cast them back.
Now, the strict-aliasing-safe version is not hard to write:
static void
rehash_collide(HashTable h,
void **keyp,
void **valp,
void *newkey,
void *newval)
{
union {
void *ptr;
int val;
} uresult, uvalp = { *valp }, unewval = { newval };
uresult.val = uvalp.val + unewval.val;
*valp = uresult.ptr;
}
...but the fact that it equates the sizes of ints and void pointers
worries me. Is there a good reason this function isn't written:
static void
rehash_collide(HashTable h,
void **keyp,
void **valp,
void *newkey,
void *newval)
{
*valp=(void *)(((size_t) *valp) + ((size_t) newval));
}
...?
--Brian
_______________________________________________
Image-SIG maillist - Image-SIG@python.org
http://mail.python.org/mailman/listinfo/image-sig
