Why can’t C compilers rearrange struct members to eliminate alignment padding? [duplicate]

by

There are multiple reasons why the C compiler cannot automatically reorder the fields:

  • The C compiler doesn’t know whether the struct represents the memory structure of objects beyond the current compilation unit (for example: a foreign library, a file on disc, network data, CPU page tables, …). In such a case the binary structure of data is also defined in a place inaccessible to the compiler, so reordering the struct fields would create a data type that is inconsistent with the other definitions. For example, the header of a file in a ZIP file contains multiple misaligned 32-bit fields. Reordering the fields would make it impossible for C code to directly read or write the header (assuming the ZIP implementation would like to access the data directly):

    struct __attribute__((__packed__)) LocalFileHeader {
    uint32_t signature;
    uint16_t minVersion, flag, method, modTime, modDate;
    uint32_t crc32, compressedSize, uncompressedSize;
    uint16_t nameLength, extraLength;
};

    The packed attribute prevents the compiler from aligning the fields according to their natural alignment, and it has no relation to the problem of field ordering. It would be possible to reorder the fields of LocalFileHeader so that the structure has both minimal size and has all fields aligned to their natural alignment. However, the compiler cannot choose to reorder the fields because it does not know that the struct is actually defined by the ZIP file specification.

  • C is an unsafe language. The C compiler doesn’t know whether the data will be accessed via a different type than the one seen by the compiler, for example:

    struct S {
    char a;
    int b;
    char c;
};

struct S_head {
    char a;
};

struct S_ext {
    char a;
    int b;
    char c;
    int d;
    char e;
};

struct S s;
struct S_head *head = (struct S_head*)&s;
fn1(head);

struct S_ext ext;
struct S *sp = (struct S*)&ext;
fn2(sp);

    This is a widely used low-level programming pattern, especially if the header contains the type ID of data located just beyond the header.

  • If a struct type is embedded in another struct type, it is impossible to inline the inner struct:

    struct S {
    char a;
    int b;
    char c, d, e;
};

struct T {
    char a;
    struct S s; // Cannot inline S into T, 's' has to be compact in memory
    char b;
};

    This also means that moving some fields from S to a separate struct disables some optimizations:

    // Cannot fully optimize S
struct BC { int b; char c; };
struct S {
    char a;
    struct BC bc;
    char d, e;
};

  • Because most C compilers are optimizing compilers, reordering struct fields would require new optimizations to be implemented. It is questionable whether those optimizations would be able to do better than what programmers are able to write. Designing data structures by hand is much less time consuming than other compiler tasks such as register allocation, function inlining, constant folding, transformation of a switch statement into binary search, etc. Thus the benefits to be gained by allowing the compiler to optimize data structures appear to be less tangible than traditional compiler optimizations.

More Related Contents:

  1. Access violation reading data from binary file into struct in C
  2. Why does clang produce inefficient asm with -O0 (for this simple floating point sum)?
  3. typedef struct vs struct definitions [duplicate]
  4. Struct memory layout in C
  5. Difference between a Structure and a Union
  6. How do I check if a variable is of a certain type (compare two types) in C?
  7. Assign one struct to another in C
  8. The initialization of static variables in C
  9. How to turn off gcc compiler optimization to enable buffer overflow
  10. C typedef of pointer to structure
  11. How to initialize const in a struct in C (with malloc)
  12. C : typedef struct name {…}; VS typedef struct{…} name;
  13. Trouble Understanding MPI_Type_create_struct
  14. Are “malloc(sizeof(struct a *))” and “malloc(sizeof(struct a))” the same?
  15. How to trap unaligned memory access?
  16. Empty structure in C
  17. what is the difference between struct {0} and memset 0 [duplicate]
  18. How to include a dynamic array INSIDE a struct in C?
  19. Initializing a struct to 0
  20. How to optimize these loops (with compiler optimization disabled)?
  21. Array of variable length in a structure
  22. forward declaration of a struct in C?
  23. Is there any way to loop through a struct with elements of different types in C?
  24. Does GCC’s __attribute__((__packed__)) retain the original ordering?
  25. How do you use offsetof() on a struct?
  26. How does C return a structure? [duplicate]
  27. dereferencing pointer to incomplete type
  28. Char array in a struct – incompatible assignment? [duplicate]
  29. Get list of C structure members
  30. Why does my function not modify the value of variable in a struct in C?

Leave a Comment