如何设置所需偏移量的结构元素

Question

在嵌入式编程中，当描述硬件时，通常需要将结构元素放置在硬件工程师设计它们时已知的预定义位置。例如，让我们定义一个结构FPGA，它有大约100个寄存器/区域，如下面的简化示例所示:

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;
};

现在，我对人工计算和在结构变化的情况下可能出现的错误感到沮丧和愤怒。有什么方法可以做到这一点更强大/方便吗?我试着这样写:

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

，但这不会编译报怨不完整的结构…注意，我的例子是简化的。在现实中，大约有20-30个这样的备用字段必须定义-结构非常大。

Answer 1

好吧，这不会赢得环球小姐奖，但我认为它符合你的要求:

#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 %xn", offsetof(sFPGA,CPLD_Version));
    printf("NID_Version offset %xn", offsetof(sFPGA,NID_Version));
}

假设你想要N=20个填充字段。你必须在结构的开始添加N个PAD_FIELDS(i,，而i从1到20(在我的例子中)或从0到19或任何你喜欢的。然后，当你需要填充时，你添加例如, 0x80)，这意味着下一个字段将定位在偏移0x80从结构的开始。

在运行此代码时，它输出以下文本:

CPLD_Version offset a0
NID_Version offset 10a2

这个宏的工作方式是用你的字段定义一个结构，然后合并你的字段，并添加根据结构计算的填充。

如果你不介意一些boost::预处理器魔法，这里有一个方法可以让你在一开始就自动化整个PAD_FIELDS(1,PAD_FIELDS(2,PAD_FIELDS(3,PAD_FIELDS(4,...:

#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));

注意用法的变化:

1. 在结构的开始，你写CONTAINS_PADDING(n)，其中n是所需填充元素的数量。
2. 在结构结束之前，你必须添加一个")"。
3. 代替,0x0A)来指定填充，你必须写SET_OFFSET(0x0A); (;是可选的)。

Answer 2

该语言根本不允许您强制使用特定的填充。即使您添加了自己的填充，编译器也不知道您要做什么。它可以很容易地添加自己的额外的填充来按照它想要的方式对齐成员。

当然，对于特定的 CPU、操作系统和编译器，您可能只是运气好，因为您手动添加的填充可能恰好是您想要的填充——您必须编写一个测试程序来验证成员的偏移量是否与您认为的一致。

如果你绝对必须访问特定偏移量的数据，你可以尝试非标准的__attribute__(packed) gcc扩展(但请参阅此);或者编写自定义I/O路由，将数据从它的形式反序列化到/输出到struct，以便在C编程级别更容易访问。

Answer 3

这个呢:

struct sFPGA {
  struct Internal_S {
    uchar   Spare1[0x24];
    ushort  DiscreteInput;
  } s;
  uchar   Spare2[0xA0 - sizeof (struct Internal_S)];
  ushort  CPLD_Version;
};

Answer 4

看看我想出的这个恶心的解决方案，我认为它实际上比其他所有发布的都要干净一点。为了满足我的需求，我只需要一个设备的数千个寄存器中的几个寄存器，所以我不必解决结构中不同大小的字段。

 #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=%lxn", s1.a, offsetof(struct s, a));
        printf("%u b=%lxn", s1.b, offsetof(struct s, b));
        printf("so=%un", sizeof(s1));
        return 0;
}