How can I access variables in packed structure without unaligned mode? - c

Question

I'm using packed structure for communication using direct DMA access, and here is my test code:
// structure for communication buf 1
typedef __packed struct _test1
{
uint8_t a;
uint32_t b;
uint16_t c;
uint16_t d;
uint32_t e;
} test1;
// structure for communication buf 2
.
.
.
// structure for communication buf 3
.
.
.
// structure for communication buf set
typedef __packed struct _test2
{
uint8_t dump[3];
test1 t;
// may have many other packed structure for communication buf
} test2;
#pragma anon_unions
typedef struct _test3
{
union
{
uint32_t buf[4];
__packed struct
{
__packed uint8_t dump[3];
test1 t;
};
};
} test3;
test1 t1;
test2 t2;
test3 t3;
size of these structures are
sizeof(t1) = 13
sizeof(t2) = 16
sizeof(t3) = 16
if I want to access variable b, for not effecting performance, read/write memory content with aligned access is needed, with calculated offset by hand
t3.buf[1]
but I cannot read/write variables in structure without using unaligned accesses
t2.t.b
t3.t.b
so I defined structures like the following code, packed only variable a
typedef struct _test4
{
__packed uint8_t a;
uint32_t b;
uint16_t c;
uint16_t d;
uint32_t e;
} test4;
typedef struct _test5
{
__packed uint8_t dump[3];
test4 t;
} test5;
test4 t4;
test5 t5;
although access of all element in structure is aligned, but padding is inserted either
sizeof(t4) = 16
sizeof(t5) = 20
so how can I define packed structures, and access single variable in it without using unaligned access(except a)?
thanks a lot for helping

Answer 1

Your question introduces two problems under the umbrella of one:
Communication between components and/or devices; this may or may not have the same underlying representation of structures and integers, hence your use of the non-portable __packed attribute.
Performance of access, biased by alignment and/or data size; on one hand the compiler aligns data to fall in line with the bus, yet on the other hand that data might occupy too much space in your cache.
One of these is the actual problem you want to solve, X, and the other the Y in your XY problem. Please avoid asking XY problems in the future.
Have you considered how to guarantee that uint16_t and uint32_t will be big endian or little endian, based on your requirements? You need to specify that, if you care about portability. I care about portability, so that's what my answer will focus on. You may also notice how optimal efficiency will be obtained, too. Nonetheless, to make this portable:
You should be serialising your data using serialisation functions to convert each member of your structure into sequences of bytes by division and modulo (or left shift and binary and) operations.
Similarly, you should be deserialising your data by inverse operations multiplication and addition (or right shift and binary or).
As an example, here's some code showing both little endian and big endian for serialising and deserialising test1:
typedef /*__packed*/ struct test1
{
uint32_t b;
uint32_t e;
uint16_t c;
uint16_t d;
uint8_t a;
} test1;
void serialise_test1(test1 *destination, void *source) {
uint8_t *s = source;
destination->a = s[0];
destination->b = s[1] * 0x01000000UL
+ s[2] * 0x00010000UL
+ s[3] * 0x00000100UL
+ s[4]; /* big endian */
destination->c = s[5] * 0x0100U
+ s[6]; /* big endian */
destination->d = s[7]
+ s[8] * 0x0100U; /* little endian */
destination->e = s[9]
+ s[10] * 0x00000100UL
+ s[11] * 0x00010000UL
+ s[12] * 0x01000000UL; /* little endian */
}
void deserialise_test1(void *destination, test1 *source) {
uint8_t temp[] = { source->a
, source->b >> 24, source->b >> 16
, source->b >> 8, source->b
, source->c >> 8, source->c
, source->d, source->d >> 8
, source->d >> 16, source->b >> 24 };
memcpy(destination, temp, sizeof temp);
}
You may notice that I removed the __packed attribute and rearranged the members, so that the larger members precede (i.e. come before) the smaller; this is likely to reduce padding significantly. The functions allow you to convert between an array of uint8_t (which you send to/receive from the wire, or DMA, or whatnot) and your test1 structure, so this code is much more portable. You benefit from the guarantees this code provides regarding the structure of your protocol, where-as before it was at the whim of the implementation, and two devices using two different implementations might have disagreed about the internal representation of integers for example.

Answer 2

You could hard code all the indexes like
typedef __packed struct _test1
{
uint8_t a;
uint32_t b;
uint16_t c;
uint16_t d;
uint32_t e;
} test1;
enum
{
a = 0,
b = 1,
c = 5,
d = 7,
e = 9,
};
test1 t1 = {1,2,3,4};//not sure if init lists work for packed values
printf("%u", *(uint32_t*)((uint8_t*)&t1 + b));
Or offsetof can be used like this
printf("%u", *(uint32_t*)((uint8_t*)&t1 + offsetof(test1, b)));