ARM64 (AArch64) 명령어셋 레퍼런스

ARM64(AArch64) 아키텍처의 명령어를 GAS 문법 기준으로 종합 정리합니다. RISC 설계 철학과 고정 32-bit 명령어 길이, 31개 범용 레지스터와 예외 레벨(EL0-EL3), NEON(128-bit)/SVE(가변 길이) 벡터 레지스터, 주소 지정 모드, 데이터 전송·산술·논리·분기·스택·시스템·원자적·SIMD 명령어 카테고리 표, A64 인코딩 다이어그램, 커널 핵심 명령어(SVC, ERET, LDXR/STXR, DMB/DSB/ISB) 심화까지 Linux 커널 개발에 필요한 ARM64 ISA 전체를 다룹니다.

아키텍처 개요

ARM64(AArch64)는 ARMv8-A에서 도입된 64-bit RISC 아키텍처입니다. ARMv1(1985) → ARMv7(32-bit A32/T32) → ARMv8(64-bit A64, 2011) → ARMv9(2021, SVE2/MTE/CCA)로 발전했습니다.

레지스터 셋

범용 레지스터

PSTATE 조건 플래그

시스템 레지스터 (주요)

SIMD/벡터 레지스터

주소 지정 모드

/* ADRP + ADD: 심볼의 전체 주소 계산 */
    adrp    x0, my_global           /* x0 = my_global이 있는 4KB 페이지 주소 */
    add     x0, x0, :lo12:my_global  /* x0 += 페이지 내 오프셋 (하위 12비트) */
    /* 이제 x0 = &my_global 전체 주소 */

/* ADRP + LDR: 심볼에서 직접 값 로드 */
    adrp    x1, my_global
    ldr     x1, [x1, :lo12:my_global] /* my_global 값 직접 로드 */

데이터 전송 명령어

ADRP + LDR 패턴: 전역 변수 접근

/* C 코드: extern unsigned long jiffies; val = jiffies; */

/* 컴파일러가 생성하는 ADRP + LDR 패턴 */
    adrp    x0, jiffies              /* x0 = jiffies의 4KB 페이지 주소 */
    ldr     x0, [x0, :lo12:jiffies]  /* x0 = *jiffies (페이지 내 오프셋으로 로드) */

/* GOT(Global Offset Table) 경유 패턴 (모듈 코드) */
    adrp    x0, :got:jiffies         /* GOT 엔트리의 페이지 주소 */
    ldr     x0, [x0, :got_lo12:jiffies] /* GOT에서 실제 주소 로드 */
    ldr     x0, [x0]                 /* 실제 값 로드 */

산술 명령어

논리/시프트/비트 조작 명령어

비교/분기 명령어

/* C 코드: if (x == 1 && y == 2) goto target; */

/* x86-64 방식 (분기 2개) */
    /*  cmp  x0, #1       */
    /*  b.ne  skip         */
    /*  cmp  x1, #2       */
    /*  b.eq  target       */
    /*  skip:              */

/* ARM64 CCMP 방식 (분기 1개) */
    cmp     x0, #1               /* x == 1? 플래그 세트 */
    ccmp    x1, #2, #0, eq       /* 이전이 EQ이면 y==2 비교, 아니면 NZCV=0(NE) */
    b.eq    target                /* 두 조건 모두 참이면 분기 */

/* C 코드: if (x == 1 || y == 2) goto target; */
    cmp     x0, #1               /* x == 1? */
    ccmp    x1, #2, #4, ne       /* 이전이 NE이면 y==2 비교, EQ이면 NZCV=4(Z=1,EQ) */
    b.eq    target                /* 둘 중 하나라도 참이면 분기 */

스택/함수 호출 명령어

ARM64에는 PUSH/POP 명령어가 없습니다. STP/LDP로 레지스터 쌍을 저장/복원합니다.

/* 함수 프롤로그/에필로그 패턴 */
my_func:
    stp     x29, x30, [sp, #-16]!    /* FP, LR 저장 (pre-index) */
    mov     x29, sp                    /* 프레임 포인터 설정 */
    /* ... 함수 본문 ... */
    ldp     x29, x30, [sp], #16       /* FP, LR 복원 (post-index) */
    ret                                /* X30(LR)으로 복귀 */

시스템/특권 명령어

원자적/동기화 명령어

독점 접근 (ARMv8.0)

LSE 원자적 명령어 (ARMv8.1)

메모리 배리어

LDXR/STXR CAS 루프 패턴

/* compare_and_swap(addr, expected, desired) */
cas_loop:
    ldaxr   x3, [x0]            /* 독점 Acquire 로드 */
    cmp     x3, x1               /* expected와 비교 */
    b.ne    1f                   /* 다르면 실패 */
    stlxr   w4, x2, [x0]         /* 독점 Release 저장 */
    cbnz    w4, cas_loop          /* 저장 실패 시 재시도 */
1:
    mov     x0, x3               /* 이전 값 반환 */
    ret

스핀락 구현 예제 (LDAXR/STLXR)

/* arch_spin_lock — 간소화된 스핀락 구현 */
/* x0 = &lock (0=unlocked, 1=locked) */
arch_spin_lock:
    mov     w2, #1               /* 락 값 준비 */
    sevl                             /* 이벤트 레지스터 세트 (첫 WFE 통과) */
1:  wfe                              /* 이벤트 대기 (전력 절약) */
2:  ldaxr   w1, [x0]             /* Acquire 독점 로드 */
    cbnz    w1, 1b               /* 이미 잠김 → WFE로 대기 */
    stxr    w1, w2, [x0]          /* 독점 저장 시도 */
    cbnz    w1, 2b               /* 저장 실패 → 재시도 (WFE 건너뜀) */
    ret                              /* 락 획득 성공 */

arch_spin_unlock:
    stlr    wzr, [x0]             /* Release 저장: 0(unlock) 기록 */
    ret                              /* SEV는 STLR의 exclusive monitor clear로 자동 전파 */

SIMD/벡터 명령어

NEON 명령어 (128-bit)

SVE 명령어 (가변 길이)

커널 핵심 명령어 심화

SVC #0 el0_svc 진입 경로

/* 유저 공간에서 시스템 콜: SVC #0 */
/* ELR_EL1 ← PC+4, SPSR_EL1 ← PSTATE, PSTATE.DAIF 마스크 */
/* PC ← VBAR_EL1 + 0x400 (EL0 64-bit Synchronous) */

/* arch/arm64/kernel/entry.S — 예외 벡터 테이블 */
    .align 11                       /* 2048-byte 정렬 */
vectors:
    /* Current EL with SP0 */
    ventry  el1_sync_invalid        /* Synchronous */
    ventry  el1_irq_invalid         /* IRQ */
    ventry  el1_fiq_invalid         /* FIQ */
    ventry  el1_error_invalid       /* SError */
    /* Current EL with SPx */
    ventry  el1h_sync               /* Synchronous */
    ventry  el1h_irq                /* IRQ */
    /* ... */
    /* Lower EL (EL0) using AArch64 */
    ventry  el0_sync                /* Synchronous (SVC 포함) */
    ventry  el0_irq                 /* IRQ */
    /* ... */

MSR/MRS 시스템 레지스터 접근

/* SCTLR_EL1 읽기/쓰기 */
    mrs     x0, sctlr_el1           /* 읽기 */
    orr     x0, x0, #(1 << 0)      /* MMU 활성화 비트 세트 */
    msr     sctlr_el1, x0           /* 쓰기 */
    isb                              /* 명령어 동기화 */

/* 페이지 테이블 베이스 설정 */
    msr     ttbr0_el1, x0           /* 유저 페이지 테이블 */
    msr     ttbr1_el1, x1           /* 커널 페이지 테이블 */
    tlbi    vmalle1                  /* 전체 TLB 무효화 */
    dsb     ish                      /* 데이터 동기화 */
    isb                              /* 명령어 동기화 */

ERET 예외 복귀

/* EL1에서 EL0으로 복귀 */
    msr     elr_el1, x0             /* 복귀 주소 설정 */
    msr     spsr_el1, x1            /* 프로세서 상태 복원 */
    eret                             /* 예외 복귀: PC←ELR, PSTATE←SPSR */

/* KPTI: 유저 복귀 시 TTBR0 전환 (간소화) */
/* arch/arm64/kernel/entry.S 기반 */
    mrs     x1, ttbr1_el1           /* 커널 TTBR1 읽기 */
    bfi     x1, x0, #48, #16     /* ASID 삽입 */
    msr     ttbr0_el1, x1           /* TTBR0 = 유저 페이지 테이블 */
    isb                              /* 파이프라인 동기화 */
    eret                             /* EL0으로 복귀 */

예외 진입 시 레지스터 저장 (kernel_entry 매크로)

/* arch/arm64/kernel/entry.S — kernel_entry 매크로 (간소화) */
/* EL0 → EL1 예외 진입 시 전체 레지스터 컨텍스트 저장 */
    sub     sp, sp, #288           /* pt_regs 구조체 크기만큼 스택 할당 */
    stp     x0, x1, [sp, #16 * 0]  /* X0-X1 저장 */
    stp     x2, x3, [sp, #16 * 1]  /* X2-X3 저장 */
    /* ... X4-X27 저장 (STP 쌍으로) ... */
    stp     x28, x29, [sp, #16 * 14] /* X28-X29 저장 */

    mrs     x22, elr_el1            /* 예외 복귀 주소 */
    mrs     x23, spsr_el1           /* 저장된 프로세서 상태 */
    mrs     x20, sp_el0             /* 유저 SP (EL0 사용 SP) */

    stp     x30, x20, [sp, #16 * 15] /* LR, SP_EL0 저장 */
    stp     x22, x23, [sp, #16 * 16] /* ELR_EL1, SPSR_EL1 저장 */

    /* 이제 C 함수(el0_sync_handler 등)를 호출할 수 있음 */
    mov     x0, sp                   /* pt_regs 포인터를 인자로 전달 */
    bl      el0_svc_handler          /* 시스템 콜 핸들러 호출 */

Linux 커널 GCC 인라인 어셈블리 예제 (ARM64)

/* arch/arm64/include/asm/sysreg.h 기반 */
#define read_sysreg(r) ({                               \
    u64 __val;                                         \
    asm volatile("mrs %0, " __stringify(r) : "=r"(__val)); \
    __val;                                              \
})

#define write_sysreg(v, r) do {                          \
    u64 __val = (u64)(v);                               \
    asm volatile("msr " __stringify(r) ", %x0"           \
                 : : "rZ"(__val));                       \
} while (0)

/* 사용 예: 인터럽트 비활성화 */
static inline void arch_local_irq_disable(void)
{
    asm volatile(
        "msr    daifset, #3"    /* IRQ + FIQ 마스크 */
        :
        :
        : "memory"
    );
}

/* atomic_add: 인라인 어셈블리로 원자적 덧셈 */
static inline void arch_atomic_add(int i, atomic_t *v)
{
    unsigned long tmp;
    int result;

    asm volatile(
        "1: ldxr    %w0, %2\n"       /* 독점 로드 */
        "   add     %w0, %w0, %w3\n" /* 덧셈 */
        "   stxr    %w1, %w0, %2\n"  /* 독점 저장 */
        "   cbnz    %w1, 1b"         /* 실패 시 재시도 */
        : "=&r"(result), "=&r"(tmp), "+Q"(v->counter)
        : "Ir"(i)
    );
}

명령어 인코딩

ARM64(A64) 모든 명령어는 고정 32-bit입니다. 상위 비트(op0 필드)로 명령어 그룹을 결정합니다.

인코딩 예제: ADD X0, X1, X2

ADD X0, X1, X2는 "Data Processing — Register" 그룹(op0=x101)에 속합니다. 구체적으로 Add (shifted register) 형식으로 인코딩됩니다.

보안 확장 (PAC/BTI/MTE)

ARMv8.3+ 이후 도입된 보안 확장은 커널과 유저 공간 모두에서 메모리 안전성과 제어 흐름 무결성을 하드웨어 수준으로 강화합니다. PAC(Pointer Authentication), BTI(Branch Target Identification), MTE(Memory Tagging Extension)는 각각 ROP/JOP 공격, 간접 분기 하이재킹, use-after-free/buffer-overflow를 방어합니다.

/* PAC 커널 함수 프롤로그/에필로그 (GCC 자동 생성) */
my_function:
    paciasp                    /* LR에 PAC 서명 (SP를 컨텍스트로) */
    stp     x29, x30, [sp, #-16]!
    mov     x29, sp
    /* ... 함수 본문 ... */
    ldp     x29, x30, [sp], #16
    autiasp                    /* PAC 검증 (실패 시 fault → SIGILL) */
    ret

/* BTI 보호 함수 진입점 */
my_indirect_target:
    bti     c                  /* BL로만 도달 가능한 타겟 표시 */
    stp     x29, x30, [sp, #-16]!
    /* ... */

/* MTE 커널 사용 (KASAN HW 모드) */
/* CONFIG_KASAN_HW_TAGS=y → 슬랩 할당 시 자동 태깅 */
/* kmalloc() → kasan_set_tag() → IRG + STG */
/* kfree() → 태그 변경 → 이후 접근 시 Tag Check Fault */

캐시 & TLB 관리 명령어

ARM64는 x86과 달리 소프트웨어가 명시적으로 캐시 유지보수와 TLB 무효화를 수행해야 합니다. 커널의 DMA 매핑, 페이지 테이블 수정, 코드 패칭 등에서 정확한 캐시/TLB 관리가 필수입니다.

관련 문서