Swapping 2 function pointers without a temporary variable

Question

Swapping two void pointers is easy without using any extra memory:

void* p1;
void* p2;

//...

p1 = ((uintptr_t)p1) ^ ((uintptr_t)p2);
p2 = ((uintptr_t)p1) ^ ((uintptr_t)p2);
p1 = ((uintptr_t)p1) ^ ((uintptr_t)p2);

But to swap function pointers must I use another pointer? (as they are not guaranteed to fit into any integer type).

void (*p1)();
void (*p2)();

//...

void (*tmp)() = p1;
p1 = p2;
p2 = tmp;

Can anyone give me an example of a fully portable method that will swap function pointers without using a temporary variable?

Answer 1

I think this works, because aliasing through (unsigned) char is allowed:

void (*p1)();
void (*p2)();

for (size_t i = 0; i < sizeof(p1); ++i) {
    ((unsigned char *)&p1)[i] ^= ((unsigned char *)&p2)[i]
}
for (size_t i = 0; i < sizeof(p2); ++i) {
    ((unsigned char *)&p2)[i] ^= ((unsigned char *)&p1)[i]
}
for (size_t i = 0; i < sizeof(p1); ++i) {
    ((unsigned char *)&p1)[i] ^= ((unsigned char *)&p2)[i]
}

Answer 2

Use the xor swap algoritm:

*p1 = *p1 ^ *p2;
*p2 = *p1 ^ *p2;
*p1 = *p1 ^ *p2;

Answer 3

I'd rather write it like this (see below, however):

uintptr_t up1 = (uintptr_t)p1;
uintptr_t up2 = (uintptr_t)p2;

p1 ^= p2;
p2 ^= p1;
p1 ^= p2;

On most architectures which have sizeof(uintptr_t) <= register size, this is three instruction == 3 clocks, likely as much as the other version (unless the casts cost extra). However, I would prefer the temp-variant for most architectures.

Warning: it is not safe: While 6.3.2.3p1 states "void * can be converted safely between a pointer to any object type" and 7.20.1.4p1 states "unitptr_t can hold a void *", 3.15 restricts the term object to the data storage only. Functions reside in code storage. (Thanks to the comments)

So, do not apply this to function pointers!

Note, this is less obvious anyways than the temp-version and a compiler might very well use this code if it detects the temp-version's pattern.