I am going though some C code written for the Microchip C30 compiler and I often see structs defined as follows:
typedef struct __attribute__((__packed__))
{
IP_ADDR MyIPAddr; // IP address
IP_ADDR MyMask; // Subnet mask
IP_ADDR MyGateway; // Default Gateway
// etc...
} APP_CONFIG;
What does packed mean?
When structures are defined, the compiler is allowed to add paddings (spaces without actual data) so that members fall in address boundaries that are easier to access for the CPU.
For example, on a 32-bit CPU, 32-bit members should start at addresses that are multiple of 4 bytes in order to be efficiently accessed (read and written). The following structure definition adds a 16-bit padding between both members, so that the second member falls in a proper address boundary:
struct S {
int16_t member1;
int32_t member2;
};
The structure in memory of the above structure in a 32-bit architecture is (~ = padding):
+---------+---------+
| m1 |~~~~| m2 |
+---------+---------+
When a structure is packed, these paddings are not inserted. The compiler has to generate more code (which runs slower) to extract the non-aligned data members, and also to write to them.
The same structure, when packed, will appear in memory as something like:
+---------+---------+
| m1 | m2 |~~~~
+---------+---------+
It instructs the compiler to not add any padding between members of the struct.
See, for example, this page.
Let me explain the concept of padding in structures and then packed structures by taking an example.
And then let us see why packing is required.
Padding:
struct eg_struct
{
unsigned char abc;
unsigned int xyz;
}
When the structure is declared as above on a 16 bit architecture, the variable abc would be assigned some address. The next address is not assigned to variable xyz, instead one extra byte is added, and then the next address would be assigned to the variable xyz.
In the end, the structure looks something like below:
struct eg_struct
{
unsigned char abc;
unsigned char paddedbytes[1];
unsigned int xyz;
}
Padding makes addresses of member variables easily accessible to the microcontroller. The disadvantage is extra unnecessary bytes that come into the picture.
Packing:
If same structure is declared using the attribute “packed”, the extra byte will not be added after the variable abc.
Let me give one example where packing is needed:
Consider a microcontroller interfaced with an EEPROM where some structure is being stored.
Imagine a function writing to the EEPROM would look as below:
Write_EEPROM(EEPROM address, Ram address, Byte count);
Now if packing is not done, the extra padded bytes would occupy space in the EEPROM, which is of no use.
_attribute__((__packed__)) means (most probably) "do not insert any padding to make things faster" and may also mean "do not insert any alignments to preserve alignment".
One thing that has not been explicitly called out is that packing usually is done to match predefined field structures. For example, at the low level layer of a network interface, a series of bytes is exchanged between networked machines. After the data is received, it will need to be mapped to a high level structure so that the data can be manipulated easily. This is when no-padding is usually necessary, so that the structure directly maps to the bytes.
Network data interchange also involves byte endianness issue (i.e. almost all network data uses big endian format regardless the endianness of the source and destination machines).
Furthermore, some machines cannot access wide data in non-aligned address, for example, Cortex-M0 cores cannot access 32-bit data in non-32-bit aligned address, so care must be taken on writing networking code in such cases.
When packed used during structure declaration, compiler will not add any padding to the members of the same structure. Below is the example code and output which is self explanatory.
$ cat structure_packed.c
#include <stdio.h>
typedef struct __attribute__((__packed__))
{
char a;
int ai;
char ac;
}A;
struct B
{
char b;
int bi;
char bc;
};
int main()
{
A a;
struct B b;
int c;
printf("size of struct A: %lu, addr a: %p, addr ai: %p, addr ac: %p\n", sizeof(a), &(a.a), &(a.ai), &a.ac);
printf("size of struct B: %lu, addr b: %p, addr bi: %p, addr bc: %p\n", sizeof(b), &(b.b), &(b.bi), &b.bc);
printf("addr of c: %p\n", &c);
return 0;
}
Compile
$ gcc structure_packed.c -o structure_packed
Run|Output
$ ./structure_packed size of struct A: 6, addr a: 0x7ffc6f177ed6, addr ai: 0x7ffc6f177ed7, addr ac: 0x7ffc6f177edb size of struct B: 12, addr b: 0x7ffc6f177edc, addr bi: 0x7ffc6f177ee0, addr bc: 0x7ffc6f177ee4 addr of c: 0x7ffc6f177ed0
