RISC-V 명령어셋 레퍼런스

RISC-V 아키텍처의 명령어를 GAS 문법 기준으로 종합 정리합니다. 모듈형 ISA 설계 철학과 RV64I 기본 명령어셋, M(곱셈)/A(원자적)/F(단정도)/D(배정도)/C(압축)/V(벡터) 표준 확장, 32개 범용 레지스터와 CSR 체계, R/I/S/B/U/J 6가지 인코딩 타입, 데이터 전송·산술·논리·분기·스택·시스템·원자적·벡터 명령어 카테고리 표, 인코딩 다이어그램, 커널 핵심 명령어(ECALL, SRET, LR/SC, SFENCE.VMA) 심화까지 Linux 커널 개발에 필요한 RISC-V ISA 전체를 다룹니다.

아키텍처 개요

RISC-V는 UC Berkeley에서 2010년 시작한 오픈소스 RISC ISA입니다. 모듈형 설계로 기본 정수 ISA(RV32I/RV64I)에 표준 확장을 선택적으로 추가합니다.

모듈형 ISA 확장 구조

RISC-V의 핵심 설계 철학은 모듈형(modular) ISA입니다. RV64I 기본 정수 명령어셋을 중심으로 필요한 확장을 선택적으로 추가하여 SoC 설계자가 목적에 맞는 최적의 프로세서를 구성할 수 있습니다. 표준 확장 조합인 RV64G(= RV64IMAFD)는 범용 운영체제 실행에 필요한 최소 세트이며, Linux 커널은 이를 기본으로 요구합니다.

레지스터 셋

범용 레지스터 (x0-x31)

레지스터 파일 시각적 맵

32개 범용 레지스터를 용도별로 그룹화하고 Caller/Callee-saved 여부를 색상으로 구분한 시각적 맵입니다. 함수 호출 시 어떤 레지스터를 저장해야 하는지 파악하는 데 유용합니다.

CSR (Control and Status Registers) — 주요

CSR 주소 공간 레이아웃

RISC-V CSR 주소는 12-bit (0x000-0xFFF)로 인코딩됩니다. 상위 비트들이 접근 권한과 특권 레벨을 결정하므로, CSR 번호만으로도 접근 가능 여부를 하드웨어가 즉시 판단할 수 있습니다.

부동소수점 / 벡터 레지스터

주소 지정 모드

RISC-V는 매우 단순한 주소 모드를 사용합니다: 베이스 레지스터 + 12-bit 부호 확장 즉시값 오프셋만 지원합니다.

데이터 전송 명령어

LUI + ADDI로 32-bit 상수 로딩

RISC-V 명령어의 즉시값은 최대 12-bit이므로, 더 큰 상수를 레지스터에 로드하려면 LUI(상위 20-bit)와 ADDI(하위 12-bit)를 조합해야 합니다. 여기서 주의할 점은 ADDI가 부호 확장을 수행하므로, 하위 12-bit의 MSB가 1이면 LUI에 1을 더해 보정해야 한다는 것입니다.

/* 예: a0 = 0x12345678 로드 */
/* 상위 20-bit: 0x12345, 하위 12-bit: 0x678 */
/* 0x678의 MSB=0이므로 보정 불필요 */
    lui     a0, 0x12345           /* a0 = 0x12345000 */
    addi    a0, a0, 0x678         /* a0 = 0x12345678 */

/* 예: a0 = 0x12345800 로드 */
/* 하위 12-bit: 0x800, MSB=1 → ADDI가 -2048로 부호 확장 */
/* 보정: LUI에 1을 더함 (0x12345 + 1 = 0x12346) */
    lui     a0, 0x12346           /* a0 = 0x12346000 */
    addi    a0, a0, -0x800        /* a0 = 0x12346000 - 0x800 = 0x12345800 */

/* 어셈블러 의사 명령어 li가 이를 자동 처리: */
    li      a0, 0x12345800        /* 어셈블러가 위 보정을 자동 수행 */

산술 명령어

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

비교/분기 명령어

주요 의사 명령어(pseudo-instruction) 확장 표

RISC-V 어셈블러는 프로그래머 편의를 위해 다양한 의사 명령어를 제공합니다. 아래 표는 자주 사용되는 의사 명령어와 그것이 실제로 확장되는 기본 명령어를 보여줍니다.

스택/함수 호출 명령어

RISC-V에는 PUSH/POP이 없습니다. addi sp와 sd/ld로 수동 관리합니다.

/* 함수 프롤로그/에필로그 */
my_func:
    addi    sp, sp, -32           /* 스택 프레임 할당 */
    sd      ra, 24(sp)             /* 복귀 주소 저장 */
    sd      s0, 16(sp)             /* 프레임 포인터 저장 */
    addi    s0, sp, 32             /* 프레임 포인터 설정 */
    /* ... 함수 본문 ... */
    ld      s0, 16(sp)             /* 프레임 포인터 복원 */
    ld      ra, 24(sp)             /* 복귀 주소 복원 */
    addi    sp, sp, 32             /* 스택 프레임 해제 */
    ret                             /* jalr zero, 0(ra) */

시스템/특권 명령어

트랩 위임(Trap Delegation) 메커니즘

기본적으로 모든 트랩은 M-mode로 전달되지만, medeleg(예외 위임)와 mideleg(인터럽트 위임) CSR을 설정하면 특정 트랩을 S-mode에서 직접 처리할 수 있습니다. Linux 부팅 시 SBI(OpenSBI 등)가 이 위임을 설정합니다.

SFENCE.VMA 변형 (TLB 무효화)

SFENCE.VMA는 인자에 따라 무효화 범위가 달라집니다. 불필요하게 넓은 범위를 플러시하면 성능 저하가 발생하므로, 커널은 가능한 한 좁은 범위의 무효화를 사용합니다.

Sv39 페이지 테이블 워크 구조

Linux RISC-V는 주로 Sv39 (39-bit 가상 주소, 3단계 페이지 테이블)를 사용합니다. satp CSR이 루트 페이지 테이블의 물리 주소와 ASID를 저장합니다.

원자적/동기화 명령어 (A 확장)

LR/SC CAS 루프 패턴

/* compare_and_swap(addr=a0, expected=a1, desired=a2) → old in a0 */
cas_loop:
    lr.d.aq  a3, (a0)             /* Load-Reserved + Acquire */
    bne      a3, a1, 1f           /* expected와 다르면 실패 */
    sc.d.rl  a4, a2, (a0)          /* Store-Conditional + Release */
    bnez     a4, cas_loop          /* SC 실패 시 재시도 */
1:
    mv       a0, a3               /* 이전 값 반환 */
    ret

AMOSWAP 기반 스핀락 구현

/* 스핀락: lock=a0 (0=해제, 1=잠김) */
spin_lock:
    li       t0, 1
1:
    amoswap.w.aq t1, t0, (a0)      /* t1 = old, *a0 = 1 (acquire) */
    bnez     t1, 1b               /* 이미 잠겨있으면 재시도 */
    ret                             /* 획득 성공, acquire 의미론 보장 */

spin_unlock:
    amoswap.w.rl zero, zero, (a0)  /* *a0 = 0, release 의미론 */
    ret

/* 최적화된 버전: test-and-set with backoff */
spin_lock_optimized:
    li       t0, 1
1:  lw       t1, (a0)              /* 일반 로드로 먼저 확인 (캐시 친화적) */
    bnez     t1, 1b               /* 잠겨있으면 바쁜 대기 */
    amoswap.w.aq t1, t0, (a0)      /* 해제된 것 같으면 시도 */
    bnez     t1, 1b               /* 실패 시 다시 대기 */
    ret

벡터 명령어 (V 확장)

RISC-V V 확장은 가변 길이 벡터(VLEN: 구현 의존, 128-bit 이상)를 지원합니다. vsetvli로 벡터 길이와 요소 타입을 동적으로 설정합니다.

LMUL (Length MULtiplier) 개념

LMUL은 하나의 벡터 연산이 사용하는 레지스터 그룹의 크기를 결정합니다. LMUL=1이면 단일 레지스터, LMUL=2이면 연속 2개 레지스터를 하나의 벡터로 묶어 더 긴 벡터를 처리합니다. 반대로 LMUL=1/2, 1/4, 1/8 분수값도 가능하여 좁은 요소를 효율적으로 처리합니다.

vsetvli와 VLEN/SEW/LMUL 관계

vsetvli 명령어는 벡터 연산 전에 반드시 호출하여 SEW(Selected Element Width)와 LMUL을 설정합니다. 하드웨어는 요청된 벡터 길이(AVL)와 VLMAX를 비교하여 실제 처리할 요소 수(VL)를 결정합니다.

/* vsetvli rd, rs1, vtypei */
/* rd: 실제 설정된 벡터 길이 (VL) */
/* rs1: 요청하는 벡터 길이 (AVL). rs1=zero이면 VL 변경 없이 vtype만 변경 */
/* vtypei: SEW, LMUL, ta(tail agnostic), ma(mask agnostic) 인코딩 */

/* 예: SEW=8, LMUL=1, tail-agnostic, mask-agnostic */
    vsetvli  t0, a2, e8, m1, ta, ma  /* t0 = min(a2, VLMAX) */

/* SEW 옵션: e8(8-bit), e16(16-bit), e32(32-bit), e64(64-bit) */
/* LMUL 옵션: mf8(1/8), mf4(1/4), mf2(1/2), m1(1), m2(2), m4(4), m8(8) */
/* 꼬리 정책: ta(tail agnostic) / tu(tail undisturbed) */
/* 마스크 정책: ma(mask agnostic) / mu(mask undisturbed) */

벡터화된 memcpy 예제

RISC-V V 확장의 강력한 점은 vsetvli 스트립마이닝 루프입니다. 하드웨어가 한 번에 처리할 수 있는 최대 요소 수를 자동으로 결정하므로, VLEN에 독립적인 코드를 작성할 수 있습니다.

/* void *memcpy_v(void *dst, const void *src, size_t n) */
/* a0=dst, a1=src, a2=n (바이트 수) */
memcpy_v:
    mv       a3, a0                /* 반환용 dst 주소 보존 */
.Lloop:
    vsetvli  t0, a2, e8, m8, ta, ma /* t0 = 이번에 복사할 바이트 수 */
                                      /* SEW=8(바이트), LMUL=8(최대 처리량) */
    vle8.v   v0, (a1)              /* src에서 t0 바이트 로드 */
    vse8.v   v0, (a0)              /* dst에 t0 바이트 저장 */
    add      a1, a1, t0            /* src += t0 */
    add      a0, a0, t0            /* dst += t0 */
    sub      a2, a2, t0            /* n -= t0 */
    bnez     a2, .Lloop            /* 남은 바이트가 있으면 반복 */
    mv       a0, a3                /* dst 주소 반환 */
    ret

커널 핵심 명령어 심화

ECALL — SBI 호출 패턴

/* SBI 호출: a7=EID, a6=FID, a0-a5=인자 */
/* 반환: a0=error, a1=value */
    li      a7, 0x10              /* SBI_EXT_BASE */
    li      a6, 0                  /* SBI_BASE_GET_SPEC_VERSION */
    ecall                            /* S-mode → M-mode 트랩 */
    /* a0=error code, a1=spec version */

트랩 핸들러 진입

/* stvec → _handle_exception */
_handle_exception:
    csrrw   tp, sscratch, tp       /* tp ↔ sscratch 교환 */
    /* tp는 이제 커널 task_struct, sscratch는 유저 tp */
    sd      sp, TASK_TI_USER_SP(tp)    /* 유저 sp 저장 */
    ld      sp, TASK_TI_KERNEL_SP(tp)  /* 커널 스택으로 전환 */
    addi    sp, sp, -PT_SIZE       /* pt_regs 공간 할당 */
    /* 레지스터 저장... */
    sd      ra, PT_RA(sp)
    sd      gp, PT_GP(sp)
    /* ... a0-a7, s0-s11, t0-t6 저장 ... */
    csrr    a0, scause             /* 트랩 원인 */
    csrr    a1, sepc               /* 예외 PC */
    csrr    a2, stval              /* 트랩 값 */

SRET — 트랩 복귀

    /* 레지스터 복원 후 */
    csrw    sepc, a0               /* 복귀 PC 설정 */
    csrw    sstatus, a1            /* 상태 복원 */
    csrrw   tp, sscratch, tp       /* tp ↔ sscratch 복원 */
    sret                            /* PC←sepc, 모드←sstatus.SPP */

SFENCE.VMA — TLB 무효화

/* arch/riscv/include/asm/tlbflush.h */
static inline void local_flush_tlb_page(unsigned long addr)
{
    asm volatile("sfence.vma %0" :: "r"(addr) : "memory");
}
static inline void local_flush_tlb_all(void)
{
    asm volatile("sfence.vma" ::: "memory");
}

SBI (Supervisor Binary Interface) 확장 표

SBI는 S-mode(커널)가 M-mode(펌웨어)의 서비스를 호출하는 표준 인터페이스입니다. RISC-V에서 ARM의 PSCI나 x86의 BIOS 서비스에 해당하며, OpenSBI가 대표적 구현체입니다. 호출 규약은 a7=EID(Extension ID), a6=FID(Function ID), a0-a5=인자, 반환은 a0=error, a1=value입니다.

완전한 컨텍스트 스위치 예제

Linux 커널의 __switch_to()는 프로세스 간 컨텍스트를 전환합니다. RISC-V에서는 callee-saved 레지스터(s0-s11, sp, ra)만 저장/복원하면 됩니다 (caller-saved는 C 호출 규약에 의해 호출자가 이미 처리).

/* arch/riscv/kernel/entry.S — __switch_to(prev, next) */
/* a0 = prev->thread (struct thread_struct *) */
/* a1 = next->thread (struct thread_struct *) */
__switch_to:
    /* === prev 컨텍스트 저장 === */
    sd      ra,  THREAD_RA(a0)     /* 복귀 주소 */
    sd      sp,  THREAD_SP(a0)     /* 스택 포인터 */
    sd      s0,  THREAD_S0(a0)     /* callee-saved s0 (fp) */
    sd      s1,  THREAD_S1(a0)
    sd      s2,  THREAD_S2(a0)
    sd      s3,  THREAD_S3(a0)
    sd      s4,  THREAD_S4(a0)
    sd      s5,  THREAD_S5(a0)
    sd      s6,  THREAD_S6(a0)
    sd      s7,  THREAD_S7(a0)
    sd      s8,  THREAD_S8(a0)
    sd      s9,  THREAD_S9(a0)
    sd      s10, THREAD_S10(a0)
    sd      s11, THREAD_S11(a0)

    /* === next 컨텍스트 복원 === */
    ld      ra,  THREAD_RA(a1)     /* next의 복귀 주소 */
    ld      sp,  THREAD_SP(a1)     /* next의 스택 */
    ld      s0,  THREAD_S0(a1)
    ld      s1,  THREAD_S1(a1)
    ld      s2,  THREAD_S2(a1)
    ld      s3,  THREAD_S3(a1)
    ld      s4,  THREAD_S4(a1)
    ld      s5,  THREAD_S5(a1)
    ld      s6,  THREAD_S6(a1)
    ld      s7,  THREAD_S7(a1)
    ld      s8,  THREAD_S8(a1)
    ld      s9,  THREAD_S9(a1)
    ld      s10, THREAD_S10(a1)
    ld      s11, THREAD_S11(a1)

    /* tp(스레드 포인터)를 next의 task_struct로 전환 */
    mv      tp, a2                 /* a2 = next task_struct */

    ret                             /* ra가 next의 복귀 주소이므로 next 프로세스로 점프 */

SFENCE.VMA 커널 사용 패턴

/* 1. 단일 페이지 매핑 변경 후 */
static inline void local_flush_tlb_page(unsigned long addr)
{
    /* 해당 가상 주소의 TLB 엔트리만 무효화 */
    asm volatile("sfence.vma %0" :: "r"(addr) : "memory");
}

/* 2. 프로세스 전체 주소 공간 무효화 (특정 ASID) */
static inline void local_flush_tlb_all_asid(unsigned long asid)
{
    asm volatile("sfence.vma zero, %0" :: "r"(asid) : "memory");
}

/* 3. 전체 TLB 플러시 (satp 변경 후) */
static inline void local_flush_tlb_all(void)
{
    asm volatile("sfence.vma" ::: "memory");
}

/* 4. 원격 TLB 무효화 (SBI를 통해 다른 hart에 IPI 전송) */
void flush_tlb_range(struct vm_area_struct *vma,
                     unsigned long start, unsigned long end)
{
    /* SBI RFENCE 확장 사용 */
    /* 로컬 hart: sfence.vma */
    /* 원격 hart: sbi_remote_sfence_vma() IPI */
}

명령어 인코딩

RISC-V는 6가지 기본 인코딩 타입을 사용합니다. 모든 타입에서 opcode는 [6:0], rd는 [11:7]에 위치하여 디코딩을 단순화합니다.

인코딩 예제: add a0, a1, a2

add a0, a1, a2는 R-type 인코딩입니다. 각 필드가 어떻게 매핑되는지 구체적으로 보겠습니다.

/* add a0, a1, a2 의 32-bit 인코딩 */
/*  funct7  | rs2   | rs1   | f3  | rd    | opcode  */
/*  0000000 | 01100 | 01011 | 000 | 01010 | 0110011 */
/*  = 0x00C58533                                    */

/* 검증: objdump 출력 */
/*   0: 00c58533    add    a0, a1, a2              */

/* 비교: sub a0, a1, a2 → funct7만 다름 (0100000)  */
/*  0100000 | 01100 | 01011 | 000 | 01010 | 0110011 */
/*  = 0x40C58533                                    */

SBI (Supervisor Binary Interface)

SBI는 S-mode(리눅스 커널)가 M-mode(펌웨어, OpenSBI)에 서비스를 요청하는 표준 인터페이스입니다. x86의 BIOS/UEFI Runtime Services, ARM의 PSCI(Power State Coordination Interface)에 대응하며, RISC-V 커널이 하드웨어 추상화 없이 이식성을 확보하는 핵심 메커니즘입니다.

/* arch/riscv/kernel/sbi.c — SBI 호출 구현 */
struct sbiret sbi_ecall(int ext, int fid,
                       unsigned long arg0, unsigned long arg1,
                       unsigned long arg2, unsigned long arg3,
                       unsigned long arg4, unsigned long arg5)
{
    struct sbiret ret;
    register unsigned long a0 asm("a0") = arg0;
    register unsigned long a1 asm("a1") = arg1;
    register unsigned long a2 asm("a2") = arg2;
    register unsigned long a3 asm("a3") = arg3;
    register unsigned long a4 asm("a4") = arg4;
    register unsigned long a5 asm("a5") = arg5;
    register unsigned long a6 asm("a6") = fid;
    register unsigned long a7 asm("a7") = ext;

    asm volatile ("ecall"
        : "+r" (a0), "+r" (a1)
        : "r" (a2), "r" (a3), "r" (a4), "r" (a5),
          "r" (a6), "r" (a7)
        : "memory");

    ret.error = a0;  /* SBI_SUCCESS=0, SBI_ERR_FAILED=-1, ... */
    ret.value = a1;
    return ret;
}

/* SMP 부팅: HSM 확장으로 다른 hart 시작 */
/* sbi_hart_start(hartid, start_addr, opaque) */
/* → M-mode에서 해당 hart를 start_addr로 점프시킴 */
/* → secondary_start_sbi() → 커널 진입 */

가상 메모리 심화 (Sv39/Sv48/Sv57)

RISC-V의 가상 메모리는 satp CSR로 제어되며, Sv39(39비트 VA, 3레벨), Sv48(48비트 VA, 4레벨), Sv57(57비트 VA, 5레벨) 모드를 지원합니다. 리눅스 커널은 Sv48을 기본으로 사용하며, Sv57은 선택적으로 활성화됩니다.

관련 문서