x86_64 명령어셋 레퍼런스

x86_64(AMD64/Intel 64) 아키텍처의 명령어를 AT&T 문법 기준으로 종합 정리합니다. CISC 설계 철학과 가변 길이 인코딩, 16개 범용 레지스터와 RFLAGS, SSE/AVX/AVX-512 SIMD 레지스터, 주소 지정 모드, 데이터 전송·산술·논리·분기·스택·시스템·원자적·SIMD 명령어 카테고리 표, REX/VEX/EVEX 인코딩 다이어그램, 커널 핵심 명령어(SYSCALL, SWAPGS, LOCK CMPXCHG, INVLPG) 심화까지 Linux 커널 개발에 필요한 x86_64 ISA 전체를 다룹니다.

아키텍처 개요

x86_64(AMD64)는 2003년 AMD가 IA-32(x86)를 64-bit로 확장한 CISC 아키텍처입니다. 8086(1978) → 80386(1985, 32-bit) → AMD64(2003, 64-bit) 순으로 발전했으며, 하위 호환성을 유지하면서 레지스터와 주소 공간을 확장했습니다.

동작 모드 전환 다이어그램

x86_64 프로세서는 전원 인가 후 Real Mode에서 시작하며, 제어 레지스터 비트를 조작해 단계적으로 Long Mode(64-bit)까지 전환합니다. 리눅스 커널 부트 과정에서 이 전환은 arch/x86/boot/compressed/head_64.S에서 수행됩니다.

레지스터 셋

범용 레지스터 (64-bit / 32-bit / 16-bit / 8-bit)

레지스터 중첩 구조 (RAX 예시)

x86_64 범용 레지스터는 하위 호환성을 위해 중첩 구조를 가집니다. 64-bit RAX 안에 32-bit EAX가, 그 안에 16-bit AX가, AX는 다시 상위 AH와 하위 AL로 나뉩니다.

RFLAGS 레지스터 주요 비트

특수/시스템 레지스터

SIMD 레지스터

SIMD 레지스터 중첩 구조

SIMD 레지스터는 SSE → AVX → AVX-512 확장에 따라 중첩 구조를 가집니다. ZMM의 하위 256-bit은 YMM이고, YMM의 하위 128-bit은 XMM입니다.

주소 지정 모드

x86_64 AT&T 문법에서 메모리 피연산자는 displacement(base, index, scale) 형식을 사용합니다.

ModR/M 및 SIB 바이트 구조

x86_64 메모리 피연산자의 인코딩에서 ModR/M 바이트는 주소 모드와 레지스터를 지정하고, SIB(Scale-Index-Base) 바이트는 복합 주소 계산(base + index * scale + displacement)을 인코딩합니다. ModR/M의 R/M 필드가 100(RSP 인코딩)이면 SIB 바이트가 뒤따릅니다.

데이터 전송 명령어

/* 커널에서 자주 보이는 패턴 */

/* 1. LEA로 구조체 멤버 주소 계산 (메모리 접근 없음) */
/*    leaq offset(%rdi), %rax   — container_of() 매크로 결과 */

/* 2. MOVSX: syscall 번호(int) → 테이블 인덱스(long) */
/*    movslq %eax, %rax  — 32-bit 부호 있는 값을 64-bit로 확장 */

/* 3. MOVZX: 바이트 읽기 → 레지스터 제로 확장 */
/*    movzbl (%rdi), %eax  — 1바이트 로드, EAX 제로 확장 (RAX 상위도 0) */

/* 4. CMOVcc: 조건부 이동으로 분기 제거 */
int clamp_min(int val, int min_val) {
    return val < min_val ? min_val : val;
    /* 컴파일 결과:
       cmpl %esi, %edi      // val - min_val
       cmovll %esi, %edi    // val < min_val이면 edi = min_val
       movl %edi, %eax      // return
    */
}

산술 명령어

/* GCC가 자주 생성하는 LEA 패턴 */

/* x * 3 */
leaq    (%rdi,%rdi,2), %rax    /* rax = rdi + rdi*2 = rdi*3 */

/* x * 5 + 1 */
leaq    1(%rdi,%rdi,4), %rax   /* rax = rdi + rdi*4 + 1 = rdi*5 + 1 */

/* x * 12 (두 단계) */
leaq    (%rdi,%rdi,2), %rax    /* rax = rdi*3 */
shlq    $2, %rax               /* rax = rdi*3*4 = rdi*12 */

/* 주의: LEA는 RFLAGS를 변경하지 않으므로 */
/* CMP/TEST 뒤의 조건 분기를 방해하지 않음 */
cmpq    $0, %rsi
leaq    1(%rdi), %rdi          /* rdi++, 플래그 보존 (INC는 ZF 변경) */
je      .Lzero                  /* 위의 CMP 결과로 분기 */

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

비교/분기 명령어

분기 예측과 커널 최적화

현대 x86_64 프로세서는 분기 예측 유닛(BPU)을 사용해 조건 분기의 결과를 투기적으로 예측합니다. 예측이 맞으면 파이프라인이 지연 없이 계속 진행되지만, 예측 실패(misprediction) 시 10~20 사이클의 페널티가 발생합니다.

/* include/linux/compiler.h */
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

/* 사용 예시 — 페이지 폴트 핸들러 */
if (unlikely(fault_signal_pending(fault, regs))) {
    /* 시그널 처리 (cold path — 거의 실행되지 않음) */
    return;
}
/* 정상 처리 (hot path — 대부분 여기로 진행) */

/* unlikely() 적용 시 GCC가 생성하는 코드 레이아웃 */
/* hot path가 직선(fall-through)이 되도록 배치 */

.Lhot_path:
    testq   %rax, %rax
    jne     .Lcold_path         /* unlikely: 분기 안 하는 것이 일반적 */
    /* ... 정상 처리 (fall-through) ... */
    ret

    /* cold path는 함수 끝으로 분리 (I-cache 효율) */
    .section .text.unlikely
.Lcold_path:
    /* ... 에러 처리 ... */
    jmp     .Lerror_handler

스택/함수 호출 명령어

시스템/특권 명령어

SYSCALL/SYSRET 메커니즘 상세

SYSCALL은 인터럽트(INT 0x80)보다 훨씬 빠른 시스템 콜 진입 방법입니다. 스택 전환이나 IDT 조회 없이 MSR에 미리 설정된 값으로 즉시 커널 코드로 점프합니다. 이 과정에서 하드웨어가 자동으로 수행하는 레지스터 조작을 이해하는 것이 중요합니다.

원자적/동기화 명령어

LOCK 접두사는 다음 명령어의 메모리 연산을 원자적으로 만듭니다. 캐시 라인 락 또는 버스 락을 통해 멀티코어 환경에서 원자성을 보장합니다.

LOCK CMPXCHG 패턴 (Compare-And-Swap)

/* atomic_cmpxchg: [rdi]가 rsi이면 rdx로 교체 */
atomic_cmpxchg:
    movq    %rsi, %rax          /* RAX ← expected (old) */
    lock cmpxchgq %rdx, (%rdi) /* if [RDI]==RAX then [RDI]←RDX */
                                  /* RAX ← [RDI] (이전 값) */
    ret                         /* RAX에 이전 값 반환 */

XCHG 기반 스핀락 구현

XCHG는 메모리 피연산자와 사용될 때 암묵적으로 LOCK이 적용됩니다. 이 특성을 이용한 스핀락은 가장 기본적인 커널 동기화 방식입니다.

/* 단순 스핀락 구현 (Test-and-Set) */
/* RDI = lock 주소, lock=0 (해제), lock=1 (획득) */

spin_lock:
    movl    $1, %eax
.Lretry:
    xchgl   %eax, (%rdi)          /* 원자적 교환 (암묵적 LOCK) */
    testl   %eax, %eax             /* 이전 값이 0이었으면 → 락 획득 성공 */
    jnz     .Lspin                  /* 아니면 스핀 */
    ret

.Lspin:
    pause                           /* 스핀 루프 힌트 (전력 절감 + 파이프라인) */
    cmpl    $0, (%rdi)              /* Test: 락이 해제되었는지 읽기만 (LOCK 없이) */
    jne     .Lspin                  /* 아직 잠겨있으면 계속 스핀 */
    jmp     .Lretry                 /* 해제된 것 같으면 Set 재시도 */

spin_unlock:
    movl    $0, (%rdi)              /* 단순 쓰기 (x86 스토어 순서 보장) */
    ret

XADD 기반 참조 카운팅

LOCK XADD는 원자적으로 값을 더하면서 이전 값을 반환합니다. 이는 참조 카운팅에서 이전 카운트 확인이 필요할 때 핵심적으로 사용됩니다.

/* 커널 refcount 감소 (arch/x86/include/asm/refcount.h 기반) */
static inline bool refcount_dec_and_test(refcount_t *r)
{
    int val = -1;  /* 감소할 값 */

    asm volatile(LOCK_PREFIX "xaddl %0, %1"
                 : "+r"(val), "+m"(r->refs.counter)
                 :: "memory");

    /* val = 이전 값, counter는 이미 감소됨 */
    /* 이전 값이 1이었으면 → 감소 후 0 → 마지막 참조 해제 */
    return val == 1;
}

/* 사용 패턴 */
if (refcount_dec_and_test(&obj->refcnt)) {
    /* 참조 카운트 0 → 객체 해제 */
    kfree(obj);
}

SIMD/벡터 명령어

SSE 명령어 (128-bit XMM)

AVX 명령어 (256-bit YMM)

AVX-512 명령어 (512-bit ZMM)

커널 핵심 명령어 심화

SYSCALL/SYSRET 진입 경로

x86_64 Linux에서 시스템 콜은 SYSCALL 명령어로 진입합니다. MSR_LSTAR에 저장된 entry_SYSCALL_64 주소로 점프합니다.

/* arch/x86/entry/entry_64.S — entry_SYSCALL_64 핵심 경로 */
entry_SYSCALL_64:
    swapgs                       /* GS를 커널 per-cpu로 교환 */
    movq    %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
    movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    /* pt_regs 구조체 저장 */
    pushq   $__USER_DS            /* SS */
    pushq   PER_CPU_VAR(cpu_tss_rw + TSS_sp2) /* RSP */
    pushq   %r11                    /* RFLAGS (SYSCALL이 R11에 저장) */
    pushq   $__USER_CS              /* CS */
    pushq   %rcx                    /* RIP (SYSCALL이 RCX에 저장) */
    pushq   %rax                    /* syscall 번호 */
    /* ... 나머지 레지스터 저장, 시스콜 디스패치 ... */

컨텍스트 전환 시 레지스터 저장/복원

시스템 콜이나 인터럽트로 커널에 진입할 때, 하드웨어와 소프트웨어가 역할을 분담하여 사용자 레지스터를 저장합니다. SYSCALL은 최소한의 레지스터만 하드웨어가 저장하고, 나머지는 커널 진입 코드(entry_SYSCALL_64)가 수동으로 저장합니다.

SWAPGS와 per-cpu 데이터 접근 패턴

SWAPGS는 GS 베이스 레지스터와 MSR_KERNEL_GS_BASE를 교환합니다. 커널 진입 시 per-cpu 데이터 접근을 위해 사용되며, 복귀 시 다시 교환합니다. GS 베이스를 통해 현재 CPU의 per-cpu 영역에 빠르게 접근할 수 있습니다.

/* SWAPGS + per-cpu 접근 패턴 */

/* 1. 커널 진입 시: GS를 커널 per-cpu 영역으로 교환 */
/*    SWAPGS → GS.base = 현재 CPU의 per-cpu 오프셋 */

/* 2. per-cpu 변수 접근 (GS 세그먼트 오버라이드) */
/*    movq %gs:offset, %rax  — per-cpu 변수 읽기 */

/* arch/x86/include/asm/percpu.h — 간략화 */
#define this_cpu_read_8(pcp) ({                           \
    u64 val;                                               \
    asm volatile("movq %%gs:%1, %0"                       \
                 : "=r"(val)                               \
                 : "m"(pcp));                               \
    val;                                                     \
})

/* 사용 예: 현재 CPU의 current task 가져오기 */
static inline struct task_struct *get_current(void)
{
    return this_cpu_read_8(current_task);
    /* 컴파일 결과: movq %gs:current_task, %rax */
}

/* 3. 커널 복귀 시: SWAPGS로 GS를 사용자 공간 값으로 복원 */
/*    SWAPGS → GS.base = 사용자 프로세스의 GS (TLS 등) */

LOCK CMPXCHG — 커널 atomic_cmpxchg

/* arch/x86/include/asm/cmpxchg.h — 간략화 */
static inline u64 __cmpxchg(volatile void *ptr, u64 old, u64 new)
{
    u64 prev;
    asm volatile(LOCK_PREFIX "cmpxchgq %2, %1"
                 : "=a"(prev), "+m"(*(volatile u64 *)ptr)
                 : "r"(new), "0"(old)
                 : "memory");
    return prev;
}

INVLPG — TLB 무효화

/* 단일 페이지 TLB 엔트리 무효화 */
static inline void __invlpg(unsigned long addr)
{
    asm volatile("invlpg (%0)" :: "r"(addr) : "memory");
}

WRMSR/RDMSR — MSR 접근

static inline void wrmsr(u32 msr, u32 low, u32 high)
{
    asm volatile("wrmsr"
                 :: "c"(msr), "a"(low), "d"(high)
                 : "memory");
}

명령어 인코딩

x86_64 명령어는 가변 길이로, 최대 15바이트까지 가능합니다. 레거시 접두사, REX, VEX, EVEX 네 가지 인코딩 체계가 있습니다.

인코딩 실전 예제

실제 명령어가 어떻게 바이트로 인코딩되는지 두 가지 예제를 통해 살펴봅니다.

최근 아키텍처 확장 (v6.14+)

Intel APX — Advanced Performance Extensions (v6.16+)

커널 6.16에서 Intel APX(Advanced Performance Extensions) 지원이 추가되었습니다. APX는 x86-64의 주요 한계를 해소하는 ISA 확장으로, 다음과 같은 핵심 기능을 제공합니다:

4096 CPU 코어 지원 (v6.14+)

커널 6.14에서 x86_64의 최대 CPU 코어 수 제한이 2048에서 4096으로 확장되었습니다 (CONFIG_NR_CPUS 최댓값 증가). 이는 AMD EPYC/Intel Xeon의 고코어 서버와 멀티소켓 시스템의 확장성을 지원합니다.

시스템 레지스터 심화

x86-64의 시스템 레지스터는 CPU 모드 전환, 페이징, 디버깅, 성능 모니터링 등 커널 동작의 핵심을 제어합니다. Control Register(CR0-CR4), Debug Register(DR0-DR7), MSR(Model-Specific Register)의 비트 필드를 정확히 이해해야 커널 초기화 코드와 예외 처리를 분석할 수 있습니다.

디버그 레지스터 (DR0-DR7)

/* DR7 비트 필드 */
/* bit 0,2,4,6 (L0-L3): 로컬 BP 활성화 */
/* bit 1,3,5,7 (G0-G3): 글로벌 BP 활성화 */
/* bit 16-17 (R/W0): DR0 조건 (00=실행, 01=쓰기, 10=I/O, 11=읽기/쓰기) */
/* bit 18-19 (LEN0): DR0 길이 (00=1B, 01=2B, 10=8B, 11=4B) */
/* bit 20-23: DR1 조건/길이, bit 24-27: DR2, bit 28-31: DR3 */

/* 커널 hw_breakpoint 사용 예 */
/* perf_event_create_kernel_counter() → arch_install_hw_breakpoint() */
/* → set_debugreg(addr, 0)  // DR0에 주소 설정 */
/* → set_debugreg(ctrl, 7)  // DR7에 조건 설정 */

성능 모니터링 카운터 (PMC)

/* PERFEVTSELx 비트 필드 */
/* bit 0-7   : EventSelect (이벤트 코드) */
/* bit 8-15  : UMask (이벤트 세분류) */
/* bit 16    : USR (유저 모드 카운트) */
/* bit 17    : OS (커널 모드 카운트) */
/* bit 20    : INT (오버플로 시 인터럽트/NMI) */
/* bit 22    : EN (카운터 활성화) */
/* bit 23    : INV (조건 반전) */
/* bit 24-31 : CMASK (카운트 마스크) */

/* 커널 perf 서브시스템 사용 흐름 */
/* perf_event_open() → x86_pmu_hw_config() */
/* → wrmsrl(MSR_P6_EVNTSEL0, config) → wrmsrl(MSR_P6_PERFCTR0, 0) */
/* 카운터 오버플로 → NMI → intel_pmu_handle_irq() → 샘플 저장 */

가상화 확장 (VMX) 레지스터

SIMD/벡터 확장 심화

x86-64의 SIMD 확장은 SSE → AVX → AVX-512 → AMX로 발전해왔습니다. 커널은 암호화(AES-NI), 체크섬(CRC32c), RAID(XOR/P+Q), 문자열 연산에서 SIMD를 활용합니다. 각 세대의 레지스터 폭, 명령어 형식, 커널 사용 패턴을 이해해야 합니다.

관련 문서