将任意结构存储的 void* 引用传递给函数

Question

I have a cli program that is used for talking to FPGA registers and memory. Depending on the command, you may return a 32 bit registers (which may consist of multiple fields) or it could be as large at 128 Bytes. So what I wanted to do, was malloc 128 bytes globally to hold a returned structure, or hold a structure in preparation for it to be written to the FPGA. (see void *entry_top.

In the example below, I have a singular Get command that fails with a segmentation fault when attempting to print the value of a field obtained. In GDB, I can see that the address of entry_top does not seem to actually seem to be passed by reference into the io_get_entry function which was the intent.

I tried to make things a bit simpler by just assigning a test value 0x12345678 to entry using a cast of (host_global_size_entry_t*). In this test program, at the main level, I believed I should have been able to cast the void * to (host_global_size_entry_t *) and read the set value correctly in entry_top.

Not 100% certain, but the issue seems to be that my memory reference is being passed incorrectly with the usage of &entry_top.

Can anyone comment as to what I have done wrong relative to passing the void* entry_top reference to multiple levels of functions?

using namespace std;

#include "stdint.h"
#include <stdlib.h>
#include <list>
#include <string.h>
#include <string>
#include <iostream>


#ifndef __KRISTEN_TYPES_H__
#define __KRISTEN_TYPES_H__
#include <stdint.h>

#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#ifdef PACKED
#undef PACKED
#endif /* PACKED */
#define PACKED __attribute__ ((packed))
#ifdef ALIGNED
#undef ALIGNED
#endif /* ALIGNED */
#define ALIGNED __attribute__ ((aligned (4)))
#ifdef __cplusplus
}
#endif /* __cplusplus */


typedef enum _return_t  
{                
    /* Common codes */  
    func_ok = 0,        
    func_failed,        
    func_invalid,       
    func_not_done       
} return_t;              

#endif // __KRISTEN_TYPES_H__


 uint32_t host_global_size_offset[1] = {53300};


 void *entry_top = malloc(32*sizeof(uint32_t));
 uint32_t *field_size = (uint32_t*)malloc(sizeof(uint32_t));
 uint32_t* result=(uint32_t*)malloc(64*sizeof(uint32_t));

struct _host_global_size_entry_t {
   union {
      struct {
         uint32_t global_size_field        : 32 ; // A generic bit field for this register.
      } PACKED; 
      uint8_t entry[5];
   } PACKED;
   uint8_t alignment_correction[3];
} PACKED;
typedef struct _host_global_size_entry_t __attribute__ ((aligned (4))) host_global_size_entry_t;


return_t io_get_entry(uint32_t index, void *entry, uint32_t base, uint8_t  length) {
   uint32_t local_addr = base + (index * length);
   ((host_global_size_entry_t*) entry)->global_size_field = 0x12345678;  // Assign a value that we can see in Main'
   // The next line shows that the value was 0x12345678 succesfully
   printf("io_get_entry local_addr = %d, length = %d, entry->global_sizefield = 0x%X\n", local_addr, length, ((host_global_size_entry_t*) entry)->global_size_field);
   return func_ok;
}


return_t host_global_size_read_entry(uint32_t index, void *entry, uint8_t instance) {
   return_t result;
   uint32_t base;
   uint8_t  length;
   base = host_global_size_offset[instance];
   length = sizeof(host_global_size_entry_t);
   result = io_get_entry(index, &entry, base, length);
   // The next printf causes a segmentation fault.  GDB says that &entry here is not the same as &entry in io_get_entry 
   printf("host_global_size_read_entry = 0x%X\n", ((host_global_size_entry_t*)entry)->global_size_field);

   return result;
}

return_t host_global_size_read_field(char *field, uint32_t *field_size, void *result, void *entry) {
//host_global_size_entry_t *entry;
   uint32_t field_s = 0;
   if (strcmp("global_size_field", field) == 0) {
      field_s = 4;
      *(uint32_t *)result = ((host_global_size_entry_t*)entry)->global_size_field; 
   } else   if (field_size != NULL) *field_size = field_s;
      *field_size = field_s;
   return func_ok;
}



int main (void) {
  uint8_t instance = 0;
  uint32_t index = 0;
  // Pass the address of entry_top global
  host_global_size_read_entry(index, &entry_top, instance); // Read entry.
  // Cast the result to the structure we expect to be comming back.  
  printf("main: entry_top->global_sizefield = 0x%X\n", ((host_global_size_entry_t*) entry_top)->global_size_field);
  return 0;
}

Answer 1

Both in main and host_global_size_read_entry you take the address of entry_top (resp. entry ) This is a void ** , but C++ will silently convert it to a void * without complaint.

Instead, you should pass entry_top by value, so that host_global_size_read_entry and io_get_entry receive the contents of entry_top , ie the pointer to allocated memory.