redundant bytes in union typedef

Question

I am using the following structures for formatting the data of CAN-messages. messageData.ptr is used for further processing. The section part ist used for better access. The problem is that whyever there are two more bytes between messageData.srcSpecifier and messageData.data

typedef union _MessagePureData_TypeDef
{
    signed int S32[1];
    unsigned int U32[1];
    unsigned short U16[2];
    signed short S16[2];
    unsigned char U8[4];
} messagePureData;

typedef union _MessageData_TypeDef
{
    unsigned char ptr[6];
    struct
    {
        unsigned char srcDevice;
        unsigned char srcSpecifier;
        messagePureData data;
    } section;
} messageData; 

example:

messageData.section.srcDevice = 0xAA;
messageData.section.srcSpecifier = 0xBB;
messageData.section.data.U32  = 0x11223344;

results that messageData.ptr contains: [0xAA, 0xBB, 0x01, 0x17, 0x44, 0x33]

so from where is 0x01 and 0x17 ??

Answer 1

Alignment.
A messagePureData is always aligned for an int, which is perhaps 4 bytes large. That means that section is most certainly aligned for 8 bytes, putting two padding bytes between srcSpecifier and data (so a whole struct object has an alignment of 8 and data one of 4). On the other hand, ptr as an array is continuous, so it covers the same storage as the two padding bytes.

| ptr         | ptr + 1      | ptr + 2 | ptr + 3 | ptr + 4   | ptr + 5   |
|             |              |         |         |           |             
| srcDevice   | srcSpecifier | padding | padding | &data     | &data + 1 |   ... 

^                            ^                   ^
| Address is multiple of 8   |                   | Address is multiple of 4
                             |                   
                             | 
                             | Address is a multiple of two;
                             | Unfeasible address for data.

You can pack the struct to circumvent this.

Answer 2

Since the union contains int members, it has the same alignment requirement as int. Padding is added before data member of the structure, if necessary, to provide that alignment.

On your platform, it appears that that requirement is four bytes. The two members before it each take one byte, so two more are required to make its offset a multiple of four. These are not initialised to any particular value, so you see arbitrary values if you look at them.

Answer 3

The size of the messagePureData data field is 32 bits.

The compiler therefore aligns it to a 32-bit address, by adding 2 bytes (a.k.a. padding).

You can use #pragma pack in order to prevent the compiler from applying this re-alignment.

But bare in mind that the assembly code for accessing this field might be slightly less efficient.