C中的默认联合和结构对齐？

Question

What is the default alignment of global variables that are unions or structures. Are they guaranteed to be word-aligned? In particular when using GCC and SDCC.

In the code, is the function f() safe, or can it cause unaligned access? Is there a difference between 16-bit and 32-bit platforms?

#define ADDR_SIZE 8

typedef union {
   unsigned char u8[ADDR_SIZE];
} addr_t;

addr_t global_address;

void f(void) {
   uint32_t x = *((uint32_t *)&global_address) + *((uint32_t *)&global_address + 1);
}

Answer 1

What is the default alignment of global variables that are unions or structures.

It depends on the union members.

Are they guaranteed to be word-aligned?

No. (Assuming word is 4-byte). Alignment requirements are complex. Although they are rarely greater than the sizeof(int) , they may differ per each type.

---

In C11, by including a max_align_t object, the union will be aligned as needed to any type.

max_align_t which is an object type whose alignment is as great as is supported by the implementation in all contexts; C11 §7.19 2

#include <stddef.h>

typedef union {
   max_align_t dummy;
   unsigned char u8[ADDR_SIZE];
} addr_t;

@Jens Gustedt has good points about aliasing. Just access the uint32_t from within the union. Watch out for endian issues.

typedef union {
   unsigned char u8[ADDR_SIZE];
   uint32_t u32[ADDR_SIZE/sizeof(uint32_t)];
} addr_t;

Answer 2

Unless you specified the alignment requirements using for example __attribute__((aligned(4))) , you cannot guarantee the union to be aligned properly.

With careful global variables arrangement using char like here:

...
#define ADDR_SIZE 8

typedef union {
   unsigned char u8[ADDR_SIZE];
} addr_t;

addr_t global_address1;
char padd1;
addr_t global_address2;
addr_t global_address3;
...

You can see here the odd address:

0x804971d * &global_address1
0x8049714
0x8049715 * &global_address2
0x804970c

Attempting to access these address in some architectures with strict-alignment requirements will cause some misaligned access exception and halts the program. Other architectures that can handle misaligned access, at performance cost, will require at least two memory read cycles witch requires a number of CPU cycles to complete.