MIPS 명령어셋 레퍼런스

MIPS 아키텍처의 명령어를 GAS 문법 기준으로 종합 정리합니다. 전통 RISC 설계 철학과 고정 32-bit 명령어, 32개 범용 레지스터와 HI/LO 특수 레지스터, 지연 슬롯 메커니즘, MIPS32/64 Release 2와 Release 6의 차이, R/I/J 3가지 인코딩 타입, 데이터 전송·산술·논리·분기·스택·시스템·원자적·MSA SIMD 명령어 카테고리 표, 인코딩 다이어그램, 커널 핵심 명령어(SYSCALL, ERET, LL/SC, MFC0/MTC0, TLBWI) 심화까지 Linux 커널 개발에 필요한 MIPS ISA 전체를 다룹니다.

아키텍처 개요

MIPS(Microprocessor without Interlocked Pipelined Stages)는 1981년 Stanford에서 John Hennessy가 설계한 RISC 아키텍처입니다. MIPS Computer Systems(1984) → SGI(1992) → Imagination Technologies(2012) → Wave Computing(2018) → MIPS(2021)를 거쳤습니다.

MIPS 클래식 5단계 파이프라인

MIPS 가상 주소 공간 (32-bit)

레지스터 셋

범용 레지스터 ($0-$31)

특수 레지스터

CP0 (Coprocessor 0) 레지스터 — 주요

CP0 Status 레지스터 비트 필드 ($12)

CP0 Cause 레지스터 비트 필드 ($13)

MIPS64 n64 ABI 차이

주소 지정 모드

MIPS는 매우 제한적인 주소 모드를 사용합니다: 베이스 + 16-bit 부호 확장 오프셋만 지원합니다.

    beq     $t0, $t1, target       /* $t0 == $t1이면 target으로 분기 */
    addiu   $v0, $v0, 1            /* ← 지연 슬롯: 항상 실행됨! */
    /* 여기는 분기하지 않았을 때만 실행 */
    ...
target:
    /* $v0는 이미 +1된 상태 (지연 슬롯이 실행되었으므로) */

    .set    noreorder
    beq     $t0, $zero, done
    addiu   $v0, $v0, 1            /* 유용한 명령어를 지연 슬롯에 배치 */
    .set    reorder

데이터 전송 명령어

/* R2: 비정렬 32-bit 로드 (LWL/LWR 패턴) */
/* $a0에 비정렬 주소가 있다고 가정 (예: 0x10003) */
/* Big-Endian 기준 */
    lwl     $t0, 0($a0)            /* 주소의 워드 좌측 바이트들 로드 */
    lwr     $t0, 3($a0)            /* 주소의 워드 우측 바이트들 로드 */
    /* 이제 $t0에 4바이트가 올바르게 로드됨 */

/* R2: 비정렬 32-bit 저장 (SWL/SWR 패턴) */
    swl     $t0, 0($a0)            /* 워드 좌측 바이트들 저장 */
    swr     $t0, 3($a0)            /* 워드 우측 바이트들 저장 */

/* R6: 단순화됨 — LW/SW가 비정렬 지원 */
    lw      $t0, 0($a0)            /* R6에서는 비정렬이어도 정상 동작 */

산술 명령어

/* R2: 곱셈 패턴 — result = $a0 * $a1 */
    mult    $a0, $a1               /* HI:LO = $a0 * $a1 */
    mflo    $v0                    /* $v0 = 결과 하위 32-bit (곱의 하위) */
    mfhi    $v1                    /* $v1 = 결과 상위 32-bit */

/* R2: 나눗셈 패턴 — quotient = $a0 / $a1, remainder = $a0 % $a1 */
    div     $zero, $a0, $a1        /* LO=몫, HI=나머지 */
    mflo    $v0                    /* $v0 = 몫 */
    mfhi    $v1                    /* $v1 = 나머지 */

/* R6: 곱셈 — 결과가 GPR에 직접 */
    mul     $v0, $a0, $a1          /* $v0 = ($a0 * $a1) 하위 32-bit */
    muh     $v1, $a0, $a1          /* $v1 = ($a0 * $a1) 상위 32-bit */

/* R6: 나눗셈 — 몫과 나머지 각각 별도 명령어 */
    div     $v0, $a0, $a1          /* $v0 = $a0 / $a1 (몫) */
    mod     $v1, $a0, $a1          /* $v1 = $a0 % $a1 (나머지) */

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

비교/분기 명령어

/* 비최적화: NOP 낭비 */
    addiu   $v0, $v0, 1
    bne     $v0, $a0, loop
    nop                             /* 낭비되는 사이클 */

/* 최적화: 유용한 명령어를 지연 슬롯에 이동 */
    bne     $v0, $a0, loop
    addiu   $v0, $v0, 1            /* 지연 슬롯에서 실행 — 1 사이클 절약 */

/* 함수 호출 최적화: 인자 설정을 지연 슬롯에 */
    jal     some_func
    move    $a0, $s0               /* 지연 슬롯: 인자를 $a0에 설정 */

스택/함수 호출 명령어

MIPS에는 PUSH/POP 명령어가 없습니다. addiu $sp와 sw/lw로 수동 관리합니다.

/* 함수 프롤로그/에필로그 (o32 ABI) */
my_func:
    addiu   $sp, $sp, -32         /* 스택 프레임 할당 */
    sw      $ra, 28($sp)           /* 복귀 주소 저장 */
    sw      $fp, 24($sp)           /* 프레임 포인터 저장 */
    move    $fp, $sp               /* 프레임 포인터 설정 */
    /* ... 함수 본문 ... */
    move    $sp, $fp               /* 스택 복원 */
    lw      $fp, 24($sp)           /* 프레임 포인터 복원 */
    lw      $ra, 28($sp)           /* 복귀 주소 복원 */
    addiu   $sp, $sp, 32           /* 스택 프레임 해제 */
    jr      $ra                    /* 복귀 (지연 슬롯) */
    nop                             /* 지연 슬롯 */

시스템/특권 명령어

예외 벡터 레이아웃

/* R2+: 원자적 인터럽트 비활성화 */
    di      $t0                    /* $t0 = 이전 Status, IE←0 */
    ehb                            /* Execution Hazard Barrier */
    /* ... 크리티컬 섹션 ... */
    ei                             /* IE←1, 인터럽트 재활성화 */

/* R1 (구형): MFC0/MTC0 패턴 — 경쟁 조건 가능 */
    mfc0    $t0, $12               /* Status 읽기 */
    ori     $t1, $t0, 1            /* IE 비트 세트 */
    mtc0    $t1, $12               /* Status 쓰기 — 여기서 인터럽트 경쟁 가능 */

원자적/동기화 명령어

LL/SC CAS 루프 패턴

/* compare_and_swap(addr=$a0, expected=$a1, desired=$a2) → old in $v0 */
cas_loop:
    ll      $v0, 0($a0)           /* Load Linked */
    bne     $v0, $a1, 1f          /* expected와 다르면 실패 */
    nop                             /* 지연 슬롯 */
    move    $t0, $a2               /* desired 값 복사 */
    sc      $t0, 0($a0)           /* Store Conditional */
    beqz    $t0, cas_loop          /* SC 실패(0) 시 재시도 */
    nop                             /* 지연 슬롯 */
1:
    jr      $ra                    /* $v0에 이전 값 반환 */
    nop                             /* 지연 슬롯 */

LL/SC 스핀락 구현

/* arch_spin_lock(lock=$a0) — 간소화된 MIPS 스핀락 */
arch_spin_lock:
    .set    noreorder
1:
    ll      $t0, 0($a0)           /* 락 값 Load Linked */
    bnez    $t0, 1b               /* 이미 잠겨있으면 재시도 */
    li      $t1, 1                 /* 지연 슬롯: 잠금 값 준비 */
    sc      $t1, 0($a0)           /* Store Conditional (잠금 시도) */
    beqz    $t1, 1b               /* SC 실패 시 재시도 */
    nop                             /* 지연 슬롯 */
    sync                            /* 메모리 배리어 (acquire) */
    jr      $ra
    nop
    .set    reorder

/* arch_spin_unlock(lock=$a0) */
arch_spin_unlock:
    .set    noreorder
    sync                            /* 메모리 배리어 (release) */
    sw      $zero, 0($a0)          /* 락 해제 (일반 store로 충분) */
    jr      $ra
    nop
    .set    reorder

MSA (MIPS SIMD Architecture) 명령어

MSA는 128-bit 벡터 레지스터 $w0-$w31을 사용하며, 바이트(.b)/하프워드(.h)/워드(.w)/더블워드(.d) 요소 타입을 지원합니다.

커널 핵심 명령어 심화

예외 핸들러 디스패치 (Cause.ExcCode)

MIPS에서 General Exception 벡터(0x80000180)에 도달하면, 커널은 Cause.ExcCode 필드를 확인하여 적절한 핸들러로 분기합니다. Linux 커널의 arch/mips/kernel/genex.S에서 이 디스패치 로직을 구현합니다.

/* General Exception 벡터 진입점 (0x80000180) */
/* arch/mips/kernel/genex.S — except_vec3_generic */
except_vec3_generic:
    .set    noreorder
    mfc0    $k1, $13               /* Cause 레지스터 읽기 */
    andi    $k1, $k1, 0x7c         /* ExcCode 필드 추출 (비트 6:2) */
    /* ExcCode * 4 = exception_handlers 테이블 인덱스 (이미 <<2 위치) */
    la      $k0, exception_handlers
    addu    $k0, $k0, $k1          /* 테이블 + ExcCode*4 */
    lw      $k0, 0($k0)            /* 핸들러 주소 로드 */
    jr      $k0                    /* 핸들러로 점프 */
    nop                             /* 지연 슬롯 */
    .set    reorder

/* exception_handlers 테이블 (ExcCode별 핸들러 포인터) */
/*  0: handle_int       — 인터럽트 */
/*  1: handle_tlbm      — TLB Modified */
/*  2: handle_tlbl      — TLB Load 미스 */
/*  3: handle_tlbs      — TLB Store 미스 */
/*  4: handle_adel      — Address Error (Load) */
/*  5: handle_ades      — Address Error (Store) */
/*  8: handle_sys       — System Call */
/*  9: handle_bp        — Breakpoint */
/* 10: handle_ri        — Reserved Instruction */
/* 11: handle_cpu       — Coprocessor Unusable */
/* 13: handle_ov        — Overflow */

예외 진입/복귀 전체 시퀀스

/* 예외 진입 — 레지스터 저장 (arch/mips/kernel/genex.S SAVE_ALL 매크로) */
exception_entry:
    .set    noreorder
    .set    noat
    mfc0    $k0, $12               /* Status 레지스터 */
    mfc0    $k1, $14               /* EPC (복귀 주소) */

    /* 커널 스택 포인터 확보 */
    addiu   $sp, $sp, -320         /* pt_regs 구조체 크기만큼 할당 */

    /* 모든 범용 레지스터 저장 */
    sw      $zero, 0($sp)          /* $0 (형식상) */
    sw      $at, 4($sp)            /* $at */
    sw      $v0, 8($sp)            /* $v0 */
    sw      $v1, 12($sp)           /* $v1 */
    sw      $a0, 16($sp)           /* $a0-$a3 */
    sw      $a1, 20($sp)
    sw      $a2, 24($sp)
    sw      $a3, 28($sp)
    /* ... $t0-$t7, $s0-$s7, $t8-$t9 저장 생략 ... */
    sw      $gp, 112($sp)          /* $gp */
    sw      $fp, 120($sp)          /* $fp */
    sw      $ra, 124($sp)          /* $ra */

    /* CP0 레지스터 저장 */
    sw      $k0, 128($sp)          /* Status */
    sw      $k1, 132($sp)          /* EPC */
    mfc0    $t0, $13
    sw      $t0, 136($sp)          /* Cause */
    mfc0    $t0, $8
    sw      $t0, 140($sp)          /* BadVAddr */
    /* HI/LO도 저장 (R2의 경우) */
    mfhi    $t0
    sw      $t0, 144($sp)          /* HI */
    mflo    $t0
    sw      $t0, 148($sp)          /* LO */
    .set    at
    .set    reorder

/* 예외 복귀 — 레지스터 복원 (RESTORE_ALL 매크로) */
exception_exit:
    .set    noreorder
    .set    noat
    /* HI/LO 복원 */
    lw      $t0, 144($sp)
    mthi    $t0
    lw      $t0, 148($sp)
    mtlo    $t0
    /* CP0 복원 */
    lw      $t0, 128($sp)          /* Status */
    lw      $t1, 132($sp)          /* EPC */
    mtc0    $t0, $12               /* Status 복원 */
    mtc0    $t1, $14               /* EPC 복원 */
    /* 모든 범용 레지스터 복원 */
    lw      $ra, 124($sp)
    lw      $fp, 120($sp)
    lw      $gp, 112($sp)
    /* ... $s0-$s7, $t0-$t9, $a0-$a3, $v0-$v1 복원 ... */
    lw      $at, 4($sp)
    addiu   $sp, $sp, 320          /* 스택 프레임 해제 */
    eret                            /* PC←EPC, EXL←0 (원자적) */
    .set    at
    .set    reorder

SYSCALL 진입 경로

/* 유저 공간: SYSCALL 명령어 → 예외 벡터로 트랩 */
/* 예외 벡터: 0x80000180 (General Exception, BEV=0) */
/* Cause.ExcCode = 8 (Syscall) */

/* arch/mips/kernel/scall32-o32.S 핵심 경로 */
handle_sys:
    lw      $v0, PT_R2($sp)        /* syscall 번호 ($v0) */
    sll     $v0, $v0, 2            /* × 4 (테이블 인덱스) */
    la      $t1, sys_call_table
    addu    $t1, $t1, $v0
    lw      $t0, 0($t1)            /* 시스콜 핸들러 주소 */
    jalr    $t0                    /* 핸들러 호출 */
    nop                             /* 지연 슬롯 */

ERET — 예외 복귀

/* Status.EXL=1 → EPC에서 복귀, EXL=0으로 복원 */
    mfc0    $k0, $14               /* EPC 읽기 */
    mfc0    $k1, $12               /* Status 읽기 */
    /* Status 복원 처리 ... */
    mtc0    $k1, $12               /* Status 쓰기 */
    eret                            /* PC←EPC, EXL←0 */

TLB 조작 패턴

/* TLB Refill 핸들러 (0x80000000) */
tlb_refill:
    mfc0    $k0, $4                /* Context 레지스터 */
    lw      $k1, 0($k0)            /* PTE 로드 */
    mtc0    $k1, $2                /* EntryLo0 */
    lw      $k1, 4($k0)            /* 다음 PTE */
    mtc0    $k1, $3                /* EntryLo1 */
    tlbwr                           /* Random 인덱스로 TLB 쓰기 */
    eret

CACHE 명령어

/* D-cache writeback + invalidate */
static inline void flush_dcache_line(unsigned long addr)
{
    asm volatile(
        "cache %0, 0(%1)"
        :: "i"(Hit_Writeback_Inv_D), "r"(addr));
}

명령어 인코딩

MIPS는 3가지 기본 인코딩 타입을 사용합니다: R(레지스터), I(즉시값), J(점프).

인코딩 실제 예: addu $t0, $t1, $t2

R6 Compact Branch 인코딩

TLB 관리 심화

MIPS는 소프트웨어 관리 TLB를 사용합니다. TLB 미스 시 CPU가 자동으로 페이지 테이블을 검색하는 x86/ARM64와 달리, MIPS는 TLB Refill 예외를 발생시키고 커널이 직접 TLB 엔트리를 채워야 합니다. 이를 위해 EntryHi, EntryLo0/1, PageMask, Index CP0 레지스터와 TLBWR/TLBWI/TLBR/TLBP 명령어를 사용합니다.

/* arch/mips/mm/tlbex.c — TLB Refill 핸들러 (빌드 시 동적 생성) */
/* 가장 성능 크리티컬한 커널 코드 — ~20 명령어로 최적화 */

/* 개념적 TLB Refill 핸들러 (R2/R6 공통 원리) */
tlb_refill_handler:
    /* 1. k0/k1은 예외에서 자유롭게 사용 가능 (커널 전용) */
    mfc0    k1, C0_CONTEXT       /* Context.PTEBase + BadVPN2 → PTE 주소 */
    lw      k0, 0(k1)            /* EntryLo0 = PTE[even] */
    lw      k1, 4(k1)            /* EntryLo1 = PTE[odd] */
    mtc0    k0, C0_ENTRYLO0      /* EntryLo0 설정 */
    mtc0    k1, C0_ENTRYLO1      /* EntryLo1 설정 */
    ehb                           /* Execution Hazard Barrier */
    tlbwr                         /* Random 위치에 TLB 쓰기 */
    eret                          /* 예외 복귀 (EPC로 점프) */

/* TLB 프로빙과 무효화 */
    mtc0    t0, C0_ENTRYHI       /* 검색할 VPN2|ASID 설정 */
    ehb
    tlbp                          /* TLB 검색 → Index에 결과 */
    ehb
    mfc0    t1, C0_INDEX          /* Index.P(bit31)=1이면 미스 */
    bltz    t1, not_found         /* 음수 → TLB에 없음 */
    /* Index >= 0 → 해당 위치에 무효 엔트리 쓰기 */
    mtc0    zero, C0_ENTRYLO0
    mtc0    zero, C0_ENTRYLO1
    ehb
    tlbwi                         /* Index 위치에 쓰기 (무효화) */

CP0 레지스터 비트 필드 상세

CP0 (Coprocessor 0)는 MIPS의 시스템 제어 레지스터 집합입니다. x86의 CR0-CR4/MSR, ARM64의 시스템 레지스터에 대응합니다. 커널은 mfc0/mtc0로 CP0에 접근하며, 예외 처리·TLB 관리·캐시 설정·인터럽트 제어의 핵심입니다.

관련 문서