function address cast to char array - c

Question

For my educational purposes I was wondering if there is an alternative way with memcpy() to the following code for the function address casting to an array of chars?
#include <stdio.h>
#include <string.h>
typedef void (*_vfp)(void);
#define FPSZ sizeof(_vfp)
union rcast {
_vfp fp;
char fp_c[FPSZ];
} rc;
void a(void){
printf("a()\n");
}
int main(int argc, char **argv)
{
int i=0;
memset(&rc,0,FPSZ);
rc.fp=a;
for (i=0;i<FPSZ;++i)
printf("%hhx ",rc.fp_c[FPSZ-i-1]);
puts("");
printf("%p\n",a);
return 0;
}
Thanks.

Answer 1

Minimally modifying your code:
#include <stdio.h>
#include <string.h>
typedef void (*_vfp)(void);
#define FPSZ sizeof(_vfp)
void a(void){
printf("a()\n");
}
int main(int argc, char **argv)
{
int i=0;
_vfp fp = a;
char fp_c[FPSZ];
memcpy(fp_c, &fp, FPSZ);
for (i=0;i<FPSZ;++i)
printf("%hhx ",fp_c[FPSZ-i-1]);
puts("");
printf("%p\n",a);
return 0;
}
EDIT: In response to comment, here's a version without a proxy and without memcpy
#include <stdio.h>
#include <stdint.h>
#include <limits.h>
#include <string.h>
typedef void (*_vfp)(void);
#define FPSZ sizeof(_vfp)
void a(void){
printf("a()\n");
}
int main(int argc, char **argv)
{
int i=0;
char fp_c[FPSZ];
for (i=0;i<FPSZ;++i)
fp_c[i] = (char) (((uintptr_t) &a) >> CHAR_BIT * i);
for (i=0;i<FPSZ;++i)
printf("%hhx ",fp_c[FPSZ-i-1]);
puts("");
printf("%p\n",a);
return 0;
}

Answer 2

For my educational purposes I was wondering if there is an alternative way with memcpy() to the following code for the function address casting to an array of chars?
Note well: though arrays and pointers are closely associated, they are very different things. Among many other differences, you can use pointer types in cast operators, and pointers as cast operands, but you cannot use array types or arrays in those contexts.
You seem to say that what you want is a char array containing the bytes of the function pointer's value (as opposed to the bytes of whatever the pointer points to). You can get that, or something like it, several ways. The simplest way is to create a char * to the pointer's value. Again, that's not an array, but it can be used in many of the same ways that an array could be used:
typedef void (*_vfp)(void);
int main(int argc, char **argv)
{
int i;
_vfp fp = a;
char *cp = &fp;
for (i = 0; i < sizeof(fp); ++i) {
printf("%hhx ", cp[i]);
}
printf("\n%p\n", (void *) a);
return 0;
}
Do note, however, that the above code exhibits undefined behavior. The %p field descriptor tells printf() that the corresponding argument is an object pointer. C draws a distinction between object pointers and function pointers, and does not define any behavior for converting between values of those two type families. I include a cast explicitly expressing such a conversion (which may enable the compiler to notice and complain); your code results in such a conversion being performed implicitly.
If you want a separate array object containing the bytes of the pointer's value (as opposed to the pointed-to function's), then you can get it in a similar way:
int main(int argc, char **argv)
{
_vfp fp = a;
char array[sizeof(fp)];
memcpy(array, &fp, sizeof(array));
/* ... */
}
That one uses memcpy(), exactly as you asked.
In any event, there is no need for a union. In fact, although your union-based approach might happen to work with your C implementation, reading from a different union member than was most recently written to formally exhibits undefined behavior.

Answer 3

What you are doing is formally Undefined Behaviour. C language says that an union can contain any of different variables, but you shall only access the variable that was set in the union : The size of a union is sufficient to contain the largest of its members. The value of at
most one of the members can be stored in a union object at any time. (ref : C Language Specification Draft - 6.7.2.1 Structure and union specifiers - 16)
So it is neither best nor worse than doing pointer casting via void :
intptr_t ip = (intptr_t) &a;
char *fp_c = (void *) &intptr_t;
or with memcpy :
char fp_c[FPSZ];
intptr_t ip = (intptr_t) &a;
memcpy(fp_c, &ip, sizeof(intptr_t));
All will give you same result in :
for (i=0; i<FPSZ; i++) {
printf("%hhx ",fp_c[FPSZ-i-1]);
}
fputs("\n");