int a[3];  // Chiếm 12 bytes liên tiếp: a[0], a[1], a[2]

struct rec {
    int a[3];      // offset 0
    int i;         // offset 12
    struct rec *n; // offset 16
};

| a[0] | a[1] | a[2] |  i   |    n     |
  0      4      8     12     16        20

void set_i(struct rec *r, int val) {
    r->i = val;
}

# %edx = val, %eax = r
movl %edx, 12(%eax)    # Mem[r+12] = val  (i nằm ở offset 12)

struct rec { int a[3]; int i; struct rec *n; };

int *get_ap(struct rec *r, int idx) {
    return &r->a[idx];
}

movl  12(%ebp), %eax   # lấy idx
sall  $2, %eax         # idx * 4
addl  8(%ebp), %eax    # r + idx*4

struct rec { int i; int a[3]; struct rec *n; };

movl  8(%ebp), %ebx    # lấy r
leal  4(%ebx), %esi    # r + 4
movl  12(%ebp), %edi   # lấy idx
sall  $2, %edi         # 4 * idx
leal  (%edi,%esi), %eax  # r + 4 + 4*idx

struct example {
    int b;       // offset 0
    double p;    // offset 4
    short a[4];  // offset 12
    char* c;     // offset 20
};

struct rec { int a[3]; int i; struct rec *n; };
// Layout: a(0), i(12), n(16)

void set_val(struct rec *r, int val) {
    while (r) {
        int i = r->i;
        r->a[i] = val;
        r = r->n;
    }
}

# r = %edx, val = %ecx
.L17:
    movl  12(%edx), %eax        # eax = r->i        (i ở offset 12)
    movl  %ecx, (%edx,%eax,4)   # r->a[i] = val     (a ở offset 0, phần tử i)
    movl  16(%edx), %edx        # r = r->n           (n ở offset 16)
    testl %edx, %edx            # kiểm tra r != NULL
    jne   .L17                  # nếu khác 0 thì lặp

struct rec { int i; int a[3]; struct rec *n; };
// Layout: i(0), a(4), n(16)

.L17:
    movl  (%edx), %eax           # eax = r->i        (i ở offset 0)
    movl  %ecx, 4(%edx,%eax,4)   # r->a[i] = val     (a ở offset 4)
    movl  16(%edx), %edx         # r = r->n
    testl %edx, %edx
    jne   .L17

Dữ liệu KHÔNG căn chỉnh:
| c | i[0]... | ...i[0] | i[1]... |
  p   p+1       p+5       p+9      (vấn đề: i[0] trải qua 2 block)

Dữ liệu ĐÃ căn chỉnh:
| c |  3 bytes trống  | i[0] | i[1] |     v      |
  p        p+1~3        p+4    p+8     p+16

struct S1 {
    char c;      // 1 byte, offset 0
    int i[2];    // 4 bytes x2, cần offset chia hết cho 4 → offset 4 (chèn 3 byte trống)
    double v;    // 8 bytes, cần offset chia hết cho 8 → offset 16 (chèn 4 byte từ sau i[1])
};

| c | _ _ _ | i[0] | i[1] | _ _ _ _ | v (8 bytes) |
  0    1~3     4      8      12~15     16            24
         K = 8 (do double), tổng kích thước = 24 (bội số của 8) ✓

struct example {
    int b;       // 4 bytes
    float d;     // 4 bytes
    double p;    // 8 bytes
    short a[4];  // 2*4 = 8 bytes
    char c;      // 1 byte
};

| b(4) | d(4) | p(8 bytes) | a[0]~a[3] (8 bytes) | c(1) | padding(7) |
  0      4      8             16                    24     25          32

struct S1 { char c; int i[2]; double v; } *p;

c | ___ | i[0] | i[1] | ____ | v
0   1~3   4      8      12~15  16    → tổng 24

c | ___ | i[0] | i[1] | v (8 bytes)
0   1~3   4      8      12           → tổng 20

struct S2 {
    double v;   // offset 0, 8 bytes
    int i[2];   // offset 8, 8 bytes
    char c;     // offset 16, 1 byte
};

| v (8) | i[0] | i[1] | c | _______ |
  0       8      12    16   17~23
                                    = 24 bytes tổng

struct S2 { double v; int i[2]; char c; } a[10];

a[0]        a[1]        a[2]
[v|i0|i1|c|pad] [v|i0|i1|c|pad] ...
a+0         a+24        a+48

struct S3 { short i; float v; short j; } a[10];

short get_j(int idx) {
    return a[idx].j;
}

| i(2) | _(2) | v(4) | j(2) | _(2) |  → sizeof(S3) = 12
  0      2      4      8      10

# %eax = idx
leal  (%eax,%eax,2), %eax   # eax = 3*idx
movswl a+8(,%eax,4), %eax   # load a[idx].j = a + 8 + 4*(3*idx) = a + 8 + 12*idx

// Cách kém: 12 bytes
struct S4 { char c; int i; char d; };
// c(0) | pad(3) | i(4) | d(8) | pad(3) = 12 bytes

// Cách tốt: 8 bytes
struct S5 { int i; char c; char d; };
// i(0) | c(4) | d(5) | pad(2) = 8 bytes

struct {
    char  *a;   // Windows 32-bit: con trỏ = 4 bytes
    short  b;   // 2 bytes
    double c;   // 8 bytes
    char   d;   // 1 byte
    float  e;   // 4 bytes
    void  *f;   // 4 bytes
} foo;

| a(4) | b(2) | __(2) | c(8) | d(1) | ___(3) | e(4) | f(4) | ____(4) |
  0      4      6       8      16     17        20     24     28        32

struct {
    double c;   // 8 bytes, offset 0
    char  *a;   // 4 bytes, offset 8
    float  e;   // 4 bytes, offset 12
    void  *f;   // 4 bytes, offset 16
    short  b;   // 2 bytes, offset 20
    char   d;   // 1 byte,  offset 22
                // padding 1 byte → offset 23, tổng = 24
} new_foo;