Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How to set structure element at desired offset

In embedded programming when describing the hardware one often needs to place struct elements at known predefined positions as the HW engineer designed them. For example, let's define a structure FPGA, which has some 100 registers/areas as in the following simplified example:

struct __attribute__ ((__packed__)) sFPGA {
    uchar   Spare1[0x24];
    ushort  DiscreteInput;
    uchar   Spare2[0x7A];
//CPLD_Version is required to be at offset 0xA0, so 0xA0-0x24-2=0x7A
    ushort  CPLD_Version;
};

Now, I am frustrated and angry of manual calculations and possible errors in the case of a change in the structure. Is there any way to do this more robust/convenient? I tried to write it this way:

uchar   Spare2[0xA0 - offsetof(sFPGA, Spare2)];

but this does not compile complaining about incomplete struct... Note, that my example is simplified. In reality there are some 20-30 such spare fields that must be defined - the structure is very big.

like image 570
leonp Avatar asked Aug 14 '16 12:08

leonp


People also ask

How do you find the offset of a structure?

Use offsetof() to find the offset from the start of z or from the start of x . #include <stddef. h> size_t offsetof(type, member); offsetof() returns the offset of the field member from the start of the structure type.

What is offset in structure?

The C library macro offsetof(type, member-designator) results in a constant integer of type size_t which is the offset in bytes of a structure member from the beginning of the structure. The member is given by member-designator, and the name of the structure is given in type.


2 Answers

Well, this won't win the miss Universe award, but I think it does what you want:

#include <boost/preprocessor/cat.hpp>
typedef unsigned char uchar;
typedef unsigned short ushort;
#define PAD_FIELDS(i_,f_, n_) \
    typedef struct __attribute__((packed)) {f_}             ftype##i_; \
    typedef struct __attribute__((packed)) {f_ uchar t_;}   ttype##i_; \
    f_ uchar BOOST_PP_CAT(padding,i_)[n_ - sizeof (BOOST_PP_CAT(ftype,i_)) * (sizeof (BOOST_PP_CAT(ftype,i_)) != sizeof (BOOST_PP_CAT(ttype,i_)))];

struct sFPGA {
    PAD_FIELDS(1,
    PAD_FIELDS(2,
    uchar   Spare1[0x24];
    ushort  DiscreteInput;
    //CPLD_Version is required to be at offset 0xA0
    , 0xA0)        // First padding
    ushort  CPLD_Version;
    uchar   more_stuff[0x50];
    ushort  even_more[4];
    //NID_Version is required to be at offset 0x10A2
    , 0x10A2)      // Second padding
    ushort  NID_Version;
} __attribute__((packed));

int main() {
    printf("CPLD_Version offset %x\n", offsetof(sFPGA,CPLD_Version));
    printf("NID_Version offset %x\n", offsetof(sFPGA,NID_Version));
}

Let's say you want N=20 padding fields. You have to add N of those PAD_FIELDS(i, in the beginning of your structure, where i runs for example from 1 to 20 (as in my example) or from 0 to 19 or whatever makes you happy. Then, when you need the padding you add for example , 0x80) which means that the next field will be positioned at offset 0x80 from the beginning of the structure.

Upon running this code, it outputs the following text:

CPLD_Version offset a0
NID_Version offset 10a2

The way this macro works is it defines a structure with your fields, it then incorporates your fields, and adds the padding computed according to the structure.

If you don't mind some boost::preprocessor magic, here's a way you can automate the whole PAD_FIELDS(1,PAD_FIELDS(2,PAD_FIELDS(3,PAD_FIELDS(4,... in the beginning:

#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/comma.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/punctuation/paren.hpp>
typedef unsigned char uchar;
typedef unsigned short ushort;
#define PAD_FIELDS(i_,f_, n_) \
    typedef struct __attribute__((packed)) {f_}             BOOST_PP_CAT(ftype,i_); \
    typedef struct __attribute__((packed)) {f_ uchar t_;}   BOOST_PP_CAT(ttype,i_); \
    f_ uchar BOOST_PP_CAT(padding,i_)[n_ - sizeof (BOOST_PP_CAT(ftype,i_)) * (sizeof (BOOST_PP_CAT(ftype,i_)) != sizeof (BOOST_PP_CAT(ttype,i_)))];
#define PADMAC(z,n,s) PAD_FIELDS BOOST_PP_LPAREN() n BOOST_PP_COMMA()
#define PADREP(n) BOOST_PP_REPEAT(n, PADMAC, junk)
#define FORCE_EVAL(...) __VA_ARGS__
#define CONTAINS_PADDING(n) FORCE_EVAL(PADREP(n)
#define SET_OFFSET(o) BOOST_PP_COMMA() o BOOST_PP_RPAREN()

struct sFPGA {
    CONTAINS_PADDING(2);
    uchar   Spare1[0x24];
    ushort  DiscreteInput;
    //CPLD_Version is required to be at offset 0xA0
    SET_OFFSET(0xA0);
    ushort  CPLD_Version;
    uchar   more_stuff[0x50];
    ushort  even_more[4];
    //NID_Version is required to be at offset 0x10A2
    SET_OFFSET(0x10A2);
    ushort  NID_Version;
    )
} __attribute__((packed));

Notice what changed in the usage:

  1. In the beginning of the structure you write CONTAINS_PADDING(n) where n is the number of padding elements desired.
  2. Right before the end of the structure you have to add a ")".
  3. Instead of ,0x0A) to specify the padding you have to write SET_OFFSET(0x0A); (the ; is optional).
like image 92
Slava P Avatar answered Oct 21 '22 10:10

Slava P


The language simply doesn't allow you to force particular padding. Even if you add your own padding, the compiler has no idea that's what you're trying to do. It could easily add its own additional padding to align members the way it wants.

Of course, for a particular CPU, OS, and compiler, you might just get lucky in that the padding you add manually might just work out to be the padding you want --- you'd have to write a test program to verify that the offsets of the members are what you think they are.

If you absolutely must access data at specific offsets, you can either try the non-standard __attribute__(packed) gcc extension (but see this); or write custom I/O routes to de/serialize the data from the form it's in into/out-of a struct for easier access at the C programming level.

like image 27
Paul J. Lucas Avatar answered Oct 21 '22 09:10

Paul J. Lucas