Căn chỉnh

#include <stdalign.h>       /* cho alignof va alignas, ten ngan */

_Alignof(char)     /* 1: dia chi nao cung duoc */
_Alignof(int)      /* 4: dia chi phai chia het cho 4 */
_Alignof(double)   /* 8 */

alignof(int)       /* giong _Alignof, ten ngan qua stdalign.h */

/* Va tu C23 thi alignof la tu khoa, khong can header. */

#include <stdio.h>
#include <stdalign.h>

int main(void) {
    printf("char %d  short %d  int %d  long %d  long long %d\n",
           (int)_Alignof(char), (int)_Alignof(short), (int)_Alignof(int),
           (int)_Alignof(long), (int)_Alignof(long long));
    printf("float %d  double %d  void* %d  max_align_t %d\n",
           (int)_Alignof(float), (int)_Alignof(double),
           (int)_Alignof(void *), (int)_Alignof(max_align_t));
    return 0;
}

/* Truy cap lech can chinh tren x86-64 hien dai:
     - voi mot lan doc: cham hon khoang 1 den 2 phan tram
     - khi vat qua ranh gioi dong bo dem 64 byte: cham hon dang ke
     - voi lenh SIMD: co the cham gap doi

   Nen tren x86 thi day la van de HIEU NANG, khong phai van de dung sai.
   Va do la ly do nhieu nguoi khong bao gio gap no. */

char buf[10];
int *p = (int *)(buf + 1);       /* dia chi khong chia het cho 4 */
int x = *p;

/* Tren x86:        chay, cham hon mot chut
   Tren ARM32 cu:   SIGBUS, chuong trinh chet
   Tren ARM64:      thuong chay, nhung lenh nap doi va SIMD thi khong
   Tren SPARC:      SIGBUS

   Va tren MOI may, chuan goi day la hanh vi khong xac dinh. */

#include <immintrin.h>

__m128 v = _mm_load_ps(p);       /* BAT BUOC p can chinh 16 byte,
                                    khong thi sap */
__m128 v = _mm_loadu_ps(p);      /* ban "u" cho phep lech, cham hon */

__m256d w = _mm256_load_pd(p);   /* AVX: bat buoc 32 byte */

/* Nen khi viet ma SIMD, can chinh khong phai tuy chon. */

#include <stdio.h>
#include <stdlib.h>
#include <stdalign.h>

int main(void) {
    alignas(64) char bo_dem[128];
    printf("bo_dem can chinh 64: %s\n",
           ((size_t)bo_dem % 64 == 0) ? "dung" : "sai");

    void *a = _aligned_malloc(1024, 64);   /* MinGW: khong co aligned_alloc */
    printf("cap phat can chinh 64: %s\n",
           (a && (size_t)a % 64 == 0) ? "dung" : "khong ho tro");
    _aligned_free(a);

    return 0;
}

#include <stdlib.h>

static void *cap_can_chinh(size_t can, size_t n) {
#if defined(_WIN32)
    return _aligned_malloc(n, can);
#elif defined(_ISOC11_SOURCE) || __STDC_VERSION__ >= 201112L
    /* lam tron n len boi cua can, cho an toan truoc C23 */
    size_t tron = (n + can - 1) / can * can;
    return aligned_alloc(can, tron);
#else
    void *p = NULL;
    if (posix_memalign(&p, can, n) != 0) return NULL;
    return p;
#endif
}

static void giai_phong_can_chinh(void *p) {
#if defined(_WIN32)
    _aligned_free(p);
#else
    free(p);
#endif
}

# Ba cach phat hien truy cap lech

gcc -fsanitize=alignment prog.c     # UBSan, bat luc chay
gcc -Wcast-align prog.c             # canh bao luc dich khi ep con tro
                                    # sang kieu co can chinh chat hon
gcc -Wcast-align=strict prog.c      # nghiem hon, ke ca tren x86

# -Wcast-align mac dinh chi canh bao tren nen tang KHONG cho phep
# truy cap lech. Tren x86 thi no im lang, nen phai dung ban "strict"
# neu ban muon ma chay duoc ca tren ARM.