问题
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.
回答1:
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:
- In the beginning of the structure you write
CONTAINS_PADDING(n)wherenis the number of padding elements desired. - Right before the end of the structure you have to add a ")".
- Instead of
,0x0A)to specify the padding you have to writeSET_OFFSET(0x0A);(the;is optional).
回答2:
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.
回答3:
What about this:
struct sFPGA {
struct Internal_S {
uchar Spare1[0x24];
ushort DiscreteInput;
} s;
uchar Spare2[0xA0 - sizeof (struct Internal_S)];
ushort CPLD_Version;
};
回答4:
Check out this disgusting solution I came up which I think is actually a little cleaner than everything else posted. For my requirements I just needed a handful of registers out of thousands for a device, so I don't have to solve different sized fields in the struct..
#define M(off, name) struct { uint32_t _##name[off]; uint32_t name; };
struct s {
union {
M(0, a)
M(4, b)
};
} __packed;
int main(void)
{
struct s s1;
s1.a = 12;
s1.b = 42;
printf("%u a=%lx\n", s1.a, offsetof(struct s, a));
printf("%u b=%lx\n", s1.b, offsetof(struct s, b));
printf("so=%u\n", sizeof(s1));
return 0;
}
来源：https://stackoverflow.com/questions/38942125/how-to-set-structure-element-at-desired-offset