C void *函数指针参数

Question

I'm trying to create a task queue in the ARM. The basic idea is the following.

typedef void (*funcpointer)(void *);     // the argument being passed will be a void pointer that I can hopefully typecast

struct sQueue{
   funcpointer       func_address;        // this stores the address of the function to be called
   void              *func_parameter;                   // this stores the address of the struct that is passed to the function
   uint32_t          TimeStamp;                  // the time at which the function should be called     
};

sQueue Func_List[10];

The plan is to be able to put the address of the function that should be called in Func_List[x].func_address.

I would like to be able to put the address of functions that accept pointers to different struct types in func_address. Here's an example:

void Config_ADC(sADC_Settings *pSettings);

void Enable_RX(sRX_Top_Settings *pSettings);

Both functions accept effectively a 32-bit pointer to a struct, but in these cases the structs are of different types.

When I try to assign Func_List[x].func_address = Config_ADC the compiler complains:

a value of type "void (*)(sADC_Settings *)" cannot be assigned to an entity of type "funcpointer"

Any ideas on how I can achieve this? I can of course change the function Config_ADC to accept a void* pointer and then typecast it inside the function, but I don't really want to do that.

Answer 1

IIRC it is UB to call a function through a function pointer with a different signature.

You will need a proxy function for each non matching function type.

void Config_ADC(sADC_Settings *pSettings);
void Config_ADC_proxy(void *pSettings){
  Config_ADC((sADC_Settings*) pSettings);
}

Answer 2

A solution is to cast the void pointer inside the function:

void Config_ADC(void *p)
{
    sADC_Settings *pSettings = (sADC_Settings *)p;

(Actually I don't like this because it unnecesarilly takes up another variable, however, I think it is already better than proxy functions that involve stack management and call management overhead. The compiler shouldn't bother when void * is involved; then there would be no overhead at all.)

Answer 3

Your particular ABI specification (specific to the target processor, the operating system, and perhaps even the compiler) dictates how C functions are called and with which calling conventions . Beware that some formal arguments may get passed thru some hardware registers.

I suggest to use typedef -s to define any signature of functions called thru pointers:

typedef void myroutofint_t(int);
typedef int  myintof2int_t (int, int);

If you are sure of the signature of the called function and if you can list all the signatures of functions called thru a pointer, you could use an unamed union (in C99 or C11):

struct sQueue{
 enum functiontype_en funtype;
 union {
   void* funaddress;
   myroutofint_t *funroutofint;
   myintof2int_t *funintof2int;
 };
 // othe fields of SQueue
 };

The C standard does not even require that function pointers and data pointers live in the same address space and have same size. But POSIX does, and we assume that.

BTW, you might need libffi .