Question

I’d like to count/sum up the overhead in an object file due to packing (and, ideally, have gcc minimize it for me).

For example, consider the following structure (32 bit x86, gcc):

struct a { 
    uint8_t a_char;
    uint32_t an_integer
    uint8_t another_letter;
};

While the actual data only takes up 6 bytes, the structure takes up 12 bytes in memory because both chars are followed by 3 padding bytes. By reordering the structure as follows:

struct b { 
    uint32_t an_integer
    uint8_t a_char;
    uint8_t another_letter;
};

The structure will only have sizeof(struct b) == 8 (still 4 bytes of overhead).

(1) Ideally, I’d like for gcc to rearrange struct a to struct b and save me the space, but my version (4.2) doesn’t seem to do this for any optimization level.

(2) Alternatively, given struct a, I’d like to (automatically) get either the number 6 (total amount of overhead) or 4 (minimal amount of overhead, if members are ordered “ideally”). The purpose of this is to determine whether or not manually reordering structures is worth the time (likely not).

Is there a way for gcc to do (1), and is there a tool that would perform (2)? The closest thing I can think of for (1) is #pragma pack(1), but (I’m guessing) it would have serious performance implications by making most/all memory accesses unaligned. For (2), I’m thinking a Perl script parsing debugging symbols might be able to do this, but I’m not familiar enough with DWARF to know for sure.

Answer 1

For #1, the reason it’s not done is that both the C and C++ standards prohibit structure member reordering.

Yes, struct packing will generally reduce performance. And, as mentioned in a comment, in some cases on non-x86 architectures you can get a SIGBUS if you try to operate on a member.

For #2, yes a perl script might be able to do it. Instead of parsing DWARF info, you could try scanning the source code for struct definitions, and maybe generate some small test programs to check the sizeof() of structs and members and so on.