T A[L];

char string[12];   →  chiếm [x, x+12)
int  val[5];       →  chiếm [x, x+20), mỗi phần tử cách nhau 4 bytes
double a[3];       →  chiếm [x, x+24), mỗi phần tử cách nhau 8 bytes
char* p[3];        →  chiếm [x, x+24) trên x86-64 (pointer = 8 bytes)

Little Endian:  05 00 00 00  (byte thấp trước)
Big Endian:     00 00 00 05  (byte cao trước)

int val[5];  // Giả sử địa chỉ bắt đầu là x
// val = {1, 5, 2, 1, 3}

char    A[12];
char   *B[8];
double  C[7];
double *D[5];
char  **E[5];

typedef int zip_dig[5];

int get_digit(zip_dig z, int i) {
    return z[i];
}

# %edx = z (địa chỉ đầu mảng)
# %eax = i (chỉ số)
movl (%edx, %eax, 4), %eax   # đọc ô nhớ tại địa chỉ z + 4*i

void zincr(zip_dig z) {
    int i;
    for (i = 0; i < 5; i++)
        z[i]++;
}

# %edx = z
        movl  $0, %eax        # i = 0
        jmp   .L3             # goto kiểm tra điều kiện
.L4:                          # loop:
        addl  $1, (%edx,%eax,4)  # z[i]++  (dùng i tính địa chỉ)
        addl  $1, %eax        # i++
.L3:
        cmpl  $5, %eax        # so sánh i với 5
        jne   .L4             # nếu i != 5, quay lại loop

void zincr_v(zip_dig z) {
    void *vz = z;
    int dt = 0;
    do {
        (*((int *)(vz + dt)))++;
        dt += 4;
    } while (dt != 4 * 5);
}

# %edx = z = vz
        movl  $0, %eax          # dt = 0
.L8:
        addl  $1, (%edx,%eax)   # tăng giá trị tại vz+dt
        addl  $4, %eax          # dt += 4
        cmpl  $20, %eax         # so sánh dt với 20 (= 4*5)
        jne   .L8

void zincr(zip_dig z) {
    size_t i;
    for (i = 0; i < 5; i++)
        z[i]++;
}

# %rdi = z
        movl  $0, %eax
        jmp   .L3
.L4:
        addl  $1, (%rdi,%rax,4)  # z[i]++
        addq  $1, %rax           # i++ (dùng addq vì i là size_t = 64-bit)
.L3:
        cmpq  $4, %rax           # so sánh với 4 (điều kiện i <= 4 tức i < 5)
        jbe   .L4                # jump if below or equal
        rep; ret

T A[R][C];   // R hàng, C cột, mỗi phần tử T chiếm K bytes

Trong bộ nhớ (int A[3][4]):
A[0][0] A[0][1] A[0][2] A[0][3] | A[1][0] A[1][1] ... | A[2][0] ...
^--- hàng 0 liên tục ---^         ^--- hàng 1 ---^

Địa chỉ A[i][j] = &A + i*(C*K) + j*K
                = &A + (i*C + j)*K

#define PCOUNT 6
zip_dig pgh[PCOUNT] = {
    {1, 5, 2, 0, 6},
    {1, 5, 2, 1, 3},
    ...
};

Địa chỉ bắt đầu A[i] = &A + i*(C*K)

int get_pgh_digit(int index, int dig) {
    return pgh[index][dig];
}

movl  8(%ebp), %eax           # eax = index
leal  (%eax,%eax,4), %eax     # eax = 5*index  (index + 4*index)
addl  12(%ebp), %eax          # eax = 5*index + dig
movl  pgh(,%eax,4), %eax      # đọc pgh + 4*(5*index + dig)

int *univ[3] = {mit, cmu, ucb};

univ[0] → địa chỉ của mit → [0, 2, 1, 3, 9]
univ[1] → địa chỉ của cmu → [1, 5, 2, 1, 3]
univ[2] → địa chỉ của ucb → [9, 4, 7, 2, 0]

Nested Array:     Mem[pgh + 20*index + 4*digit]    → 1 lần đọc bộ nhớ
Multi-Level:      Mem[Mem[univ + 4*index] + 4*digit] → 2 lần đọc bộ nhớ

# int get_univ_digit(int index, int digit)
movl  8(%ebp), %eax           # eax = index
movl  univ(,%eax,4), %edx     # edx = univ[index]  ← lần đọc 1: lấy con trỏ
movl  12(%ebp), %eax          # eax = digit
movl  (%edx,%eax,4), %eax     # eax = *(univ[index] + 4*digit)  ← lần đọc 2

#define N 16
typedef int fix_matrix[N][N];

int fix_ele(fix_matrix a, size_t i, size_t j) {
    return a[i][j];
}

movl  12(%ebp), %edx   # edx = i
sall  $6, %edx         # edx = i*64  (shift left 6 = nhân 2^6 = 64)
movl  16(%ebp), %eax   # eax = j
sall  $2, %eax         # eax = j*4
addl  8(%ebp), %eax    # eax = &a + j*4
movl  (%eax,%edx), %eax # đọc *(a + j*4 + i*64)

#define IDX(n, i, j) ((i)*(n) + (j))

int vec_ele(size_t n, int *a, size_t i, size_t j) {
    return a[IDX(n, i, j)];
}

int var_ele(size_t n, int a[n][n], size_t i, size_t j) {
    return a[i][j];
}

movl  8(%ebp), %eax    # eax = n
sall  $2, %eax         # eax = n*4
movl  %eax, %edx
imull 16(%ebp), %edx   # edx = i*n*4
movl  20(%ebp), %eax   # eax = j
sall  $2, %eax         # eax = j*4
addl  12(%ebp), %eax   # eax = &a + j*4
movl  (%eax,%edx), %eax # đọc *(a + j*4 + i*n*4)