Why is the size of packed struct 5 instead of 4 bytes here?

Question

See online example: Ideone example

struct {
  union {
    struct {
      uint32_t messageID : 26;
      uint8_t priority : 3; 
    } __attribute__ ((packed));
    uint32_t rawID : 29;
  } __attribute__ ((packed));
  uint8_t canFlags : 3;
} __attribute__ ((packed)) idSpecial;

Why would the compiler report the size of the struct as 5 bytes instead of 4 here? It should contain 32 bits.

Answer 1

The problem is that __attribute__((packed)) doesn't perform bitwise packing. It just guarantees that there is no padding between struct members. You can try this simpler example, where size is also reported as 5:

typedef struct structTag {
    struct {
      uint32_t messageID : 26;
      uint8_t priority : 3;
    } __attribute__ ((packed));
    uint8_t canFlags : 3;
} __attribute__ ((packed)) idSpecial;

Bitwise packing is only possible for bitfield members. You will need to redesign your struct to be a union of a struct with bitfields messageID/priority/canFlags, and a struct with bitfields rowID/canFlags. In other words, you will need to either have some duplication or resort to accessor macros or member functions.

Answer 2

It's because of memory alignment: The compiler won't start canFlags in the middle of a byte, it'll start it at the beginning of the next byte (probably*). So you have four bytes for your initial union, and a byte for canFlags.

If, for instance, you moved canFlags into the union, it would (probably*) have size 4:

typedef struct structTag {
  union {
    struct {
      uint32_t messageID : 26; /* 26bit message id, 67108864 ids */
      uint8_t priority : 3; /* priority: MUST BE 0 */
    } __attribute__ ((packed));
    uint32_t rawID : 29;
    uint8_t canFlags : 3; /* <==== Moved */
  } __attribute__ ((packed));
} __attribute__ ((packed)) idSpecial;

Updated example on ideone. Obviously, that specific change probably isn't what you want; I'm just demonstrating that the issue is starting a new field not on a byte boundary.

---

* "probably" because ultimately it's up to the compiler.

Answer 3

Data is arranged and accessed in computer memory using Data structure alignment. Which has two related issues

1. Alignment
2. Padding

When a write operation is performed by computer, It writes usually in multiple of 4 bytes(for 32 bit systems). One reason for this act is the goal to increase performance. So when you are writing any data structure, that has first 1 byte variable and then 4 bytes variable data, it will do padding after the first 1 byte data to align it on 32 bit boundaries.

struct {
  union {
    struct {
      uint32_t messageID : 26;
      uint8_t priority : 3; 
    } __attribute__ ((packed));
    uint32_t rawID : 29;
  } __attribute__ ((packed));
  uint8_t canFlags : 3;
} __attribute__ ((packed)) idSpecial;

Now in above data structure you are using __attribute__ ((packed)) which means no padding. So uint32_t is of 4 bytes, but you are saing it have 26 bits and 3 bits for priority. Now as you have both variables in one structure so it will reserve 32 bits instead of 29 so that your first structure's information is alligned on boundaries.

Now for canFlags It will need another bytes. So that makes 5 bytes instead of 4.

Answer 4

In some compilers, to "merge" the bits, all items must be of the same type. So make it uint32_t where you now have uint8_t - this appears to not be the case in the compiler IdeOne uses tho'

[No matter what, It is still up to the compiler how it merges the bits, so it the only way to absolutely guarantee that your data is stored as 32 bits is to use a single uint32_t and declare a class that does the relevant shifting and anding/oring to manipulate the value - the only guarantee you have is that ONE element in your struct will have at least as many bits as you have asked for]

As others have pointed out, you can't start a new structure on other than a byte boundary. I fixed it by having a second struct inside the union, like this: http://ideone.com/Mr1gjD

#include <stdint.h>
#include <stdio.h>

typedef struct structTag {
  union {
    struct {
      uint32_t messageID : 26; /* 26bit message id, 67108864 ids */
      uint8_t priority : 3; /* priority: MUST BE 0 */
    } __attribute__ ((packed));
    struct {
      uint32_t rawID : 29;
      uint8_t canFlags : 3;
    };
  } __attribute__ ((packed));
} __attribute__ ((packed)) idSpecial;

int main() {
    printf("size: %d", sizeof(idSpecial));
    return 0;
}