최근 수정 시각 : 2023-10-08 10:06:12

x86/명령어 목록


파일:상위 문서 아이콘.svg   상위 문서: x86
명령어 집합
CISC AMD64●x86● · M68K · 68xx · Z80 · 8080 · MOS 65xx · VAX
RISC AArch64 ARM · RISC-V● · MIPS● · DEC Alpha · POWER PowerPC · CELL-BE
LoongArch · OpenRISC · PA-RISC · SPARC · Blackfin · SuperH · AVR32 AVR
VLIW
EPIC 		E2K · IA-64 · Crusoe

<rowcolor=#fff> x86 · AMD64 확장 명령어 집합
인텔 주도 확장 명령어
범용 APX
SIMD MMX · SSE SSE2 · SSE3 · SSSE3 · SSE4.1 · SSE4.2 · AVX AVX2 · AVX-512 · AVX10 · AMX
AVX-512: F · CD · DQ · BW · VL · IFMA · VBMI · VBMI2 · VNNI · VAES · GFNI · BITALG
AVX[1]: AVX-VNNI · AVX-IFMA
AVX10: AVX10.1 · AVX10.2
비트 조작 BMI1 · BMI2 · ADX
보안 및 암호 AES-NI · CLMUL · RDRAND · RDSEED · SHA · MPX · SGX · TME · MKTME
가상화 및 기타 VT-x(VMX) · SMX · TSX
AMD 주도 확장 명령어
SIMD 및 비트 연산 3DNow! · F16C · XOP · FMA FMA4 · FMA3
비트 조작 ABM
보안 및 암호 SME
가상화 및 기타 AMD-V
[1] 512-bit EVEX 인코딩된 AVX-512 명령어의 256-bit VEX 인코딩 버전

1. 개요
1.1. 약어 설명1.2. 표기법
1.2.1. 인텔 문법과 AT&T 문법1.2.2. 16진수 및 2진수
1.3. 명령어 인코딩
1.3.1. x86 접두사1.3.2. Mod R/M1.3.3. SIB
1.4. 레지스터
1.4.1. 범용 레지스터1.4.2. 세그멘트 레지스터1.4.3. 플래그 레지스터
1.4.3.1. 조건 코드
1.5. x87 FPU
1.5.1. 레지스터1.5.2. Control Word1.5.3. Tag Word1.5.4. 명령어 인코딩
1.6. MMX
1.6.1. 레지스터1.6.2. Tag Word1.6.3. 인코딩
2. 명령어 목록
2.1. x86 명령어
2.1.1. x86 사칙연산 명령어
2.1.1.1. ADD
2.1.1.1.1. INC
2.1.1.2. ADC2.1.1.3. SUB
2.1.1.3.1. DEC
2.1.1.4. SBB2.1.1.5. NEG2.1.1.6. CMP2.1.1.7. MUL2.1.1.8. IMUL2.1.1.9. DIV2.1.1.10. IDIV
2.1.2. x86 논리연산 명령어
2.1.2.1. AND2.1.2.2. OR2.1.2.3. XOR2.1.2.4. NOT2.1.2.5. TEST
2.1.3. x86 Shift 명령어
2.1.3.1. ROL2.1.3.2. ROR2.1.3.3. RCL2.1.3.4. RCR2.1.3.5. SHL / SAL2.1.3.6. SHR2.1.3.7. SAR2.1.3.8. SHLD2.1.3.9. SHRD
2.1.4. x86 메모리 관련 명령어
2.1.4.1. MOV
2.1.4.1.1. MOV Sreg / MOV (seg:offset)
2.1.4.2. XCHG2.1.4.3. CMPXCHG
2.1.4.3.1. CMPXCHG8B
2.1.4.4. PUSH
2.1.4.4.1. PUSH CS/SS/DS/ES/FS/GS2.1.4.4.2. PUSHA/PUSHAD2.1.4.4.3. PUSHF/PUSHFD
2.1.4.5. POP
2.1.4.5.1. POP SS/DS/ES/FS/GS2.1.4.5.2. POPA/POPAD2.1.4.5.3. POPF/POPFD
2.1.4.6. CBW/CWDE2.1.4.7. CWD/CDQ2.1.4.8. MOVZX2.1.4.9. MOVSX2.1.4.10. LEA2.1.4.11. ENTER2.1.4.12. LEAVE2.1.4.13. BOUND2.1.4.14. BSWAP2.1.4.15. XADD2.1.4.16. XLAT2.1.4.17. LAHF2.1.4.18. SAHF2.1.4.19. LDS/LES/LFS/LGS/LSS
2.1.5. x86 제어/조건부 명령어
2.1.5.1. JMP2.1.5.2. Jcc
2.1.5.2.1. JCXZ/JECXZ
2.1.5.3. CALL2.1.5.4. RET(RETN/RETF)2.1.5.5. LOOP/LOOPcc2.1.5.6. INT n/INTO/INT3/INT12.1.5.7. IRET/IRETD2.1.5.8. CMOVcc2.1.5.9. SETcc
2.1.6. x86 프로세서 제어 명령어
2.1.6.1. LOCK prefix2.1.6.2. Segment prefix2.1.6.3. ESC2.1.6.4. WAIT2.1.6.5. HLT
2.1.7. x86 플래그 제어 및 기타 명령어
2.1.7.1. CLC2.1.7.2. CMC2.1.7.3. STC2.1.7.4. CLD2.1.7.5. STD2.1.7.6. CLI2.1.7.7. STI2.1.7.8. CPUID
2.1.8. x86 시스템 명령어
2.1.8.1. LLDT2.1.8.2. SLDT2.1.8.3. LTR2.1.8.4. STR2.1.8.5. LGDT2.1.8.6. SGDT2.1.8.7. LIDT2.1.8.8. SIDT2.1.8.9. LMSW2.1.8.10. SMSW2.1.8.11. VERR2.1.8.12. VERW2.1.8.13. ARPL2.1.8.14. LAR2.1.8.15. LSL2.1.8.16. CLTS2.1.8.17. INVD2.1.8.18. WBINVD2.1.8.19. INVLPG2.1.8.20. RSM2.1.8.21. RDMSR2.1.8.22. WRMSR2.1.8.23. RDPMC2.1.8.24. RDTSC2.1.8.25. SYSENTER2.1.8.26. SYSEXIT
2.1.9. x86 IO 명령어
2.1.9.1. IN2.1.9.2. OUT
2.1.10. 비트 조작 명령어
2.1.10.1. BT2.1.10.2. BTS2.1.10.3. BTR2.1.10.4. BTC2.1.10.5. BSF2.1.10.6. BSR
2.1.11. 문자열 조작 명령어
2.1.11.1. REP prefix2.1.11.2. MOVS/MOVSB/MOVSW/MOVSD2.1.11.3. CMPS/CMPSB/CMPSW/CMPSD2.1.11.4. LODS/LODSB/LODSW/LODSD2.1.11.5. SCAS/SCASB/SCASW/SCASD2.1.11.6. STOS/STOSB/STOSW/STOSD2.1.11.7. INS/INSB/INSW/INSD2.1.11.8. OUTS/OUTSB/OUTSW/OUTSD
2.1.12. BCD 명령어
2.1.12.1. AAA2.1.12.2. AAS2.1.12.3. AAM2.1.12.4. AAD2.1.12.5. DAA2.1.12.6. DAS
2.2. x87 FPU 명령어
2.2.1. x87 메모리 명령어
2.2.1.1. FLD2.2.1.2. FST2.2.1.3. FSTP2.2.1.4. FXCH2.2.1.5. FCMOVcc2.2.1.6. FILD2.2.1.7. FIST2.2.1.8. FISTP2.2.1.9. FISTTP2.2.1.10. FBLD2.2.1.11. FBSTP2.2.1.12. FLD1/FLDL2T/FLDL2E/FLDPI/FLDLG2/FLDLN2/FLDZ
2.2.2. x87 사칙연산 명령어
2.2.2.1. FADD2.2.2.2. FADDP2.2.2.3. FSUB2.2.2.4. FSUBP2.2.2.5. FSUBR2.2.2.6. FSUBRP2.2.2.7. FMUL2.2.2.8. FMULP2.2.2.9. FDIV2.2.2.10. FDIVP2.2.2.11. FDIVR2.2.2.12. FDIVRP2.2.2.13. FCHS2.2.2.14. FABS2.2.2.15. FSQRT2.2.2.16. FPREM2.2.2.17. FPREM12.2.2.18. FRNDINT2.2.2.19. FXTRACT2.2.2.20. FIADD2.2.2.21. FISUB2.2.2.22. FISUBR2.2.2.23. FIMUL2.2.2.24. FIDIV2.2.2.25. FIDIVR
2.2.3. x87 비교 명령어
2.2.3.1. FCOM/FCOMP/FCOMPP2.2.3.2. FUCOM/FUCOMP/FUCOMPP2.2.3.3. FICOM/FICOMP2.2.3.4. FCOMI/FCOMIP/FUCOMI/FUCOMIP2.2.3.5. FTST2.2.3.6. FXAM
2.2.4. x87 특수 함수 명령어
2.2.4.1. FSIN2.2.4.2. FCOS2.2.4.3. FSINCOS2.2.4.4. FPTAN2.2.4.5. FPATAN2.2.4.6. FYL2X2.2.4.7. FYL2XP12.2.4.8. F2XM12.2.4.9. FSCALE
2.2.5. x87 FPU 제어 명령어
2.2.5.1. FINCSTP2.2.5.2. FDECSTP2.2.5.3. FFREE2.2.5.4. FINIT/FNINIT2.2.5.5. FCLEX/FNCLEX2.2.5.6. FSTCW/FNSTCW2.2.5.7. FLDCW2.2.5.8. FSTENV/FNSTENV2.2.5.9. FLDENV2.2.5.10. FSAVE/FNSAVE2.2.5.11. FRSTOR2.2.5.12. FSTSW/FNSTSW2.2.5.13. FNOP2.2.5.14. FXSAVE2.2.5.15. FXRSTOR
3. SIMD 명령어 목록
3.1. MMX 확장
3.1.1. MMX 메모리 및 변환 명령어
3.1.1.1. MOVD3.1.1.2. MOVQ3.1.1.3. PACKSSWB3.1.1.4. PACKSSDW3.1.1.5. PACKUSWB3.1.1.6. PUNPCKHBW3.1.1.7. PUNPCKHWD3.1.1.8. PUNPCKHDQ3.1.1.9. PUNPCKLBW3.1.1.10. PUNPCKLWD3.1.1.11. PUNPCKLDQ
3.1.2. MMX Packed Arithmetic 명령어
3.1.2.1. PADDB/PADDW/PADDD3.1.2.2. PADDSB/PADDSW3.1.2.3. PADDUSB/PADDUSW3.1.2.4. PSUBB/PSUBW/PSUBD3.1.2.5. PSUBSB/PSUBSW3.1.2.6. PSUBUSB/PSUBUSW3.1.2.7. PMULHW3.1.2.8. PMULLW3.1.2.9. PMADDWD
3.1.3. MMX Comparison 명령어
3.1.3.1. PCMPEQB/PCMPEQW/PCMPEQD3.1.3.2. PCMPGTB/PCMPGTW/PCMPGTD
3.1.4. MMX Bitwise 명령어
3.1.4.1. PAND3.1.4.2. PANDN3.1.4.3. POR3.1.4.4. PXOR
3.1.5. MMX Shift/Rotate 명령어
3.1.5.1. PSLLW/PSLLD/PSLLQ3.1.5.2. PSRLW/PSRLD/PSRLQ3.1.5.3. PSRAW/PSRAD
3.1.6. MMX 제어 명령어
3.1.6.1. EMMS
3.2. SSE 확장
3.2.1. SSE 메모리 관련 명령어
3.2.1.1. MOVUPS3.2.1.2. MOVSS3.2.1.3. MOVLPS3.2.1.4. MOVHLPS3.2.1.5. MOVHPS3.2.1.6. MOVLHPS3.2.1.7. MOVAPS
3.2.2. SSE 변환 명령어3.2.3. SSE Packed Arithmetic 명령어3.2.4. SSE Comparison 명령어3.2.5. SSE Bitwise 명령어3.2.6. SSE Shuffle/Unpack 명령어3.2.7. 기타 SSE 명령어
3.3. SSE2 확장
3.3.1. SSE2 메모리 관련 명령어3.3.2. SSE2 변환 명령어3.3.3. SSE2 Packed Arithmetic 명령어3.3.4. SSE2 Comparison 명령어3.3.5. SSE2 Bitwise 명령어3.3.6. SSE2 Shuffle/Unpack 명령어3.3.7. 기타 SSE2 명령어
3.4. SSE3 확장

[clearfix]

1. 개요

x86 아키텍처의 명령어 목록. AMD64 확장에 대해서는 다루지 않는다.

1.1. 약어 설명

  • r : 레지스터
  • m : 메모리
  • imm : 상수 (ib: 8-bit, iw: 16-bit, id: 32-bit)

1.2. 표기법

1.2.1. 인텔 문법과 AT&T 문법

문법 Intel AT&T
파라미터 순서 instr dest, src
mov eax, 42
destination을 좌측, source를 우측에 표기한다. 		instr src, dest
movl $42, %eax
source를 좌측, destination을 우측에 표기한다.
파라미터 표기 add eax, 1
어셈블러가 자동으로 타입을 파악한다. 		addl $1, %eax
immediate는 $, register는 % 기호를 앞에 붙여 표기한다.
피연산자 크기 mov eax, 1234
레지스터명으로부터 자동으로 결정된다. 		movl $1234, %eax
크기를 나타내는 접미사를 사용하여 명시한다.
메모리 주소 표기 lea esi, [ebx+eax*8+4] lea 4(%ebx,%eax,8), %esi
x86 어셈블리는 크게 인텔 문법과 AT&T 문법으로 나뉜다. 인텔 문법은 Windows 환경에서 널리 쓰이며(예: Visual C++), AT&T 문법은 Unix 환경에서 널리 쓰인다(예: GCC). 여기서는 인텔 문법을 기준으로 설명한다.

1.2.2. 16진수 및 2진수

* 16진수 숫자는 뒤에 h를 붙여서 표기한다.
* 2진수 숫자는 뒤에 b를 붙여서 표기한다.

1.3. 명령어 인코딩

x86 ISA는 다음과 같은 가변길이 인코딩을 사용한다.
(Prefixes) [Opcode] (Mod R/M) (SIB) (Displacement) (Immediate)
  • (Prefixes): 4가지 그룹으로 구분되며 각 그룹에 속하는 접두사(각 1 바이트)가 선택적으로 붙을 수 있다.
  • [Opcode]: 1-3 바이트 길이로 수행하고자 하는 명령어의 종류를 지정한다. 이때 일부 SSE 명령어의 경우 prefix를 사용하는 것과 동일하게 인코딩되어 있으나(예: CVTDQ2PD: F3 0F E6h) 이는 opcode의 일부로, prefix로 취급되지 않는다.
  • (Mod R/M): 피연산자의 형태(레지스터/메모리) 및 메모리 주소 형식을 지정한다. 명령어에 따라 선택적으로 요구한다.
  • (SIB): [base + index * scale (+ disp.)] 형식으로 계산되는 메모리의 base 레지스터, index 레지스터 및 scale을 지정한다. 명령어에 따라 선택적으로 요구한다.
  • (Displacement): 1/2/4 바이트 크기의 displacement로 명령어에 따라 선택적으로 요구한다.
  • (Immediate): 1/2/4 바이트 크기의 immediate(명령어에 인코딩되는 숫자) 값으로 명령어에 따라 선택적으로 요구한다.

1.3.1. x86 접두사

x86 접두사는 다음과 같이 4가지 그룹으로 나뉜다.
  • Group 1: Lock and repeat prefixes
    • 메모리 접근의 독점 또는 명령어의 반복 수행을 지정하는 명령어이다.
    • F0h(0xF0): LOCK 접두사. 명령어가 수행되는 동안 해당 명령어가 접근하는 주소에 대한 lock을 수행한다.
    • F2h(0xF2), F3h(0xF3): 반복 접두사. 문자열을 다루는 명령어 앞에 붙어 해당 명령어가 특정 조건에 따라 반복적으로 수행되도록 하는 접두사이다. 이에 해당하지 않는 명령어에 사용하는 것은 정의되지 않은 동작이나, repz ret과 같이 사용되는 경우가 존재한다.
  • Group 2: Segment override prefixes
    • 메모리 세그멘트를 지정하는 접두사이다.
    • 2Eh(0x2E): CS segment override
    • 36h(0x36): SS segment override
    • 3Eh(0x3E): DS segment override
    • 26h(0x26): ES segment override
    • 64h(0x64): FS segment override
    • 65h(0x65): GS segment override
  • Group 3: Operand-size override prefix
    • 66h(0x66): 명령어의 피연산자의 크기가 기본값과 다름을 나타내는 접두사이다.
  • Group 4: Address-size override prefix
    • 67h(0x67): 명령어가 사용하는 주소의 크기가 기본값과 다름을 나타내는 접두사이다.

이때 접두사는 각 Group에서 최대 1개씩 붙을 수 있으며 임의의 순서로 배치될 수 있으나[1], 어셈블러에서는 Group 2 - Group 4 - Group 3 - Group 1 순서로 배치하는 것으로 보인다.
0:  55                      push   ebp
1:  89 e5                   mov    ebp,esp
3:  57                      push   edi
4:  8b 5d 08                mov    ebx,DWORD PTR [ebp+0x8]
7:  8b 7d 0a                mov    edi,DWORD PTR [ebp+0xa]
a:  26 67 66 8b 41 02       mov    ax,WORD PTR es:[bx+di+0x2]
10: 8b 5d 0c                mov    ebx,DWORD PTR [ebp+0xc]
13: 8b 7d 0e                mov    edi,DWORD PTR [ebp+0xe]
16: 26 67 66 f0 0f b1 01    lock cmpxchg WORD PTR es:[bx+di],ax
1d: 8b 5d 08                mov    ebx,DWORD PTR [ebp+0x8]
20: 8b 7d 0a                mov    edi,DWORD PTR [ebp+0xa]
23: 26 67 66 89 41 02       mov    WORD PTR es:[bx+di+0x2],ax
29: 5f                      pop    edi
2a: c9                      leave
2b: c3                      ret

[1] "For each instruction, one prefix may be used from each of these groups and be placed in any order. Using redundant prefixes (more than one prefix from a group) is reserved and may cause unpredictable behavior.", IA-32 Intel® Architecture Software Developer’s Manual Volume 2: Instruction Set Reference(Order Number 245471-012), 2003.


====# x86 Opcode #====
1-byte 0 1 2 3 4 5 6 7 8 9 A B C D E F
00 ADD [2] [3] OR [4] *[5]
r/m += r r += r/m a += imm r/m |= r r |= r/m a |= imm
10 ADC [6] [7] SBB [8] [9]
r/m += r r += r/m a += imm r/m -= r r -= r/m a -= imm
20 AND [10] DAA[i] SUB [12] DAS[i]
r/m &= r r &= r/m a &= imm r/m -= r r -= r/m a -= imm
30 XOR [14] AAA[i] CMP [16] AAS[i]
r/m ^= r r ^= r/m a ^= imm r/m - r r - r/m a - imm
40 INC[a] DEC[a]
EAX ECX EDX EBX ESP EBP ESI EDI EAX ECX EDX EBX ESP EBP ESI EDI
50 PUSH POP
EAX ECX EDX EBX ESP EBP ESI EDI EAX ECX EDX EBX ESP EBP ESI EDI
60 PUSHAD[i] POPAD[i] BOUND[i] ARPL segment
override 		size
override 		PUSH IMUL PUSH IMUL INS OUTS
FS GS [23] [24]
70 Jcc
JO JNO JB
JC
JNAE 		JAE
JNB
JNC 		JE
JZ 		JNE
JNZ 		JBE
JNA 		JA
JNBE 		JS JNS JP
JPE 		JNP
JPO 		JL
JNGE 		JGE
JNL 		JLE
JNG 		JG
JNLE
80 ALU (imm)[25] TEST XCHG MOV MOV LEA MOV POP
r/m = r[26] r = r/m[27] [28] [29]
90 NOP[30] XCHG EAX CWD CDQ CALLF WAIT PUSHFD POPFD SAHF LAHF
ECX EDX EBX ESP EBP ESI EDI
A0 MOV EAX MOVS CMPS TEST STOS LODS SCAS
a = (seg:offset) (seg:offset) = a
B0 MOV (imm)
r8 = imm8 r16(r32) = imm16(imm32)
C0 SHIFT imm RETN[r] LES LDS MOV imm ENTER LEAVE RETF[r] INT3 INT imm INTO IRETD
[33]
D0 SHIFT 1 SHIFT CL AAM[i] AAD[i] SALC XLAT FPU[36]
[37] [38]
E0 LOOPcc LOOP JECXZ IN imm OUT imm CALL JMP JMPF JMP short IN DX OUT DX
LOOPNZ LOOPZ
F0 LOCK INT1
ICEBP 		REPcc HLT CMC [39] CLC STC CLI STI CLD STD [40]
[41] REPNE REPE
[2] PUSH ES[3] POP ES[4] PUSH CS[5] 8086/8088에서는 POP CS 명령어로 동작하였으나, 80186부터는 사용되지 않으며 이후 2-byte 이상 opcode를 나타내는 escape로 사용된다.[6] PUSH SS[7] POP SS[8] PUSH DS[9] POP DS[10] ES segment override prefix[i] AMD64 확장의 64-bit 모드에서는 지원되지 않는다.[12] CS segment override prefix[i] [14] SS segment override prefix[i] [16] DS segment override prefix[i] [a] AMD64 확장에서는 REX 접두사로 사용되는 opcode이다.[a] [i] [i] [i] [23] operand size override[24] address size override[25] (ADD/OR/ADC/SBB/AND/SUB/XOR/CMP) imm; 80+sw로 인코딩된다. Opcode 82h는 80h와 동일하게 동작하는 것으로 보이나, 매뉴얼에는 생략되어 있다.)[26] RISC의 store 명령어에 대응한다.[27] RISC의 load 명령어에 대응한다.[28] mov r/m16,Sreg, segment register의 값을 memory에 저장한다.[29] mov Sreg,r/m16, memory의 값을 segment register에 불러온다.[30] xchg eax,eax로 인코딩된다. Intel 64 매뉴얼 또는 AMD 매뉴얼의 경우 operand size prefix를 붙인 66 90h(xchg ax,ax) 또한 NOP으로 기재되어 있으니 IA-32 매뉴얼에는 등장하지 않는다.[r] 어셈블리 상에서는 RETN/RETF 구분 없이 ret으로 사용한다.[r] [33] (ROL/ROR/RCL/RCR/SHL/SHR/SAR) imm[i] [i] [36] x87 명령어를 나타내는 escape이다.[37] (ROL/ROR/RCL/RCR/SHL/SHR/SAR) 1[38] (ROL/ROR/RCL/RCR/SHL/SHR/SAR) CL[39] (TEST/NOT/NEG/(I)MUL/(I)DIV)[40] (INC/DEC/CALL/JMP/PUSH) (Mod R/M)[41] prefix

=====# 1-byte opcode 목록 #=====
=====# 2-byte 이상 opcode #=====
명령어 확장 Opcode
i286
SLDT i286 0F 00 /0
STR i286 0F 00 /1
LLDT i286 0F 00 /2
LTR i286 0F 00 /3
VERR i286 0F 00 /4
VERW i286 0F 00 /5
SGDT i286 0F 01 /0
SIDT i286 0F 01 /1
LGDT i286 0F 01 /2
LIDT i286 0F 01 /3
SMSW i286 0F 01 /4
LMSW i286 0F 01 /6
LAR i286 0F 02
LSL i286 0F 03
CLTS i286 0F 06
i386
SETcc i386 0F 90+cc
PUSH FS i386 0F A0
POP FS i386 0F A1
PUSH GS i386 0F A8
POP GS i386 0F A9
BT i386 0F A3
0F BA /4
BTS i386 0F AB
0F BA /5
BTR i386 0F B3
0F BA /6
BTC i386 0F BB
0F BA /7
BSF i386 0F BC
BSR i386 0F BD
SHLD i386 0F A4..A5
SHRD i386 0F AC..AD
IMUL i386 0F AF
LSS i386 0F B2
LFS i386 0F B4
LGS i386 0F B5
MOVZX i386 0F B6..B7
MOVSX i386 0F BE..BF
i486
INVLPG i486 0F 01 /7
INVD i486 0F 08
WBINVD i486 0F 09
CMPXCHG i486 0F B0..B1
XADD i486 0F C0..C1
BSWAP i486 0F C8+r
i586
WRMSR i586 0F 30
RDTSC i586 0F 31
RDMSR i586 0F 32
CPUID i586 0F A2
RSM[42] i586 0F AA
CMPXCHG8B i586 0F C7
i686
UD2[43] i686 0F 0B
NOP i686 0F 1F /0
RDPMC i686 0F 33
SYSENTER i686 0F 34
SYSEXIT i686 0F 35
CMOVcc i686 0F 40+cc
[42] i386SL에서 도입되었으나, 전체 모델에 적용된 시점은 486 후기 및 Pentium이다.[43] Raise invalid opcode exception

1.3.2. Mod R/M

필드 mod reg/opcode r/m
비트 수 2-bit 3-bit 3-bit
Mod R/M 바이트는 3개의 필드로 구성되어 있다.
  • mod
    • operand의 모드를 지정한다. r/m 필드와 결합되어 사용된다.
    • 32-bit addressing에서 r/m 필드의 값이 100(esp)인 경우 SIB를 사용한다.
    • 00: (m) (레지스터/SIB) 또는 disp16/disp32 값에 해당하는 주소를 지정한다.[44]
    • 01: (m) (레지스터/SIB) 값에 disp8을 더한 주소를 지정한다.
    • 10: (m) (레지스터/SIB) 값에 disp16/disp32를 더한 주소를 지정한다.
    • 11: (r) 레지스터의 값을 operand로 사용한다.
  • reg/opcode
    • 레지스터 번호 또는 일부 명령어의 경우 opcode 정보를 담고 있다.
  • r/m
    • 레지스터 번호를 나타낸다.
[44] r/m 필드의 값이 101(ebp)인 경우 disp 값을 그대로 사용한다.

1.3.3. SIB

필드 scale index base
비트 수 2-bit 3-bit 3-bit
32-bit addressing에서 선택적으로 사용되는 바이트이다. [base + index * scale]에 해당하는 주소를 지정하는 데 사용된다.
  • scale
    • 00: 1 (byte)
    • 01: 2 (bytes)
    • 10: 4 (bytes)
    • 11: 8 (bytes)
  • Index
    • 해당하는 레지스터의 값을 사용한다. 단, 100(esp)인 경우 0으로 계산한다. (esp를 index에 사용할 수 없다.)
  • Base
    • 해당하는 레지스터의 값을 사용한다. 단, 101(ebp)인 경우 mod에 따라 다음의 값을 사용한다.
    • 00: [scaled index] + disp32
    • 01: [scaled index] + disp8 + [EBP]
    • 10: [scaled index] + disp32 + [EBP]

1.4. 레지스터

  • 범용 레지스터:
    • A: Accumulator, C: Count, D: Data, B: Base
    • SP: Stack Pointer, BP: Base Pointer
    • SI: Source Index, DI: Destination Index
  • 특수 레지스터:
    • 세그멘트 레지스터(CS/DS/SS/ES/FS/GS)
    • 플래그 레지스터(EFLAGS)
    • 명령어 포인터(EIP)
  • 접두사/접미사:
    • -L/H: 8비트 (L: 하위 8비트, H: 상위 8비트)
    • -X: 16비트/32비트
    • E-: 32비트

1.4.1. 범용 레지스터

번호 / 종류 0 1 2 3 4 5 6 7
8비트 정수 AL CL DL BL AH, SPL CH, BPL DH, SIL BH, DIL
16비트 정수 AX CX DX BX SP BP SI DI
32비트 정수 EAX ECX EDX EBX ESP EBP ESI EDI
80비트 x87 ST0 ST1 ST2 ST3 ST4 ST5 ST6 ST7
64비트 MMX[45] MM0 MM1 MM2 MM3 MM4 MM5 MM6 MM7
128비트 SSE XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7
[45] x87과 동시에 사용할 수 없다.

1.4.2. 세그멘트 레지스터

번호 레지스터 설명 비고
0 ES Extra Segment
1 CS Code Segment
2 SS Stack Segment
3 DS Data Segment
4 FS 80386에서 추가
5 GS 80386에서 추가

1.4.3. 플래그 레지스터

  • 상태 플래그
    • CF(0): Carry Flag
    • PF(2): Parity Flag
    • AF(4): Auxiliary Carry Flag
    • ZF(6): Zero Flag
    • SF(7): Sign Flag
  • 제어 플래그
    • DF(10): Direction Flag
  • 시스템 플래그
    • TF(8): Trap Flag
    • IF(9): Interrupt Enable Flag
    • OF(11): Overflow Flag
    • IOPL(12-13): I/O Privilege Level
    • NT(14): Nested Task
    • RF(16): Resume Flag
    • VM(17): Virtual-8086 Mode
    • AC(18): Alignment Check
    • VIF(19): Virtual Interrupt Flag
    • VIP(20): Virtual Interrupt Pending
    • ID(21): ID Flag
1.4.3.1. 조건 코드
조건 코드는 상태 플래그의 값에 따라 동작을 수행하는 데 사용되는 코드로, 총 16가지가 존재한다.
번호 cc 플래그 조건 설명
0000 O OF = 1 Overflow
0001 NO OF = 0 No Overflow
0010 B
NAE 		CF = 1 Below
Neither Above nor Equal 		DESTu < SRCu
0011 NB
AE 		CF = 0 Not Below
Above or Equal 		DESTu >= SRCu
0100 E
Z 		ZF = 1 Equal
Zero 		DEST == SRC
0101 NE
NZ 		ZF = 0 Not Equal
Not Zero 		DEST != SRC
0110 BE
NA 		(CF = 1) | (ZF = 1) Below or Equal
Not Above 		DESTu <= SRCu
0111 NBE
A 		(CF = 0) & (ZF = 0) Neither Below nor Equal
Above 		DESTu > SRCu
1000 S SF = 1 Sign
1001 NS SF = 0 Not Sign
1010 P
PE 		PF = 1 Parity
Parity Even
1011 NP
PO 		PF = 0 No Parity
Parity Odd
1100 L
NGE 		SF ^ OF = 1 Less
Neither Greater nor Eqaul 		DESTs < SRCs
1101 NL
GE 		SF ^ OF = 0 Not Less
Greater or Equal 		DESTs >= SRCs
1110 LE
NG 		(SF ^ OF | ZF) = 1 Less or Equal
Not Greater 		DESTs <= SRCs
1111 NLE
G 		(SF ^ OF | ZF) = 0 Neither Less nor Equal
Greater 		DESTs > SRCs

1.5. x87 FPU

1.5.1. 레지스터

x87은 8개의 80-bit 레지스터(R0-R7)를 스택처럼 사용한다. 레지스터는 각 레지스터의 번호가 아닌 스택 상의 상대적인 위치(ST(i))로 접근하고, 다수의 명령어에 ST(0)이 피연산자로 고정되어 있으므로 병렬적인 실행이 어렵다.

1.5.2. Control Word

16-bit x87 FPU control word는 x87 FPU의 작동을 제어한다. FINIT/FNINIT 또는 FSAVE/FNSAVE 명령어가 실행되는 경우 이 값은 037Fh로 초기화된다. (RC = 00b, PC = 11b, all floating-point exceptions are masked.)
  • (5-0) 마스크 비트: 비트가 설정되어 있는 경우 해당하는 예외의 발생을 막는다.
    • IM(0): Invalid Operation
    • DM(1): Denormal Operand
    • ZM(2): Zero Divide
    • OM(3): Overflow
    • UM(4): Underflow
    • PM(5): Precision
  • (12-8)
    • PC(9-8): Precision Control; 00b — Single Precision, 10b — Double Precision, 11b — Double Extended Precision.
    • RC(11-10): Rounding Control; 00b — Round to nearest (even), 01b — Round down(toward -inf), 10b — Round up(toward +inf), 11b — Round toward zero (Truncate).
    • X(12): Infinity Control

1.5.3. Tag Word

16-bit tag word는 x87 FPU의 8개 레지스터 각각의 내용을 나타낸다. (레지스터당 2-bit 태그)
  • 00 — Valid
  • 01 — Zero
  • 10 — Special: Invalid (NaN, unsupported), infinity, or denormal
  • 11 — Empty

1.5.4. 명령어 인코딩

인코딩 포맷 First Byte Second Byte
15-11 10 9 8 7-6 5 4 3 2-0
1 11011 opA 1 mod 1 opB r/m
2 11011 MF opA mod opB r/m
3 11011 d P opA 11 opB R ST(i)
4 11011 0 0 1 11 1 op
5 11011 0 1 1 11 1 op
  • MF: Memory Format; 00 — 32-bit real, 01 — 32-bit integer, 10 — 64-bit real, 11 — 16-bit integer
  • d: Destination; 0 — ST(0), 1 — ST(i)
  • P: Pop; 0 — Do not pop, 1 — Pop
  • R: Reverse; 0 — ST(0) op ST(i), 1 — ST(i) op ST(0)
  • R^d: 0 — Destination OP Source, 1 — Source OP Destination
0 1 R / d
ST(0) = ST(0) op ST(i) ST(0) = ST(i) op ST(0) 0
ST(i) = ST(0) op ST(i) ST(i) = ST(i) op ST(0) 1

=====# Format 1 #=====
opA opB 명령어 추가 시점 Mnemonic HEX 비고
00 00 FLDENV 8087 FLDENV m14byte D9 /4 32-bit 모드에서는 66h 접두사 필요
80387 FLDENV m28byte
00 01 FLDCW 8087 FLDCW m2byte D9 /5
00 10 FNSTENV 8087 FNSTENV m14byte D9 /6 32-bit 모드에서는 66h 접두사 필요
80387 FNSTENV m28byte [46]
00 11 FNSTCW 8087 FNSTCW m2byte D9 /7 [47]
01 01 FLD 8087 FLD m80fp DB /5
01 11 FSTP 8087 FSTP m80fp DB /7
10 00 FRSTOR 8087 FRSTOR m94byte DD /4 32-bit 모드에서는 66h 접두사 필요
80387 FRSTOR m108byte
10 10 FNSAVE 8087 FNSAVE m94byte DD /6 32-bit 모드에서는 66h 접두사 필요
80387 FNSAVE m108byte [48]
10 11 FNSTSW 8087 FNSTSW m2byte DD /7 [49]
11 00 FBLD 8087 FBLD m80bcd DF /4
11 01 FILD 8087 FILD m64int DF /5
11 10 FBSTP 8087 FBSTP m80bcd DF /6
11 11 FISTP 8087 FISTP m64int DF /7
[46] FSTENV 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.[47] FSTCW 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.[48] FSAVE 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.[49] FSTSW 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.

=====# Format 2 #=====
opA opB 명령어 추가 시점 MF Mnemonic HEX 비고
0 000 FADD 8087 00 FADD m32fp D8 /0
10 FADD m64fp DC /0
0 000 FIADD 8087 01 FIADD m32int DA /0
11 FIADD m16int DE /0
0 001 FMUL 8087 00 FMUL m32fp D8 /1
10 FMUL m64fp DC /1
0 001 FIMUL 8087 01 FIMUL m32int DA /1
11 FIMUL m16int DE /1
0 010 FCOM 8087 00 FCOM m32fp D8 /2
10 FCOM m64fp DC /2
0 010 FICOM 8087 01 FICOM m32int DA /2
11 FICOM m16int DE /2
0 011 FCOMP 8087 00 FCOMP m32fp D8 /3
10 FCOMP m64fp DC /3
0 011 FICOMP 8087 01 FICOMP m32int DA /3
11 FICOMP m16int DE /3
0 100 FSUB 8087 00 FSUB m32fp D8 /4
10 FSUB m64fp DC /4
0 100 FISUB 8087 01 FISUB m32int DA /4
11 FISUB m16int DE /4
0 101 FSUBR 8087 00 FSUBR m32fp D8 /5
10 FSUBR m64fp DC /5
0 101 FISUBR 8087 01 FISUBR m32int DA /5
11 FISUBR m16int DE /5
0 110 FDIV 8087 00 FDIV m32fp D8 /6
10 FDIV m64fp DC /6
0 110 FIDIV 8087 01 FIDIV m32int DA /6
11 FIDIV m16int DE /6
0 111 FDIVR 8087 00 FDIVR m32fp D8 /7
10 FDIVR m64fp DC /7
0 111 FIDIVR 8087 01 FIDIVR m32int DA /7
11 FIDIVR m16int DE /7
1 000 FLD 8087 00 FLD m32fp D9 /0
10 FLD m64fp DD /0
1 000 FILD 8087 01 FILD m32int DB /0
11 FILD m16int DF /0
1 001 FISTTP SSE3 10 FISTTP m64int DD /1
01 FISTTP m32int DB /1
11 FISTTP m16int DF /1
1 010 FST 8087 00 FST m32fp D9 /2
10 FST m64fp DD /2
1 010 FIST 8087 01 FIST m32int DB /2
11 FIST m16int DF /2
1 011 FSTP 8087 00 FSTP m32fp D9 /3
10 FSTP m64fp DD /3
1 011 FISTP 8087 01 FISTP m32int DB /3
11 FISTP m16int DF /3

=====# Format 3 #=====
opA opB R P 명령어 추가 시점 d Mnemonic HEX 비고
0 00 0 0 FADD 8087 0 FADD st(0),st(i) D8 C0+i
1 FADD st(i),st(0) DC C0+i
0 00 0 1 FADDP 8087 1 FADDP st(i),st(0) DE C0+i
FADDP DE C1
0 00 1 0 FMUL 8087 0 FMUL st(0),st(i) D8 C8+i
1 FMUL st(i),st(0) DC C8+i
0 00 1 1 FMULP 8087 1 FMULP st(i),st(0) DE C8+i
FMULP DE C9
0 01 0 0 FCOM 8087 * FCOM st(i) D8 D0+i
DC D0+i
FCOM D8 D1
DC D1
0 01 0 1 FCOMP 8087 1 FCOMP st(i) DE D0+i
FCOMP DE D1
0 01 1 0 FCOMP 8087 * FCOMP st(i) D8 D8+i
DC D8+i
FCOMP D8 D9
DC D9
0 01 1 1 FCOMPP 8087 1 FCOMPP DE D9
0 10 0 0 FSUB 8087 0 FSUB st(0),st(i) D8 E0+i
1 1 FSUB st(i),st(0) DC E8+i
0 10 1 1 FSUBP 8087 1 FSUBP st(i),st(0) DE E8+i
FSUBP DE E9
0 10 1 0 FSUBR 8087 0 FSUBR st(0),st(i) D8 E8+i
0 1 FSUBR st(i),st(0) DC E0+i
0 10 0 1 FSUBRP 8087 1 FSUBRP st(i),st(0) DE E0+i
FSUBRP DE E1
0 11 0 0 FDIV 8087 0 FDIV st(0),st(i) D8 F0+i
1 1 FDIV st(i),st(0) DC F8+i
0 11 1 1 FDIVP 8087 1 FDIVP st(i),st(0) DE F8+i
FDIVP DE F9
0 11 1 0 FDIVR 8087 0 FDIVR st(0),st(i) D8 F8+i
0 1 FDIVR st(i),st(0) DC F0+i
0 11 0 1 FDIVRP 8087 1 FDIVRP st(i),st(0) DE F0+i
FDIVRP DE F1
1 00 0 0 FLD 8087 0 FLD st(i) D9 C0+i
1 00 0 0 FFREE 8087 1 FFREE st(i) DD C0+i
1 00 0 1 FFREEP 8087 1 FFREEP st(i) DF C0+i
1 00 1 0 FXCH 8087 0 FXCH st(i) D9 C8+i
1 DD C8+i
1 1 DF C8+i
1 01 0 0 FNOP 8087 0 FNOP D9 D0
1 01 0 0 FST 8087 1 FST st(i) DD D0+i
1 01 0 1 FSTP 8087 1 FSTP st(i) DF D0+i
1 01 1 0 FSTPNCE 8087 0 FSTPNCE st(i) D9 D8+i
1 01 1 0 FSTP 8087 1 FSTP st(i) DD D8+i
1 10 0 0 FUCOM 80387 1 FUCOM st(i) DD E0+i
FUCOM DD E1
1 10 0 1 FNSTSW 80287 1 FNSTSW AX DF E0 [50]
1 10 1 0 FUCOMP 80387 1 FUCOMP st(i) DD E8+i
FUCOMP DD E9
1 10 1 1 FUCOMPP 80387 0 FUCOMPP DA E9
[50] FSTSW 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.
opA opB R P 명령어 추가 시점 d Mnemonic HEX 비고
0 00 0 1 FCMOVcc Pentium Pro 0 FCMOVB st(0),st(i) DA C0+i
0 00 1 FCMOVE st(0),st(i) DA C8+i
0 01 0 FCMOVBE st(0),st(i) DA D0+i
0 01 1 FCMOVU st(0),st(i) DA D8+i
1 00 0 FCMOVNB st(0),st(i) DB C0+i
1 00 1 FCMOVNE st(0),st(i) DB C8+i
1 01 0 FCMOVNBE st(0),st(i) DB D0+i
1 01 1 FCMOVNU st(0),st(i) DB D8+i
1 10 1 1 FUCOMI Pentium Pro 0 FUCOMI st(0),st(i) DB E8+i
1 10 1 1 FUCOMIP Pentium Pro 1 FUCOMIP st(0),st(i) DF E8+i
1 11 0 1 FCOMI Pentium Pro 0 FCOMI st(0),st(i) DB F0+i
1 11 0 1 FCOMIP Pentium Pro 1 FCOMIP st(0),st(i) DF F0+i

=====# Format 4 #=====
op[4:3] op[2:0] 명령어 추가 시점 Mnemonic HEX 비고
00 000 FCHS 8087 FCHS D9 E0
00 001 FABS 8087 FABS D9 E1
00 100 FTST 8087 FTST D9 E4
00 101 FXAM 8087 FXAM D9 E5
01 000 FLD1 8087 FLD1 D9 E8
01 001 FLD2T 8087 FLD2T D9 E9
01 010 FLD2E 8087 FLD2E D9 EA
01 011 FLDPI 8087 FLDPI D9 EB
01 100 FLDLG2 8087 FLDLG2 D9 EC
01 101 FLDLN2 8087 FLDLN2 D9 ED
01 110 FLDZ 8087 FLDZ D9 EE
10 000 F2XM1 8087 F2XM1 D9 F0
10 001 FYL2X 8087 FYL2X D9 F1
10 010 FPTAN 8087 FPTAN D9 F2
10 011 FPATAN 8087 FPATAN D9 F3
10 100 FXTRACT 8087 FXTRACT D9 F4
10 101 FPREM1 80387 FPREM1 D9 F5 Round to nearest (IEEE-754 compliant)
10 110 FDECSTP 8087 FDECSTP D9 F6
10 111 FINCSTP 8087 FINCSTP D9 F7
11 000 FPREM 8087 FPREM D9 F8 Truncate
11 001 FYL2XP1 8087 FYL2XP1 D9 F9
11 010 FSQRT 8087 FSQRT D9 FA
11 011 FSINCOS 80387 FSINCOS D9 FB
11 100 FRNDINT 8087 FRNDINT D9 FC
11 101 FSCALE 8087 FSCALE D9 FD
11 110 FSIN 80387 FSIN D9 FE
11 110 FCOS 80387 FCOS D9 FF

=====# Format 5 #=====
op[4:3] op[2:0] 명령어 추가 시점 Mnemonic HEX 비고
00 000 FENI8087_NOP 8087 FENI8087_NOP DB E0 32-bit x87 FPU에서는 NOP으로 다뤄짐
00 001 FDISI8087_NOP 8087 FDISI8087_NOP DB E1 32-bit x87 FPU에서는 NOP으로 다뤄짐
00 010 FNCLEX 8087 FNCLEX DB E2 [51]
00 011 FNINIT 8087 FNINIT DB E3 [52]
00 100 FSETPM287_NOP 8087 FSETPM287_NOP DB E4 32-bit x87 FPU에서는 NOP으로 다뤄짐
[51] FCLEX 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.[52] FINIT 명령어는 앞에 9B(WAIT) 명령어가 추가되어 인코딩된다.

1.6. MMX

1.6.1. 레지스터

x87 FPU 레지스터(R0-R7)의 하위 64비트를 MMX 레지스터(MM0-MM7)로 사용한다.

1.6.2. Tag Word

각 MMX 명령어가 실행되면 x87 FPU tag word 전체가 valid(00b)로 설정된다. EMMS(Empty MMX State) 명령어는 x87 FPU tag word 전체를 empty(11b)로 설정한다.

1.6.3. 인코딩

  • Granularity Field (gg): 피연산자의 크기를 나타낸다.
gg Granularity of Data
00 Packed Bytes
01 Packed Words
10 Packed Doublewords
11 Quadword
  • 레지스터 인코딩:
    • MMX 레지스터가 사용된 경우: MMX 레지스터는 ModR/M 바이트의 r 또는 r/m 필드에 인코딩된다.
    • 범용 레지스터가 사용된 경우: MMX 명령어에서 범용 레지스터를 사용하는 경우 이는 ModR/M 바이트의 r/m 필드에 인코딩된다.

2. 명령어 목록

2.1. x86 명령어

2.1.1. x86 사칙연산 명령어

2.1.1.1. ADD
Opcode 추가 시점 Mnemonic 형식 비고
00 /r 8086/8088 ADD r/m8,r8 r/m += r
01 /r 8086/8088 ADD r/m16,r16 r/m += r 32-bit 모드에서는 66h 접두사 필요
80386 ADD r/m32,r32
02 /r 8086/8088 ADD r8,r/m8 r += r/m
03 /r 8086/8088 ADD r16,r/m16 r += r/m 32-bit 모드에서는 66h 접두사 필요
80386 ADD r32,r/m32
04 ib 8086/8088 ADD al,imm8 a += imm
05 iw 8086/8088 ADD ax,imm16 a += imm 32-bit 모드에서는 66h 접두사 필요
05 id 80386 ADD eax,imm32
80 /0 ib 8086/8088 ADD r/m8,imm8 r/m += imm
81 /0 iw 8086/8088 ADD r/m16,imm16 r/m += imm 32-bit 모드에서는 66h 접두사 필요
81 /0 id 80386 ADD r/m32,imm32
83 /0 ib 8086/8088 ADD r/m16,imm8 r/m += imm 32-bit 모드에서는 66h 접두사 필요
80386 ADD r/m32,imm8
2.1.1.1.1. INC
Opcode 추가 시점 Mnemonic 형식 비고
40+rw[53] 8086/8088 INC r16 r += 1 32-bit 모드에서는 66h 접두사 필요
40+rd 80386 INC r32
FE /0 8086/8088 INC r/m8 r/m += 1
FF /0 8086/8088 INC r/m16 r/m += 1 32-bit 모드에서는 66h 접두사 필요
80386 INC r/m32
[53] AMD64 확장에서 해당 opcode는 REX 접두사를 인코딩하는 데 사용된다.
2.1.1.2. ADC
Opcode 추가 시점 Mnemonic 형식 비고
10 /r 8086/8088 ADC r/m8,r8 r/m += r + CF
11 /r 8086/8088 ADC r/m16,r16 r/m += r + CF 32-bit 모드에서는 66h 접두사 필요
80386 ADC r/m32,r32
12 /r 8086/8088 ADC r8,r/m8 r += r/m + CF
13 /r 8086/8088 ADC r16,r/m16 r += r/m + CF 32-bit 모드에서는 66h 접두사 필요
80386 ADC r32,r/m32
14 ib 8086/8088 ADC al,imm8 a += imm + CF
15 iw 8086/8088 ADC ax,imm16 a += imm + CF 32-bit 모드에서는 66h 접두사 필요
15 id 80386 ADC eax,imm32
80 /2 ib 8086/8088 ADC r/m8,imm8 r/m += imm + CF
81 /2 iw 8086/8088 ADC r/m16,imm16 r/m += imm + CF 32-bit 모드에서는 66h 접두사 필요
81 /2 id 80386 ADC r/m32,imm32
83 /2 ib 8086/8088 ADC r/m16,imm8 r/m += imm + CF 32-bit 모드에서는 66h 접두사 필요
80386 ADC r/m32,imm8
2.1.1.3. SUB
Opcode 추가 시점 Mnemonic 형식 비고
28 /r 8086/8088 SUB r/m8,r8 r/m -= r
29 /r 8086/8088 SUB r/m16,r16 r/m -= r 32-bit 모드에서는 66h 접두사 필요
80386 SUB r/m32,r32
2A /r 8086/8088 SUB r8,r/m8 r -= r/m
2B /r 8086/8088 SUB r16,r/m16 r -= r/m 32-bit 모드에서는 66h 접두사 필요
80386 SUB r32,r/m32
2C ib 8086/8088 SUB al,imm8 a -= imm
2D iw 8086/8088 SUB ax,imm16 a -= imm 32-bit 모드에서는 66h 접두사 필요
2D id 80386 SUB eax,imm32
80 /5 ib 8086/8088 SUB r/m8,imm8 r/m -= imm
81 /5 iw 8086/8088 SUB r/m16,imm16 r/m -= imm 32-bit 모드에서는 66h 접두사 필요
81 /5 id 80386 SUB r/m32,imm32
83 /5 ib 8086/8088 SUB r/m16,imm8 r/m -= imm 32-bit 모드에서는 66h 접두사 필요
80386 SUB r/m32,imm8
2.1.1.3.1. DEC
Opcode 추가 시점 Mnemonic 형식 비고
48+rw[54] 8086/8088 DEC r16 r -= 1 32-bit 모드에서는 66h 접두사 필요
48+rd 80386 DEC r32
FE /1 8086/8088 DEC r/m8 r/m -= 1
FF /1 8086/8088 DEC r/m16 r/m -= 1 32-bit 모드에서는 66h 접두사 필요
80386 DEC r/m32
[54] AMD64 확장에서 해당 opcode는 REX 접두사를 인코딩하는 데 사용된다.
2.1.1.4. SBB
Opcode 추가 시점 Mnemonic 형식 비고
18 /r 8086/8088 SBB r/m8,r8 r/m -= r + CF
19 /r 8086/8088 SBB r/m16,r16 r/m -= r + CF 32-bit 모드에서는 66h 접두사 필요
80386 SBB r/m32,r32
1A /r 8086/8088 SBB r8,r/m8 r -= r/m + CF
1B /r 8086/8088 SBB r16,r/m16 r -= r/m + CF 32-bit 모드에서는 66h 접두사 필요
80386 SBB r32,r/m32
1C ib 8086/8088 SBB al,imm8 a -= imm + CF
1D iw 8086/8088 SBB ax,imm16 a -= imm + CF 32-bit 모드에서는 66h 접두사 필요
1D id 80386 SBB eax,imm32
80 /3 ib 8086/8088 SBB r/m8,imm8 r/m -= imm + CF
81 /3 iw 8086/8088 SBB r/m16,imm16 r/m -= imm + CF 32-bit 모드에서는 66h 접두사 필요
81 /3 id 80386 SBB r/m32,imm32
83 /3 ib 8086/8088 SBB r/m16,imm8 r/m -= imm + CF 32-bit 모드에서는 66h 접두사 필요
80386 SBB r/m32,imm8
2.1.1.5. NEG
Opcode 추가 시점 Mnemonic 형식 비고
F6 /3 8086/8088 NEG r/m8 r/m = -(r/m)
F7 /3 8086/8088 NEG r/m16 r/m = -(r/m) 32-bit 모드에서는 66h 접두사 필요
80386 NEG r/m32
2.1.1.6. CMP
Opcode 추가 시점 Mnemonic 형식 비고
38 /r 8086/8088 CMP r/m8,r8 temp = r/m - r
39 /r 8086/8088 CMP r/m16,r16 temp = r/m - r 32-bit 모드에서는 66h 접두사 필요
80386 CMP r/m32,r32
3A /r 8086/8088 CMP r8,r/m8 temp = r - r/m
3B /r 8086/8088 CMP r16,r/m16 temp = r - r/m 32-bit 모드에서는 66h 접두사 필요
80386 CMP r32,r/m32
3C ib 8086/8088 CMP al,imm8 temp = a - imm
3D iw 8086/8088 CMP ax,imm16 temp = a - imm 32-bit 모드에서는 66h 접두사 필요
3D id 80386 CMP eax,imm32
80 /7 ib 8086/8088 CMP r/m8,imm8 temp = r/m - imm
81 /7 iw 8086/8088 CMP r/m16,imm16 temp = r/m - imm 32-bit 모드에서는 66h 접두사 필요
81 /7 id 80386 CMP r/m32,imm32
83 /7 ib 8086/8088 CMP r/m16,imm8 temp = r/m - imm 32-bit 모드에서는 66h 접두사 필요
80386 CMP r/m32,imm8
SUB 연산을 수행 후 결과값을 레지스터에 저장하지 않고 플래그만 설정하는 명령어이다.
2.1.1.7. MUL
Opcode 추가 시점 Mnemonic 형식 비고
F6 /4 8086/8088 MUL r/m8 ax = al * (r/m8);
F7 /4 8086/8088 MUL r/m16 dx:ax = ax * (r/m16); 32-bit 모드에서는 66h 접두사 필요
80386 MUL r/m32 edx:eax = eax * (r/m32);
2.1.1.8. IMUL
Opcode 추가 시점 Mnemonic 형식 비고
0F AF /r 80386 IMUL r16,r/m16 r *= r/m 32-bit 모드에서는 66h 접두사 필요
IMUL r32,r/m32
69 /r iw 80186 IMUL r16,r/m16,imm16 r = r/m * imm 32-bit 모드에서는 66h 접두사 필요
69 /r id 80386 IMUL r32,r/m32,imm32 r = r/m * imm
6B /r ib 80186 IMUL r16,r/m16,imm8 r = r/m * imm 32-bit 모드에서는 66h 접두사 필요
80386 IMUL r32,r/m32,imm8 r = r/m * imm
F6 /5 8086/8088 IMUL r/m8 ax = al * (r/m8);
F7 /5 8086/8088 IMUL r/m16 dx:ax = ax * (r/m16); 32-bit 모드에서는 66h 접두사 필요
80386 IMUL r/m32 edx:eax = eax * (r/m32);
2.1.1.9. DIV
Opcode 추가 시점 Mnemonic 형식 비고
F6 /6 8086/8088 DIV r/m8 al = ax / (r/m8);
ah = ax % (r/m8);
F7 /6 8086/8088 DIV r/m16 ax = dx:ax / (r/m16);
dx = dx:ax % (r/m16); 		32-bit 모드에서는 66h 접두사 필요
80386 DIV r/m32 eax = edx:eax / (r/m32);
edx = edx:eax % (r/m32);
2.1.1.10. IDIV
Opcode 추가 시점 Mnemonic 형식 비고
F6 /7 8086/8088 IDIV r/m8 al = ax / (r/m8);
ah = ax % (r/m8);
F7 /7 8086/8088 IDIV r/m16 ax = dx:ax / (r/m16);
dx = dx:ax % (r/m16); 		32-bit 모드에서는 66h 접두사 필요
80386 IDIV r/m32 eax = edx:eax / (r/m32);
edx = edx:eax % (r/m32);

2.1.2. x86 논리연산 명령어

2.1.2.1. AND
Opcode 추가 시점 Mnemonic 형식 비고
20 /r 8086/8088 AND r/m8,r8 r/m &= r
21 /r 8086/8088 AND r/m16,r16 r/m &= r 32-bit 모드에서는 66h 접두사 필요
80386 AND r/m32,r32
22 /r 8086/8088 AND r8,r/m8 r &= r/m
23 /r 8086/8088 AND r16,r/m16 r &= r/m 32-bit 모드에서는 66h 접두사 필요
80386 AND r32,r/m32
24 ib 8086/8088 AND al,imm8 a &= imm
25 iw 8086/8088 AND ax,imm16 a &= imm 32-bit 모드에서는 66h 접두사 필요
25 id 80386 AND eax,imm32
80 /4 ib 8086/8088 AND r/m8,imm8 r/m &= imm
81 /4 iw 8086/8088 AND r/m16,imm16 r/m &= imm 32-bit 모드에서는 66h 접두사 필요
81 /4 id 80386 AND r/m32,imm32
83 /4 ib 8086/8088 AND r/m16,imm8 r/m &= imm 32-bit 모드에서는 66h 접두사 필요
80386 AND r/m32,imm8
2.1.2.2. OR
Opcode 추가 시점 Mnemonic 형식 비고
08 /r 8086/8088 OR r/m8,r8 r/m |= r
09 /r 8086/8088 OR r/m16,r16 r/m |= r 32-bit 모드에서는 66h 접두사 필요
80386 OR r/m32,r32
0A /r 8086/8088 OR r8,r/m8 r |= r/m
0B /r 8086/8088 OR r16,r/m16 r |= r/m 32-bit 모드에서는 66h 접두사 필요
80386 OR r32,r/m32
0C ib 8086/8088 OR al,imm8 a |= imm
0D iw 8086/8088 OR ax,imm16 a |= imm 32-bit 모드에서는 66h 접두사 필요
0D id 80386 OR eax,imm32
80 /1 ib 8086/8088 OR r/m8,imm8 r/m |= imm
81 /1 iw 8086/8088 OR r/m16,imm16 r/m |= imm 32-bit 모드에서는 66h 접두사 필요
81 /1 id 80386 OR r/m32,imm32
83 /1 ib 8086/8088 OR r/m16,imm8 r/m |= imm 32-bit 모드에서는 66h 접두사 필요
80386 OR r/m32,imm8
2.1.2.3. XOR
Opcode 추가 시점 Mnemonic 형식 비고
30 /r 8086/8088 XOR r/m8,r8 r/m ^= r
31 /r 8086/8088 XOR r/m16,r16 r/m ^= r 32-bit 모드에서는 66h 접두사 필요
80386 XOR r/m32,r32
32 /r 8086/8088 XOR r8,r/m8 r ^= r/m
33 /r 8086/8088 XOR r16,r/m16 r ^= r/m 32-bit 모드에서는 66h 접두사 필요
80386 XOR r32,r/m32
34 ib 8086/8088 XOR al,imm8 a ^= imm
35 iw 8086/8088 XOR ax,imm16 a ^= imm 32-bit 모드에서는 66h 접두사 필요
35 id 80386 XOR eax,imm32
80 /6 ib 8086/8088 XOR r/m8,imm8 r/m ^= imm
81 /6 iw 8086/8088 XOR r/m16,imm16 r/m ^= imm 32-bit 모드에서는 66h 접두사 필요
81 /6 id 80386 XOR r/m32,imm32
83 /6 ib 8086/8088 XOR r/m16,imm8 r/m ^= imm 32-bit 모드에서는 66h 접두사 필요
80386 XOR r/m32,imm8
2.1.2.4. NOT
Opcode 추가 시점 Mnemonic 형식 비고
F6 /2 8086/8088 NOT r/m8 r/m = ~(r/m)
F7 /2 8086/8088 NOT r/m16 r/m = ~(r/m) 32-bit 모드에서는 66h 접두사 필요
80386 NOT r/m32
2.1.2.5. TEST
Opcode 추가 시점 Mnemonic 형식 비고
84 /r 8086/8088 TEST r/m8,r8 temp = r/m & r
85 /r 8086/8088 TEST r/m16,r16 temp = r/m & r 32-bit 모드에서는 66h 접두사 필요
80386 TEST r/m32,r32
A8 ib 8086/8088 TEST al,imm8 temp = a & imm
A9 iw 8086/8088 TEST ax,imm16 temp = a & imm 32-bit 모드에서는 66h 접두사 필요
A9 id 80386 TEST eax,imm32
F6 /0 ib 8086/8088 TEST r/m8,imm8 temp = r/m & imm
F7 /0 iw 8086/8088 TEST r/m16,imm16 temp = r/m & imm 32-bit 모드에서는 66h 접두사 필요
F7 /0 id 80386 TEST r/m32,imm32
AND 연산을 수행 후 결과값을 레지스터에 저장하지 않고 플래그만 설정하는 명령어이다.

2.1.3. x86 Shift 명령어

Barrel Shifter를 사용하는 명령어의 목록이다. 1만큼 rotate/shift하는 명령어가 별도의 opcode에 인코딩된 것이 특징이다.
2.1.3.1. ROL
Opcode 추가 시점 Mnemonic 설명 비고
C0 /0 ib 80186 ROL r/m8,imm8
C1 /0 ib 80186 ROL r/m16,imm8 32-bit 모드에서는 66h 접두사 필요
80386 ROL r/m32,imm8
D0 /0 8086/8088 ROL r/m8,1
D1 /0 8086/8088 ROL r/m16,1 32-bit 모드에서는 66h 접두사 필요
80386 ROL r/m32,1
D2 /0 8086/8088 ROL r/m8,CL
D3 /0 8086/8088 ROL r/m16,CL 32-bit 모드에서는 66h 접두사 필요
80386 ROL r/m32,CL
2.1.3.2. ROR
Opcode 추가 시점 Mnemonic 설명 비고
C0 /1 ib 80186 ROR r/m8,imm8
C1 /1 ib 80186 ROR r/m16,imm8 32-bit 모드에서는 66h 접두사 필요
80386 ROR r/m32,imm8
D0 /1 8086/8088 ROR r/m8,1
D1 /1 8086/8088 ROR r/m16,1 32-bit 모드에서는 66h 접두사 필요
80386 ROR r/m32,1
D2 /1 8086/8088 ROR r/m8,CL
D3 /1 8086/8088 ROR r/m16,CL 32-bit 모드에서는 66h 접두사 필요
80386 ROR r/m32,CL
2.1.3.3. RCL
Opcode 추가 시점 Mnemonic 설명 비고
C0 /2 ib 80186 RCL r/m8,imm8
C1 /2 ib 80186 RCL r/m16,imm8 32-bit 모드에서는 66h 접두사 필요
80386 RCL r/m32,imm8
D0 /2 8086/8088 RCL r/m8,1
D1 /2 8086/8088 RCL r/m16,1 32-bit 모드에서는 66h 접두사 필요
80386 RCL r/m32,1
D2 /2 8086/8088 RCL r/m8,CL
D3 /2 8086/8088 RCL r/m16,CL 32-bit 모드에서는 66h 접두사 필요
80386 RCL r/m32,CL
2.1.3.4. RCR
Opcode 추가 시점 Mnemonic 설명 비고
C0 /3 ib 80186 RCR r/m8,imm8
C1 /3 ib 80186 RCR r/m16,imm8 32-bit 모드에서는 66h 접두사 필요
80386 RCR r/m32,imm8
D0 /3 8086/8088 RCR r/m8,1
D1 /3 8086/8088 RCR r/m16,1 32-bit 모드에서는 66h 접두사 필요
80386 RCR r/m32,1
D2 /3 8086/8088 RCR r/m8,CL
D3 /3 8086/8088 RCR r/m16,CL 32-bit 모드에서는 66h 접두사 필요
80386 RCR r/m32,CL
2.1.3.5. SHL / SAL
Opcode 추가 시점 Mnemonic 형식 비고
C0 /4 ib 80186 SHL r/m8,imm8 r/m <<= imm & 0x1f
C1 /4 ib 80186 SHL r/m16,imm8 r/m <<= imm & 0x1f 32-bit 모드에서는 66h 접두사 필요
80386 SHL r/m32,imm8
D0 /4 8086/8088 SHL r/m8 r/m <<= 1
D1 /4 8086/8088 SHL r/m16 r/m <<= 1 32-bit 모드에서는 66h 접두사 필요
80386 SHL r/m32
D2 /4 8086/8088 SHL r/m8,CL r/m <<= cl & 0x1f
D3 /4 8086/8088 SHL r/m16,CL r/m <<= cl & 0x1f 32-bit 모드에서는 66h 접두사 필요
80386 SHL r/m32,CL
SHL 명령어와 SAL 명령어는 동일한 연산을 수행한다.
2.1.3.6. SHR
Opcode 추가 시점 Mnemonic 형식 비고
C0 /5 ib 80186 SHR r/m8,imm8 r/m >>= imm & 0x1f
C1 /5 ib 80186 SHR r/m16,imm8 r/m >>= imm & 0x1f 32-bit 모드에서는 66h 접두사 필요
80386 SHR r/m32,imm8
D0 /5 8086/8088 SHR r/m8 r/m >>= 1
D1 /5 8086/8088 SHR r/m16 r/m >>= 1 32-bit 모드에서는 66h 접두사 필요
80386 SHR r/m32
D2 /5 8086/8088 SHR r/m8,CL r/m >>= cl & 0x1f
D3 /5 8086/8088 SHR r/m16,CL r/m >>= cl & 0x1f 32-bit 모드에서는 66h 접두사 필요
80386 SHR r/m32,CL
2.1.3.7. SAR
Opcode 추가 시점 Mnemonic 형식 비고
C0 /7 ib 80186 SAR r/m8,imm8 r/m >>= imm & 0x1f
C1 /7 ib 80186 SAR r/m16,imm8 r/m >>= imm & 0x1f 32-bit 모드에서는 66h 접두사 필요
80386 SAR r/m32,imm8
D0 /7 8086/8088 SAR r/m8 r/m >>= 1
D1 /7 8086/8088 SAR r/m16 r/m >>= 1 32-bit 모드에서는 66h 접두사 필요
80386 SAR r/m32
D2 /7 8086/8088 SAR r/m8,CL r/m >>= cl & 0x1f
D3 /7 8086/8088 SAR r/m16,CL r/m >>= cl & 0x1f 32-bit 모드에서는 66h 접두사 필요
80386 SAR r/m32,CL
2.1.3.8. SHLD
Opcode 추가 시점 Mnemonic 설명 비고
0F A4 80386 SHLD r/m16,r16,imm8 32-bit 모드에서는 66h 접두사 필요
SHLD r/m32,r32,imm8
0F A5 80386 SHLD r/m16,r16,CL 32-bit 모드에서는 66h 접두사 필요
SHLD r/m32,r32,CL
2.1.3.9. SHRD
Opcode 추가 시점 Mnemonic 설명 비고
0F AC 80386 SHRD r/m16,r16,imm8 32-bit 모드에서는 66h 접두사 필요
SHRD r/m32,r32,imm8
0F AD 80386 SHRD r/m16,r16,CL 32-bit 모드에서는 66h 접두사 필요
SHRD r/m32,r32,CL

2.1.4. x86 메모리 관련 명령어

2.1.4.1. MOV
Opcode 추가 시점 Mnemonic 형식 비고
88 /r 8086/8088 MOV r/m8,r8 r/m = r
89 /r 8086/8088 MOV r/m16,r16 r/m = r 32-bit 모드에서는 66h 접두사 필요
80386 MOV r/m32,r32
8A /r 8086/8088 MOV r8,r/m8 r = r/m
8B /r 8086/8088 MOV r16,r/m16 r = r/m 32-bit 모드에서는 66h 접두사 필요
80386 MOV r32,r/m32
B0+rb ib 8086/8088 MOV r8,imm8
B8+rw iw 8086/8088 MOV r16,imm16 32-bit 모드에서는 66h 접두사 필요
B8+rd id 80386 MOV r32,imm32
C6 /0 8086/8088 MOV r/m8,imm8
C7 /0 8086/8088 MOV r/m16,imm16 32-bit 모드에서는 66h 접두사 필요
80386 MOV r/m32,imm32
2.1.4.1.1. MOV Sreg / MOV (seg:offset)
Opcode 추가 시점 Mnemonic 형식 비고
8C /r 8086/8088 MOV r/m16,Sreg r/m = Sreg
8E /r 8086/8088 MOV Sreg,r/m16 Sreg = r/m CS는 불러들일 수 없음. SS 값 변경시 다음 명령어까지 인터럽트 억제
A0 /r 8086/8088 MOV al,moffs8 a = (seg:offset)
A1 /r 8086/8088 MOV ax,moffs16 a = (seg:offset) 32-bit 모드에서는 66h 접두사 필요
80386 MOV eax,moffs32
A2 /r 8086/8088 MOV moffs8,al (seg:offset) = a
A3 /r 8086/8088 MOV moffs16,ax (seg:offset) = a 32-bit 모드에서는 66h 접두사 필요
80386 MOV moffs32,eax
2.1.4.2. XCHG
Opcode 추가 시점 Mnemonic 형식 비고
86 /r 8086/8088 XCHG r/m8,r8
XCHG r8,r/m8
87 /r 8086/8088 XCHG r/m16,r16
XCHG r16,r/m16 		32-bit 모드에서는 66h 접두사 필요
80386 XCHG r/m32,r32
XCHG r32,r/m32
90+rw 8086/8088 XCHG ax,r16
XCHG r16,ax 		32-bit 모드에서는 66h 접두사 필요
90+rd 80386 XCHG eax,r32
XCHG r32,eax
2.1.4.3. CMPXCHG
Opcode 추가 시점 Mnemonic 설명 비고
0F B0 /r 80486 CMPXCHG r/m8,r8 [55]
0F B1 /r 80486 CMPXCHG r/m16,r16 [56] 32-bit 모드에서는 66h 접두사 필요
CMPXCHG r/m32,r32 [57]
LOCK 접두사와 함께 사용하는 경우 원자적으로 실행된다.
[55] Compare AL with r/m8. If equal, ZF is set and r8 is loaded into r/m8. Else, clear ZF and load r/m8 into AL.[56] Compare AX with r/m16. If equal, ZF is set and r16 is loaded into r/m16. Else, clear ZF and load r/m16 into AX.[57] Compare EAX with r/m32. If equal, ZF is set and r32 is loaded into r/m32. Else, clear ZF and load r/m32 into AX.
2.1.4.3.1. CMPXCHG8B
Opcode 추가 시점 Mnemonic 설명 비고
0F C7 /1 m64 Pentium CMPXCHG8B m64 [58] 레지스터 operand는 허용되지 않는다.[59]
LOCK 접두사와 함께 사용하는 경우 원자적으로 실행된다.
[58] Compare EDX:EAX with m64. If equal, set ZF and load ECX:EBX into m64. Else, clear ZF and load m64 into EDX:EAX.[59] 레지스터 operand 사용 시 예외를 발생시킨다. 그러나 LOCK 접두사와 함께 레지스터 operand를 사용하는 경우 프로세서에 따라 LOCK 접두사가 실행되어 예외 처리 과정이 정상적으로 작동하지 않아 프로세서가 뻗어버리는(!) 버그가 발생하기도 한다. 펜티엄 문서에서 언급된 F00F 버그가 이에 해당한다. 문제의 명령어는 lock cmpxchg8b eax(F0 0F C7 C8))
2.1.4.4. PUSH
Opcode 추가 시점 Mnemonic 형식 비고
50+rw 8086/8088 PUSH r16 *--SP = r 32-bit 모드에서는 66h 접두사 필요
50+rd 80386 PUSH r32
6A 80186 PUSH imm8 *--SP = imm
68 80186 PUSH imm16 *--SP = imm 32-bit 모드에서는 66h 접두사 필요
80386 PUSH imm32
FF /6 8086/8088 PUSH r/m16 *--SP = r/m 32-bit 모드에서는 66h 접두사 필요
80386 PUSH r/m32
67h 접두사 사용 시 16-bit 스택 포인터인 SP 레지스터가 사용된다. PUSH 연산 실행 시 16-bit 모드 또는 66h 접두사 사용 시 스택 포인터가 2 감소하고, 32-bit 모드에서는 스택 포인터가 4 감소한다.
2.1.4.4.1. PUSH CS/SS/DS/ES/FS/GS
Opcode 추가 시점 Mnemonic 형식 비고
0E 8086/8088 PUSH CS *--SP = CS
16 8086/8088 PUSH SS *--SP = SS
1E 8086/8088 PUSH DS *--SP = DS
06 8086/8088 PUSH ES *--SP = ES
0F A0 80386 PUSH FS *--SP = FS
0F A8 80386 PUSH GS *--SP = GS
2.1.4.4.2. PUSHA/PUSHAD
Opcode 추가 시점 Mnemonic 설명 비고
60 80186 PUSHA [60] 32-bit 모드에서는 66h 접두사 필요
80386 PUSHAD [61]
2.1.4.4.3. PUSHF/PUSHFD
Opcode 추가 시점 Mnemonic 형식 비고
9C 8086/8088 PUSHF *--SP = FLAGS 32-bit 모드에서는 66h 접두사 필요
80386 PUSHFD *--SP = EFLAGS
[60] 16-bit 범용 레지스터 전체를 번호 오름차순으로 스택에 push한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.[61] 32-bit 범용 레지스터 전체를 번호 오름차순으로 스택에 push한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.
2.1.4.5. POP
Opcode 추가 시점 Mnemonic 형식 비고
58+rw 8086/8088 POP r16 r = *SP++ 32-bit 모드에서는 66h 접두사 필요
58+rd 80386 POP r32
8F /0 8086/8088 POP r/m16 r/m = *SP++ 32-bit 모드에서는 66h 접두사 필요
80386 POP r/m32
2.1.4.5.1. POP SS/DS/ES/FS/GS
Opcode 추가 시점 Mnemonic 형식 비고
0F 8086/8088 POP CS CS = *SP++ 8086/8088에만 존재
17 8086/8088 POP SS SS = *SP++
1F 8086/8088 POP DS DS = *SP++
07 8086/8088 POP ES ES = *SP++
0F A1 80386 POP SS FS = *SP++ 다음 명령어까지 인터럽트 억제
0F A9 80386 POP SS GS = *SP++
67h 접두사 사용 시 16-bit 스택 포인터인 SP 레지스터가 사용된다. POP 연산 실행 시 16-bit 모드 또는 66h 접두사 사용 시 스택 포인터가 2 증가하고, 32-bit 모드에서는 스택 포인터가 4 증가한다.

POP CS 명령어는 CS 세그먼트를 스택에서 제거한 값으로 덮어씌워 명령어 실행 흐름을 변경시키나 IP는 변경하지 않기 때문에 쓸모가 없어 삭제되었고 공식 문서에서 CS 값을 변경하려면 CS:IP를 스택에서 꺼내 덮어씌우는 RETF 명령어를 사용하라고 안내하고 있다. POP SS 명령어의 경우 스택 세그먼트 변경시 스택 포인터 또한 변경되어야 하므로 다음 명령어에서 SP를 변경할 때까지 인터럽트를 억제시킨다.
2.1.4.5.2. POPA/POPAD
Opcode 추가 시점 Mnemonic 설명 비고
61 80186 POPA [62] 32-bit 모드에서는 66h 접두사 필요
80386 POPAD [63]
2.1.4.5.3. POPF/POPFD
Opcode 추가 시점 Mnemonic 형식 비고
9D 8086/8088 POPF FLAGS = *SP++ 32-bit 모드에서는 66h 접두사 필요
80386 POPFD EFLAGS = *SP++
[62] 16-bit 범용 레지스터 전체를 번호 내림차순으로 스택으로부터 pop한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.[63] 32-bit 범용 레지스터 전체를 번호 내림차순으로 스택으로부터 pop한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.
2.1.4.6. CBW/CWDE
Opcode 추가 시점 Mnemonic 설명 비고
98 8086/8088 CBW AX ← sign-extend of AL 32-bit 모드에서는 66h 접두사 필요
80386 CWDE EAX ← sign-extend of AX
2.1.4.7. CWD/CDQ
Opcode 추가 시점 Mnemonic 설명 비고
99 8086/8088 CWD DX:AX ← sign-extend of AX 32-bit 모드에서는 66h 접두사 필요
80386 CDQ EDX:EAX ← sign-extend of EAX
2.1.4.8. MOVZX
Opcode 추가 시점 Mnemonic 설명 비고
0F B6 /r 80386 MOVZX r16,r/m8 Move byte to word, zero-extension 32-bit 모드에서는 66h 접두사 필요
MOVZX r32,r/m8 Move byte to doubleword, zero-extension
0F B7 /r 80386 MOVZX r32,r/m16 Move word to doubleword, zero-extension
2.1.4.9. MOVSX
Opcode 추가 시점 Mnemonic 설명 비고
0F BE /r 80386 MOVSX r16,r/m8 Move byte to word, sign-extension 32-bit 모드에서는 66h 접두사 필요
MOVSX r32,r/m8 Move byte to doubleword, sign-extension
0F BF /r 80386 MOVSX r32,r/m16 Move word to doubleword, sign-extension
2.1.4.10. LEA
Opcode 추가 시점 Mnemonic 형식 비고
8D /r 8086/8088 LEA r16,m r = [base + index * size + offset] 32-bit 모드에서는 66h 접두사 필요
80386 LEA r32,m
메모리 주소를 계산하는 명령어이다. 일부 컴파일러에서는 작은 상수를 곱하는 코드를 최적화할 때 사용한다.
66h 67h Operand Size Address Size 설명
O O 16 16 16-bit 주소가 계산되어 16-bit 레지스터에 저장된다.
O - 16 32 32-bit 주소가 계산되어 하위 16-bit가 16-bit 레지스터에 저장된다.
- O 32 16 16-bit 주소가 계산되어 zero-extend된 다음 32-bit 레지스터에 저장된다.
- - 32 32 32-bit 주소가 계산되어 32-bit 레지스터에 저장된다.
2.1.4.11. ENTER
Opcode 추가 시점 Mnemonic 설명 비고
C8 iw 00 80186 ENTER imm16,0 Create a stack frame for a procedure
C8 iw 01 80186 ENTER imm16,1 Create a nested stack frame for a procedure
C8 iw ib ENTER imm16,imm8 [64]
16-bit 모드 또는 66h 접두사 사용 시 스택에서 BP 레지스터 값에 대한 push를 수행하고, 32-bit 모드에서는 EBP 레지스터 값에 대한 push를 수행한다.
[64] Nesting level에는 imm8을 32로 나눈 나머지 값(0-31)이 사용됨
2.1.4.12. LEAVE
Opcode 추가 시점 Mnemonic 형식 비고
C9 80186 LEAVE SP = BP; BP = *SP++;
80386 LEAVE ESP = EBP; EBP = *ESP++;
67h 접두사 사용 시 16-bit 스택 포인터인 SP 레지스터가 사용된다. 16-bit 모드 또는 66h 접두사 사용 시 스택에서 BP 레지스터 값에 대한 pop을 수행하고, 32-bit 모드에서는 EBP 레지스터 값에 대한 pop을 수행한다.
2.1.4.13. BOUND
Opcode 추가 시점 Mnemonic 설명 비고
62 /r 80186 BOUND r16,m16&16 32-bit 모드에서는 66h 접두사 필요
80386 BOUND r32,m32&32
2.1.4.14. BSWAP
Opcode 추가 시점 Mnemonic 설명 비고
0F C8+rd 80486 BSWAP r32 Reverses the byte order of a 32-bit register. 16-bit 레지스터에 대한 동작은 정의되지 않음
32-bit 레지스터 내의 바이트 순서를 뒤집는 명령어이다. 16-bit 레지스터 내의 바이트 순서를 뒤집고자 하는 경우 XCHG 명령어를 사용할 수 있다. (예: xchg ah,al)
2.1.4.15. XADD
Opcode 추가 시점 Mnemonic 설명 비고
0F C0 /r 80486 XADD r/m8,r8 Exchange r8 and r/m8; load sum into r/m8.
0F C1 /r 80486 XADD r/m16,r16 Exchange r16 and r/m16; load sum into r/m16. 32-bit 모드에서는 66h 접두사 필요
XADD r/m32,r32 Exchange r32 and r/m32; load sum into r/m32.
LOCK 접두사와 함께 사용하는 경우 원자적으로 실행된다.
2.1.4.16. XLAT
Opcode 추가 시점 Mnemonic 설명 비고
D7 8088/8086 XLAT m8
XLATB 		Set AL to memory byte DS:[(E)BX + unsigned AL]
16-bit 모드 또는 67h 접두사 사용시 메모리 주소로 DS:[BX+unsigned AL]을, 32-bit 모드에서는 DS:[EBX+unsigned AL]을 사용한다.
2.1.4.17. LAHF
Opcode 추가 시점 Mnemonic 설명 비고
9F 8086/8088 LAHF Load: AH ← EFLAGS(SF:ZF:0:AF:0:PF:1:CF)
2.1.4.18. SAHF
Opcode 추가 시점 Mnemonic 설명 비고
9E 8086/8088 SAHF Loads SF, ZF, AF, PF, and CF from AH into EFLAGS register
2.1.4.19. LDS/LES/LFS/LGS/LSS
Opcode 추가 시점 Mnemonic 설명 비고
C5 /r 8086/8088 LDS r16,m16:16 Load DS:r16 with far pointer from memory 32-bit 모드에서는 66h 접두사 필요
80386 LDS r32,m16:32 Load DS:r32 with far pointer from memory
C4 /r 8086/8088 LES r16,m16:16 Load ES:r16 with far pointer from memory 32-bit 모드에서는 66h 접두사 필요
80386 LES r32,m16:32 Load ES:r32 with far pointer from memory
0F B2 /r 80386 LSS r16,m16:16 Load SS:r16 with far pointer from memory 32-bit 모드에서는 66h 접두사 필요
LSS r32,m16:32 Load SS:r32 with far pointer from memory
0F B4 /r 80386 LFS r16,m16:16 Load FS:r16 with far pointer from memory 32-bit 모드에서는 66h 접두사 필요
LFS r32,m16:32 Load FS:r32 with far pointer from memory
0F B5 /r 80386 LGS r16,m16:16 Load GS:r16 with far pointer from memory 32-bit 모드에서는 66h 접두사 필요
LGS r32,m16:32 Load GS:r32 with far pointer from memory

2.1.5. x86 제어/조건부 명령어

2.1.5.1. JMP
Opcode 추가 시점 Mnemonic 설명 비고
EB cb 8086/8088 JMP rel8 Jump short, relative
E9 cw 8086/8088 JMP rel16 Jump near, relative 32-bit 모드에서는 66h 접두사 필요[jmp-ip]
E9 cd 80386 JMP rel32
EA cd 8086/8088 JMP ptr16:16 Jump far, absolute 32-bit 모드에서는 66h 접두사 필요[jmp-ip]
EA cp 80386 JMP ptr16:32
FF /4 8086/8088 JMP r/m16 Jump near, absolute indirect 32-bit 모드에서는 66h 접두사 필요[jmp-ip]
80386 JMP r/m32
FF /5 8086/8088 JMP m16:16 Jump far, absolute indirect 32-bit 모드에서는 66h 접두사 필요[jmp-ip]
80386 JMP m16:32
2.1.5.2. Jcc
Opcode 추가 시점 Mnemonic 설명 비고
70+cc cb 8086/8088 Jcc rel8 Jump short if (condition)
0F 80+cc cw 80386 Jcc rel16 Jump near if (condition) 32-bit 모드에서는 66h 접두사 필요[jcc-ip]
0F 80+cc cd 80386 Jcc rel32
2.1.5.2.1. JCXZ/JECXZ
Opcode 추가 시점 Mnemonic 설명 비고
E3 cb 8086/8088 JCXZ rel8 Jump short if CX register is 0 32-bit 모드에서는 67h 접두사 필요
80386 JECXZ rel8 Jump short if ECX register is 0
[jmp-ip] 이때 ip는 16-bit로 간주되어 eip의 상위 16-bit가 비워진다.[jmp-ip] [jmp-ip] [jmp-ip] [jcc-ip] 이때 ip는 16-bit로 간주되어 eip의 상위 16-bit가 비워진다.
2.1.5.3. CALL
Opcode 추가 시점 Mnemonic 설명 비고
E8 cw 8086/8088 CALL rel16 Call near, relative 32-bit 모드에서는 66h 접두사 필요[call-ip]
E8 cd 80386 CALL rel32
9A cd 8086/8088 CALL ptr16:16 Call far, absolute 32-bit 모드에서는 66h 접두사 필요[call-ip]
9A cp 80386 CALL ptr16:32
FF /2 8086/8088 CALL r/m16 Call near, absolute indirect 32-bit 모드에서는 66h 접두사 필요[call-ip]
80386 CALL r/m32
FF /3 8086/8088 CALL m16:16 Call far, absolute indirect 32-bit 모드에서는 66h 접두사 필요[call-ip]
80386 CALL m16:32
[call-ip] 이때 ip는 16-bit로 간주되어 eip의 상위 16-bit가 비워진다.[call-ip] [call-ip] [call-ip]
2.1.5.4. RET(RETN/RETF)
Opcode 추가 시점 Mnemonic 설명 비고
C3 8086/8088 RET Near return to calling procedure
CB 8086/8088 RET Far return to calling procedure
C2 iw 8086/8088 RET imm16 Near return to calling procedure and pop imm16 bytes
from stack
CA iw 8086/8088 RET imm16 Far return to calling procedure and pop imm16 bytes
from stack
66h 접두사 사용 시 16-bit IP가 사용된다.
2.1.5.5. LOOP/LOOPcc
Opcode 추가 시점 Mnemonic 설명 비고
E2 cb 8086/8088 LOOP rel8 Decrement count; Jump short if count != 0
E1 cb 8086/8088 LOOPE rel8
LOOPZ rel8 		Decrement count; Jump short if count != 0 and ZF = 1
E0 cb 8086/8088 LOOPNE rel8
LOOPNZ rel8 		Decrement count; Jump short if count != 0 and ZF = 0
2.1.5.6. INT n/INTO/INT3/INT1
Opcode 추가 시점 Mnemonic 설명 비고
CC 8086/8088 INT 3 Interrupt 3—trap to debugger
CD ib 8086/8088 INT imm8 Interrupt vector number specified by immediate byte
CE 8086/8088 INTO Interrupt 4—if overflow flag is 1
F1 80386 INT1
ICEBP 		[74]
[74] 2018년까지 문서화되지 않음
2.1.5.7. IRET/IRETD
Opcode 추가 시점 Mnemonic 설명 비고
CF 8086/8088 IRET Interrupt return 32-bit 모드에서는 66h 접두사 필요
80386 IRETD
2.1.5.8. CMOVcc
Opcode 추가 시점 Mnemonic 설명 비고
0F 40+cc /r Pentium Pro CMOVcc r16, r/m16 Move if (condition) 32-bit 모드에서는 66h 접두사 필요
CMOVcc r32, r/m32
2.1.5.9. SETcc
Opcode 추가 시점 Mnemonic 설명 비고
0F 90+cc 80386 SETcc r/m8 Set byte if (condition)

2.1.6. x86 프로세서 제어 명령어

2.1.6.1. LOCK prefix
Opcode 추가 시점 Mnemonic 해당 명령어 설명 비고
F0 8086/8088 LOCK [75] [76] [77]
[75] ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCH8B, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD, XCHG.[76] Asserts LOCK# signal for duration of the accompanying instruction[77] destination operand가 memory인 경우에만 사용 가능
2.1.6.2. Segment prefix
메모리 세그멘트를 지정하는 접두사이다.
  • 2Eh(0x2E): CS segment override
  • 36h(0x36): SS segment override
  • 3Eh(0x3E): DS segment override
  • 26h(0x26): ES segment override
  • 64h(0x64): FS segment override
  • 65h(0x65): GS segment override
2.1.6.3. ESC
Opcode 추가 시점 Mnemonic 비고
D8..DF 8086/8088 외부 장치(x87 FPU)에 접근하는 명령어이다.
x87 섹션 참조.
2.1.6.4. WAIT
Opcode 추가 시점 Mnemonic 설명 비고
9B 8086/8088 WAIT
FWAIT 		Check pending unmasked floating-point exceptions.
2.1.6.5. HLT
Opcode 추가 시점 Mnemonic 설명 비고
F4 8086/8088 HLT Halt
인터럽트 또는 특정한 신호가 활성화될 때까지 명령어의 실행을 멈추고 프로세서를 HALT 상태로 둔다. 하이퍼쓰레딩이 활성화된 경우 해당 명령어를 실행한 논리 프로세서만이 비활성화되고, 같은 코어에 존재하는 다른 논리 프로세서에는 적용되지 않는다.

2.1.7. x86 플래그 제어 및 기타 명령어

2.1.7.1. CLC
Opcode 추가 시점 Mnemonic 설명 비고
F8 8086/8088 CLC Clear carry CF = 0
2.1.7.2. CMC
Opcode 추가 시점 Mnemonic 설명 비고
F5 8086/8088 CMC Complement carry CF = ~CF
2.1.7.3. STC
Opcode 추가 시점 Mnemonic 설명 비고
F9 8086/8088 STC Set carry CF = 1
2.1.7.4. CLD
Opcode 추가 시점 Mnemonic 설명 비고
FC 8086/8088 CLC Clear direction DF = 0
2.1.7.5. STD
Opcode 추가 시점 Mnemonic 설명 비고
FD 8086/8088 STD Set direction DF = 1
2.1.7.6. CLI
Opcode 추가 시점 Mnemonic 설명 비고
FA 8086/8088 CLI Clear interrupt IF = 0
2.1.7.7. STI
Opcode 추가 시점 Mnemonic 설명 비고
FB 8086/8088 STI Set interrupt IF = 1
2.1.7.8. CPUID
Opcode 추가 시점 Mnemonic 설명 비고
0F A2 Pentium CPUID CPU Identification
EAX 레지스터 값에 따라 EAX, EBX, ECX, EDX 레지스터에 프로세서 정보를 반환한다.

2.1.8. x86 시스템 명령어

2.1.8.1. LLDT
Opcode 추가 시점 Mnemonic 설명 비고
0F 00 /2 80286 LLDT r/m16 Load segment selector r/m16 into LDTR
2.1.8.2. SLDT
Opcode 추가 시점 Mnemonic 설명 비고
0F 00 /0 80286 SLDT r/m16 Stores segment selector from LDTR in r/m16 [78]
80386 SLDT r32 Stores segment selector from LDTR in low-order 16 bits of r32
[78] 16-bit 레지스터 지정시 32-bit 모드에서는 66h 접두사 필요
2.1.8.3. LTR
Opcode 추가 시점 Mnemonic 설명 비고
0F 00 /3 80286 LTR r/m16 Load r/m16 into task register
2.1.8.4. STR
Opcode 추가 시점 Mnemonic 설명 비고
0F 00 /1 80286 STR r/m16 Stores segment selector from TR in r/m16
2.1.8.5. LGDT
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /2 80286 LGDT m16&32 Load m into GDTR
6-byte 메모리로부터 GDTR의 값을 불러온다. DEST[0:15]로부터 GDTR(Limit)을, DEST[16:48]로부터 GDTR(Base) 값을 불러오며 16-bit 모드 또는 66h 접두사가 붙은 경우 DEST[16:48]의 상위 8 bit 값을 무시한다(0으로 간주).
2.1.8.6. SGDT
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /0 80286 SGDT m Store GDTR to m
GDTR의 값이 6-byte 메모리에 기록되며, DEST[0:15]에 GDTR(Limit)이, 16-bit 또는 66h 접두사가 붙은 경우 DEST[16:39]에 GDTR(Base), DEST[40:47]에 0이, 32-bit의 겨우 DEST[16:48]에 GDTR(Base) 값이 기록된다.
2.1.8.7. LIDT
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /3 80286 LIDT m16&32 Load m into IDTR
6-byte 메모리로부터 IDTR의 값을 불러온다. DEST[0:15]로부터 IDTR(Limit)을, DEST[16:48]로부터 IDTR(Base) 값을 불러오며 16-bit 모드 또는 66h 접두사가 붙은 경우 DEST[16:48]의 상위 8 bit 값을 무시한다(0으로 간주).
2.1.8.8. SIDT
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /1 80286 SIDT m Store IDTR to m
IDTR의 값이 6-byte 메모리에 기록되며, DEST[0:15]에 IDTR(Limit)이, 16-bit 또는 66h 접두사가 붙은 경우 DEST[16:39]에 IDTR(Base), DEST[40:47]에 0이, 32-bit의 겨우 DEST[16:48]에 IDTR(Base) 값이 기록된다.
2.1.8.9. LMSW
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /6 80286 LMSW r/m16 Loads r/m16 in machine status word of CR0
2.1.8.10. SMSW
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /4 80286 SMSW r/m16 Store machine status word to r/m16 32-bit 모드에서는 66h 접두사 필요
80386 SMSW r32/m16 [79]
[79] Store machine status word in low-order 16 bits of r32/m16; high-order 16 bits of r32 are undefined
2.1.8.11. VERR
Opcode 추가 시점 Mnemonic 설명 비고
0F 00 /4 80286 VERR r/m16 Set ZF=1 if segment specified with r/m16 can be read
2.1.8.12. VERW
Opcode 추가 시점 Mnemonic 설명 비고
0F 00 /5 80286 VERW r/m16 Set ZF=1 if segment specified with r/m16 can be written
2.1.8.13. ARPL
Opcode 추가 시점 Mnemonic 설명 비고
63 /r 80286 ARPL r/m16,r16 Adjust RPL of r/m16 to not less than RPL of r16
2.1.8.14. LAR
Opcode 추가 시점 Mnemonic 설명 비고
0F 02 /r 80286 LAR r16,r/m16 32-bit 모드에서는 66h 접두사 필요
80386 LAR r32,r/m32
2.1.8.15. LSL
Opcode 추가 시점 Mnemonic 설명 비고
0F 03 /r 80286 LSL r16,r/m16 32-bit 모드에서는 66h 접두사 필요
80386 LSL r32,r/m32
2.1.8.16. CLTS
Opcode 추가 시점 Mnemonic 설명 비고
0F 06 80286 CLTS Clears TS flag in CR0
2.1.8.17. INVD
Opcode 추가 시점 Mnemonic 설명 비고
0F 08 80486 INVD [80]
내부 캐시에만 존재하고 메모리에 기록되지 않은 데이터는 사라지므로 WBINVD 명령어를 사용하는 것이 좋다.
[80] Flush internal caches; initiate flushing of external caches.
2.1.8.18. WBINVD
Opcode 추가 시점 Mnemonic 설명 비고
0F 09 80486 WBINVD [81]
[81] Write back and flush Internal caches; initiate writing-back and flushing of external caches.
2.1.8.19. INVLPG
Opcode 추가 시점 Mnemonic 설명 비고
0F 01 /7 80486 INVLPG m Invalidate TLB Entry for page that contains m
2.1.8.20. RSM
Opcode 추가 시점 Mnemonic 설명 비고
0F AA i386SL[82] RSM Resume operation of interrupted program
[82] i386SL/i486SL/후기 486 및 Pentium 이후 프로세서에서 지원된다.
2.1.8.21. RDMSR
Opcode 추가 시점 Mnemonic 설명 비고
0F 32 Pentium RDMSR Load MSR specified by ECX into EDX:EAX
2.1.8.22. WRMSR
Opcode 추가 시점 Mnemonic 설명 비고
0F 30 Pentium WRMSR Write the value in EDX:EAX to MSR specified by ECX
2.1.8.23. RDPMC
Opcode 추가 시점 Mnemonic 설명 비고
0F 33 Pentium MMX RDPMC [83]
[83] Read performance-monitoring counter specified by ECX into EDX:EAX
2.1.8.24. RDTSC
Opcode 추가 시점 Mnemonic 설명 비고
0F 31 Pentium RDTSC Read time-stamp counter into EDX:EAX
2.1.8.25. SYSENTER
Opcode 추가 시점 Mnemonic 설명 비고
0F 34 Pentium Pro SYSENTER Fast call to privilege level 0 system procedures
2.1.8.26. SYSEXIT
Opcode 추가 시점 Mnemonic 설명 비고
0F 35 Pentium Pro SYSEXIT Fast return to privilege level 3 user code.

2.1.9. x86 IO 명령어

2.1.9.1. IN
Opcode 추가 시점 Mnemonic 설명 비고
E4 8086/8088 IN al,imm8 Input byte from imm8 I/O port address into AL
E5 ib 8086/8088 IN ax,imm8 Input byte from imm8 I/O port address into AX 32-bit 모드에서는 66h 접두사 필요
80386 IN eax,imm8 Input byte from imm8 I/O port address into EAX
EC 8086/8088 IN al,dx Input byte from I/O port in DX into AL
ED 8086/8088 IN ax,dx Input word from I/O port in DX into AX 32-bit 모드에서는 66h 접두사 필요
80386 IN eax,dx Input doubleword from I/O port in DX into EAX
2.1.9.2. OUT
Opcode 추가 시점 Mnemonic 설명 비고
E6 8086/8088 OUT imm8,al Output byte in AL to I/O port address imm8
E7 ib 8086/8088 OUT imm8,ax Output word in AX to I/O port address imm8 32-bit 모드에서는 66h 접두사 필요
80386 OUT imm8,eax Output doubleword in EAX to I/O port address imm8
EC 8086/8088 OUT dx,al Output byte in AL to I/O port address in DX
ED 8086/8088 OUT dx,ax Output word in AX to I/O port address in DX 32-bit 모드에서는 66h 접두사 필요
80386 OUT dx,eax Output doubleword in EAX to I/O port address in DX

2.1.10. 비트 조작 명령어

2.1.10.1. BT
Opcode 추가 시점 Mnemonic 설명 비고
0F A3 80386 BT r/m16,r16 Store selected bit in CF flag 32-bit 모드에서는 66h 접두사 필요
BT r/m32,r32
0F BA /4 ib 80386 BT r/m16,imm8 Store selected bit in CF flag 32-bit 모드에서는 66h 접두사 필요
BT r/m32,imm8
2.1.10.2. BTS
Opcode 추가 시점 Mnemonic 설명 비고
0F AB 80386 BTS r/m16,r16 Store selected bit in CF flag and set 32-bit 모드에서는 66h 접두사 필요
BTS r/m32,r32
0F BA /5 ib 80386 BTS r/m16,imm8 Store selected bit in CF flag and set 32-bit 모드에서는 66h 접두사 필요
BTS r/m32,imm8
2.1.10.3. BTR
Opcode 추가 시점 Mnemonic 설명 비고
0F B3 80386 BTR r/m16,r16 Store selected bit in CF flag and clear 32-bit 모드에서는 66h 접두사 필요
BTR r/m32,r32
0F BA /6 ib 80386 BTR r/m16,imm8 Store selected bit in CF flag and clear 32-bit 모드에서는 66h 접두사 필요
BTR r/m32,imm8
2.1.10.4. BTC
Opcode 추가 시점 Mnemonic 설명 비고
0F BB 80386 BTC r/m16,r16 Store selected bit in CF flag and complement 32-bit 모드에서는 66h 접두사 필요
BTC r/m32,r32
0F BA /7 ib 80386 BTC r/m16,imm8 Store selected bit in CF flag and complement 32-bit 모드에서는 66h 접두사 필요
BTC r/m32,imm8
2.1.10.5. BSF
Opcode 추가 시점 Mnemonic 설명 비고
0F BC 80386 BSF r16,r/m16 Bit scan forward on r/m16 32-bit 모드에서는 66h 접두사 필요
BSF r32,r/m32 Bit scan forward on r/m32
Source의 least significant set bit를 찾아 그 위치를 저장한다.
2.1.10.6. BSR
Opcode 추가 시점 Mnemonic 설명 비고
0F BD 80386 BSR r16,r/m16 Bit scan reverse on r/m16 32-bit 모드에서는 66h 접두사 필요
BSR r32,r/m32 Bit scan reverse on r/m32
Source의 most significant set bit를 찾아 그 위치를 저장한다.

2.1.11. 문자열 조작 명령어

2.1.11.1. REP prefix
Opcode 추가 시점 Mnemonic 해당 명령어 중단 조건 1 중단 조건 2 비고
F3 8086/8088 REP INS, OUTS, MOVS, LODS, STOS ECX=0 None
8086/8088 REPE
REPZ 		CMPS, SCAS ECX=0 ZF=0 Find nonmatching
F2 8086/8088 REPNE
REPNZ 		CMPS, SCAS ECX=0 ZF=1 Find matching
2.1.11.2. MOVS/MOVSB/MOVSW/MOVSD
Opcode 추가 시점 Mnemonic 설명 비고
A4 8086/8088 MOVS m8,m8
MOVSB 		[84]
A5 8086/8088 MOVS m16,m16
MOVSW 		[85] 32-bit 모드에서는 66h 접두사 필요
80386 MOVS m32,m32
MOVSD 		[86]
[84] Move byte at address DS:(E)SI to address ES:(E)DI[85] Move word at address DS:(E)SI to address ES:(E)DI[86] Move doubleword at address DS:(E)SI to address ES:(E)DI
2.1.11.3. CMPS/CMPSB/CMPSW/CMPSD
Opcode 추가 시점 Mnemonic 설명 비고
A6 8086/8088 CMPS m8,m8
CMPSB 		[87]
A7 8086/8088 CMPS m16,m16
CMPSW 		[88] 32-bit 모드에서는 66h 접두사 필요
80386 CMPS m32,m32
CMPSD 		[89]
[87] Compares byte at address DS:(E)SI with byte at address ES:(E)DI and sets the status flags accordingly[88] Compares word at address DS:(E)SI with word at address ES:(E)DI and sets the status flags accordingly[89] Compares doubleword at address DS:(E)SI with doubleword at address ES:(E)DI and sets the status flags accordingly
2.1.11.4. LODS/LODSB/LODSW/LODSD
Opcode 추가 시점 Mnemonic 설명 비고
AC 8086/8088 LODS m8
LODSB 		[90]
AD 8086/8088 LODS m16
LODSW 		[91] 32-bit 모드에서는 66h 접두사 필요
80386 LODS m32
LODSD 		[92]
[90] Load byte at address DS:(E)SI into AL[91] Load word at address DS:(E)SI into AX[92] Load doubleword at address DS:(E)SI into EAX
2.1.11.5. SCAS/SCASB/SCASW/SCASD
Opcode 추가 시점 Mnemonic 설명 비고
AE 8086/8088 SCAS m8
SCASB 		[93]
AF 8086/8088 SCAS m16
SCASW 		[94] 32-bit 모드에서는 66h 접두사 필요
80386 SCAS m32
SCASD 		[95]
[93] Compare AL with byte at ES:(E)DI and set status flags[94] Compare AX with word at ES:(E)DI and set status flags[95] Compare EAX with doubleword at ES(E)DI and set status flags
2.1.11.6. STOS/STOSB/STOSW/STOSD
Opcode 추가 시점 Mnemonic 설명 비고
AA 8086/8088 STOS m8
STOSB 		[96]
AB 8086/8088 STOS m16
STOSW 		[97] 32-bit 모드에서는 66h 접두사 필요
80386 STOS m32
STOSD 		[98]
[96] Store AL at address ES:(E)DI[97] Store AX at address ES:(E)DI[98] Store EAX at address ES:(E)DI
2.1.11.7. INS/INSB/INSW/INSD
Opcode 추가 시점 Mnemonic 설명 비고
6C 80186 INS m8,dx
INSB 		[99]
6D 80186 INS m16,dx
INSW 		[100] 32-bit 모드에서는 66h 접두사 필요
80386 INS m32,dx
INSD 		[101]
[99] Input byte from I/O port specified in DX into memory location specified in ES:(E)DI[100] Input word from I/O port specified in DX into memory location specified in ES:(E)DI[101] Input doubleword from I/O port specified in DX into memory location specified in ES:(E)DI
2.1.11.8. OUTS/OUTSB/OUTSW/OUTSD
Opcode 추가 시점 Mnemonic 설명 비고
6E 80186 OUTS dx,m8
OUTSB 		[102]
6F 80186 OUTS dx,m16
OUTSW 		[103] 32-bit 모드에서는 66h 접두사 필요
80386 OUTS dx,m32
OUTSD 		[104]
[102] Output byte from memory location specified in DS:(E)SI to I/O port specified in DX[103] Output word from memory location specified in DS:(E)SI to I/O port specified in DX[104] Output doubleword from memory location specified in DS:(E)SI to I/O port specified in DX

2.1.12. BCD 명령어

2.1.12.1. AAA
Opcode 추가 시점 Mnemonic 설명 비고
37 8086/8088 AAA ASCII adjust AL after addition
2.1.12.2. AAS
Opcode 추가 시점 Mnemonic 설명 비고
3F 8086/8088 AAS ASCII adjust AL after subtraction
2.1.12.3. AAM
Opcode 추가 시점 Mnemonic 설명 비고
D4 0A 8086/8088 AAM ASCII adjust AX after multiply
D4 ib 8086/8088 (No mnemonic) Adjust AX after multiply to number base imm8
2.1.12.4. AAD
Opcode 추가 시점 Mnemonic 설명 비고
D5 0A 8086/8088 AAD ASCII adjust AX before division
D5 ib 8086/8088 (No mnemonic) Adjust AX before division to number base imm8
2.1.12.5. DAA
Opcode 추가 시점 Mnemonic 설명 비고
27 8086/8088 DAA Decimal adjust AL after addition
예: 79h + 35h = AEh → 14h (DAA)
2.1.12.6. DAS
Opcode 추가 시점 Mnemonic 설명 비고
2F 8086/8088 DAS Decimal adjust AL after subtraction
예: 35h - 47h = EEh → 88h (DAS)

2.2. x87 FPU 명령어

2.2.1. x87 메모리 명령어

2.2.1.1. FLD
Opcode 추가 시점 Mnemonic 설명 비고
D9 /0 8087 FLD m32fp PUSH(m32fp)
DD /0 FLD m64fp PUSH(m64fp)
DB /5 8087 FLD m80fp PUSH(m80fp)
D9 C0+i 8087 FLD st(i) PUSH(st(i))
2.2.1.2. FST
Opcode 추가 시점 Mnemonic 설명 비고
D9 /2 8087 FST m32fp m32fp = st(0)
DD /2 FST m64fp m64fp = st(0)
DD D0+i 8087 FST st(i) st(i) = st(0)
2.2.1.3. FSTP
Opcode 추가 시점 Mnemonic 설명 비고
D9 /3 8087 FSTP m32fp m32fp = st(0); POP()
DD /3 FSTP m64fp m64fp = st(0); POP()
DB /7 8087 FSTP m80fp m80fp = st(0); POP()
DD D8+i 8087 FST st(i) st(i) = st(0); POP() [105]
[105] DF D0+i 등 비공식적인 opcode가 존재한다.
2.2.1.4. FXCH
Opcode 추가 시점 Mnemonic 설명 비고
D9 C8+i 8087 FXCH st(i) st(0) <-> st(i) [106]
D9 C9 FXCH st(0) <-> st(1)
[106] DD C8+i 등 비공식적인 opcode가 존재한다.
2.2.1.5. FCMOVcc
Opcode 추가 시점 Mnemonic 설명 비고
DA C0+i Pentium Pro FCMOVB st(0),st(i) Move if below (CF=1)
DA C8+i FCMOVE st(0),st(i) Move if equal (ZF=1)
DA D0+i FCMOVBE st(0),st(i) Move if below or equal (CF=1 or ZF=1)
DA D8+i FCMOVU st(0),st(i) Move if unordered (PF=1)
DB C0+i FCMOVNB st(0),st(i) Move if not below (CF=0)
DB C8+i FCMOVNE st(0),st(i) Move if not equal (ZF=0)
DB D0+i FCMOVNBE st(0),st(i) Move if not below or equal (CF=0 and ZF=0)
DB D8+i FCMOVNU st(0),st(i) Move if not unordered (PF=0)
EFLAGS 레지스터에 있는 상태 플래그의 값에 따라 이동 연산을 수행한다.
2.2.1.6. FILD
Opcode 추가 시점 Mnemonic 설명 비고
DF /0 8087 FILD m16int PUSH(m16int)
DB /0 FILD m32int PUSH(m32int)
DF /5 8087 FILD m64int PUSH(m64int)
2.2.1.7. FIST
Opcode 추가 시점 Mnemonic 설명 비고
DF /2 8087 FIST m16int m16int = st(0)
DB /2 FIST m32int m32int = st(0)
2.2.1.8. FISTP
Opcode 추가 시점 Mnemonic 설명 비고
DF /3 8087 FISTP m16int m16int = st(0); POP()
DB /3 FISTP m32int m32int = st(0); POP()
DF /7 8087 FISTP m64int m64int = st(0); POP()
2.2.1.9. FISTTP
Opcode 추가 시점 Mnemonic 설명 비고
DF /1 SSE3 FISTTP m16int m16int = st(0); POP()
DB /1 FISTTP m32int m32int = st(0); POP()
DD /1 FISTTP m64int m64int = st(0); POP()
2.2.1.10. FBLD
Opcode 추가 시점 Mnemonic 설명 비고
DF /4 8087 FBLD m80bcd PUSH(m80bcd)
2.2.1.11. FBSTP
Opcode 추가 시점 Mnemonic 설명 비고
DF /6 8087 FBSTP m80bcd m80bcd = st(0); POP()
2.2.1.12. FLD1/FLDL2T/FLDL2E/FLDPI/FLDLG2/FLDLN2/FLDZ
Opcode 추가 시점 Mnemonic 설명 비고
D9 E8 8087 FLD1 Push [math(+1.0)] onto the FPU register stack.
D9 E9 FLDL2T Push [math(\log_2 10)] onto the FPU register stack.
D9 EA FLDL2E Push [math(\log_2 e)] onto the FPU register stack.
D9 EB FLDPI Push [math(\pi)] onto the FPU register stack.
D9 EC FLDLG2 Push [math(\log_{10} 2)] onto the FPU register stack.
D9 ED FLDLN2 Push [math(\log_e 2)] onto the FPU register stack.
D9 EE FLDZ Push [math(+0.0)] onto the FPU register stack.

2.2.2. x87 사칙연산 명령어

2.2.2.1. FADD
Opcode 추가 시점 Mnemonic 설명 비고
D8 /0 8087 FADD m32fp st(0) += m32fp
DC /0 FADD m64fp st(0) += m64fp
D8 C0+i 8087 FADD st(0), st(i) st(0) += st(i)
DC C0+i 8087 FADD st(i), st(0) st(i) += st(0)
2.2.2.2. FADDP
Opcode 추가 시점 Mnemonic 설명 비고
DE C0+i 8087 FADDP st(i), st(0) st(i) += st(0); POP()
DE C1 FADDP st(1) += st(0); POP()
2.2.2.3. FSUB
Opcode 추가 시점 Mnemonic 설명 비고
D8 /4 8087 FSUB m32fp st(0) -= m32fp
DC /4 FSUB m64fp st(0) -= m64fp
D8 E0+i 8087 FSUB st(0), st(i) st(0) -= st(i)
DC E8+i 8087 FSUB st(i), st(0) st(i) -= st(0)
2.2.2.4. FSUBP
Opcode 추가 시점 Mnemonic 설명 비고
DE E8+i 8087 FSUBP st(i), st(0) st(i) -= st(0); POP()
DE E9 FSUBP st(1) -= st(0); POP()
2.2.2.5. FSUBR
Opcode 추가 시점 Mnemonic 설명 비고
D8 /5 8087 FSUBR m32fp st(0) = m32fp - st(0)
DC /5 FSUBR m64fp st(0) = m64fp - st(0)
D8 E8+i 8087 FSUBR st(0), st(i) st(0) = st(i) - st(0)
DC E0+i 8087 FSUBR st(i), st(0) st(i) = st(0) - st(i)
2.2.2.6. FSUBRP
Opcode 추가 시점 Mnemonic 설명 비고
DE E0+i 8087 FSUBRP st(i), st(0) st(i) = st(0) - st(i); POP()
DE E1 FSUBRP st(1) = st(0) - st(1); POP()
2.2.2.7. FMUL
Opcode 추가 시점 Mnemonic 설명 비고
D8 /1 8087 FMUL m32fp st(0) *= m32fp
DC /1 FMUL m64fp st(0) *= m64fp
D8 C8+i 8087 FMUL st(0), st(i) st(0) *= st(i)
DC C8+i 8087 FMUL st(i), st(0) st(i) *= st(0)
2.2.2.8. FMULP
Opcode 추가 시점 Mnemonic 설명 비고
DE C8+i 8087 FMULP st(i), st(0) st(i) *= st(0); POP()
DE C9 FMULP st(1) *= st(0); POP()
2.2.2.9. FDIV
Opcode 추가 시점 Mnemonic 설명 비고
D8 /6 8087 FDIV m32fp st(0) /= m32fp
DC /6 FDIV m64fp st(0) /= m64fp
D8 F0+i 8087 FDIV st(0), st(i) st(0) /= st(i)
DC F8+i 8087 FDIV st(i), st(0) st(i) /= st(0)
2.2.2.10. FDIVP
Opcode 추가 시점 Mnemonic 설명 비고
DE F8+i 8087 FDIVP st(i), st(0) st(i) /= st(0); POP()
DE F9 FDIVP st(1) /= st(0); POP()
2.2.2.11. FDIVR
Opcode 추가 시점 Mnemonic 설명 비고
D8 /7 8087 FDIVR m32fp st(0) = m32fp / st(0)
DC /7 FDIVR m64fp st(0) = m64fp / st(0)
D8 F8+i 8087 FDIVR st(0), st(i) st(0) = st(i) / st(0)
DC F0+i 8087 FDIVR st(i), st(0) st(i) = st(0) / st(i)
2.2.2.12. FDIVRP
Opcode 추가 시점 Mnemonic 설명 비고
DE F0+i 8087 FDIVRP st(i), st(0) st(i) = st(0) / st(i); POP()
DE F1 FDIVRP st(1) = st(0) / st(1); POP()
2.2.2.13. FCHS
Opcode 추가 시점 Mnemonic 설명 비고
D9 E0 8087 FCHS st(0) = -st(0)
2.2.2.14. FABS
Opcode 추가 시점 Mnemonic 설명 비고
D9 E1 8087 FABS Replace ST(0) with its absolute value.
2.2.2.15. FSQRT
Opcode 추가 시점 Mnemonic 설명 비고
D9 FA 8087 FABS Computes square root of ST(0) and stores the result in ST(0).
2.2.2.16. FPREM
Opcode 추가 시점 Mnemonic 설명 비고
D9 F8 8087 FPREM st(0) −= (Q ∗ st(1)) Truncate
2.2.2.17. FPREM1
Opcode 추가 시점 Mnemonic 설명 비고
D9 F5 80387 FPREM1 st(0) −= (Q ∗ st(1)) Round to nearest (IEEE-754 compliant)
2.2.2.18. FRNDINT
Opcode 추가 시점 Mnemonic 설명 비고
D9 FC 8087 FRNDINT Round ST(0) to an integer.
2.2.2.19. FXTRACT
Opcode 추가 시점 Mnemonic 설명 비고
D9 F4 8087 FXTRACT st(0) = Exponent(ST), PUSH(Significand(ST))
2.2.2.20. FIADD
Opcode 추가 시점 Mnemonic 설명 비고
DA /0 8087 FIADD m32int st(0) += m32int
DE /0 FIADD m16int st(0) += m16int
2.2.2.21. FISUB
Opcode 추가 시점 Mnemonic 설명 비고
DA /4 8087 FISUB m32int st(0) -= m32int
DE /4 FISUB m16int st(0) -= m16int
2.2.2.22. FISUBR
Opcode 추가 시점 Mnemonic 설명 비고
DA /5 8087 FISUBR m32int st(0) = m32int - st(0)
DE /5 FISUBR m16int st(0) = m16int - st(0)
2.2.2.23. FIMUL
Opcode 추가 시점 Mnemonic 설명 비고
DA /1 8087 FIMUL m32int st(0) *= m32int
DE /1 FIMUL m16int st(0) *= m16int
2.2.2.24. FIDIV
Opcode 추가 시점 Mnemonic 설명 비고
DA /6 8087 FIDIV m32int st(0) /= m32int
DE /6 FIDIV m16int st(0) /= m16int
2.2.2.25. FIDIVR
Opcode 추가 시점 Mnemonic 설명 비고
DA /7 8087 FIDIVR m32int st(0) = m32int / st(0)
DE /7 FIDIVR m16int st(0) = m16int / st(0)

2.2.3. x87 비교 명령어

2.2.3.1. FCOM/FCOMP/FCOMPP
Opcode 추가 시점 Mnemonic 설명 비고
D8 /2 8087 FCOM m32fp Compare ST(0) with m32fp.
DC /2 FCOM m64fp Compare ST(0) with m64fp.
D8 D0+i 8087 FCOM st(i) Compare ST(0) with ST(i). [107]
D8 D1 FCOM Compare ST(0) with ST(1).
D8 /3 8087 FCOMP m32fp Compare ST(0) with m32fp and pop register stack.
DC /3 FCOMP m64fp Compare ST(0) with m64fp and pop register stack.
D8 D8+i 8087 FCOMP st(i) Compare ST(0) with ST(i) and pop register stack. [108]
D8 D9 FCOMP Compare ST(0) with ST(1) and pop register stack.
DE D9 8087 FCOMPP Compare ST(0) with ST(1) and pop register stack twice.
[107] DC D0+i 등 비공식적인 opcode가 존재한다.[108] DC D8+i, DE D0+i 등 비공식적인 opcode가 존재한다.
2.2.3.2. FUCOM/FUCOMP/FUCOMPP
Opcode 추가 시점 Mnemonic 설명 비고
DD E0+i 80387 FUCOM st(i) Compare ST(0) with ST(i)
DD E1 FUCOM Compare ST(0) with ST(1)
DD E8+i 80387 FUCOMP st(i) Compare ST(0) with ST(i) and pop register stack
DD E9 FUCOMP Compare ST(0) with ST(1) and pop register stack
DA E9 80387 FUCOMPP Compare ST(0) with ST(1) and pop register stack twice
2.2.3.3. FICOM/FICOMP
Opcode 추가 시점 Mnemonic 설명 비고
DE /2 8087 FICOM m16int Compare ST(0) with m16int
DA /2 FICOM m32int Compare ST(0) with m32int
DE /3 8087 FICOMP m16int Compare ST(0) with m16int and pop stack register
DA /3 FICOMP m32int Compare ST(0) with m32int and pop stack register
2.2.3.4. FCOMI/FCOMIP/FUCOMI/FUCOMIP
Opcode 추가 시점 Mnemonic 설명 비고
DB F0+i Pentium Pro FCOMI st(0),st(i) [109]
DF F0+i Pentium Pro FCOMIP st(0),st(i) [110]
DB E8+i Pentium Pro FUCOMI st(0),st(i) [111]
DF E8+i Pentium Pro FUCOMIP st(0),st(i) [112]
[109] Compare ST(0) with ST(i) and set status flags accordingly[110] Compare ST(0) with ST(i), set status flags accordingly, and pop register stack[111] Compare ST(0) with ST(i), check for ordered values, and set status flags accordingly[112] Compare ST(0) with ST(i), check for ordered values, set status flags accordingly, and pop register stack
2.2.3.5. FTST
Opcode 추가 시점 Mnemonic 설명 비고
D9 E4 8087 FTST Compare ST(0) with 0.0.
2.2.3.6. FXAM
Opcode 추가 시점 Mnemonic 설명 비고
D9 E5 8087 FXAM Classify value or number in ST(0)

2.2.4. x87 특수 함수 명령어

2.2.4.1. FSIN
Opcode 추가 시점 Mnemonic 설명 비고
D9 FE 80387 FSIN Replace ST(0) with its sine.
2.2.4.2. FCOS
Opcode 추가 시점 Mnemonic 설명 비고
D9 FF 80387 FCOS Replace ST(0) with its cosine
2.2.4.3. FSINCOS
Opcode 추가 시점 Mnemonic 설명 비고
D9 FB 80387 FSINCOS [113]
[113] Compute the sine and cosine of ST(0); replace ST(0) with the sine, and push the cosine onto the register stack.
2.2.4.4. FPTAN
Opcode 추가 시점 Mnemonic 설명 비고
D9 F2 8087 FPTAN Replace ST(0) with its tangent and push 1 onto the FPU stack.
2.2.4.5. FPATAN
Opcode 추가 시점 Mnemonic 설명 비고
D9 F3 8087 FPATAN Replace ST(1) with arctan(ST(1)/ST(0)) and pop the register stack
2.2.4.6. FYL2X
Opcode 추가 시점 Mnemonic 설명 비고
D9 F1 8087 FYL2X Replace [math(\textrm{ST}(1))] with [math((\textrm{ST}(1) ∗ \log_2 \textrm{ST}(0)))] and pop the register stack
2.2.4.7. FYL2XP1
Opcode 추가 시점 Mnemonic 설명 비고
D9 F9 8087 FYL2XP1 Replace [math(\textrm{ST}(1))] with [math(\textrm{ST}(1) ∗ \log_2(\textrm{ST}(0) + 1.0))] and pop the register stack
2.2.4.8. F2XM1
Opcode 추가 시점 Mnemonic 설명 비고
D9 F0 8087 F2XM1 Replace [math(\textrm{ST}(0))] with [math(2^{\textrm{ST}(0)} – 1)]
2.2.4.9. FSCALE
Opcode 추가 시점 Mnemonic 설명 비고
D9 FD 8087 FSCALE Scale ST(0) by ST(1).

2.2.5. x87 FPU 제어 명령어

2.2.5.1. FINCSTP
Opcode 추가 시점 Mnemonic 설명 비고
D9 F7 8087 FINCSTP Increment the TOP field in the FPU status register
2.2.5.2. FDECSTP
Opcode 추가 시점 Mnemonic 설명 비고
D9 F6 8087 FDECSTP Decrement TOP field in FPU status word.
2.2.5.3. FFREE
Opcode 추가 시점 Mnemonic 설명 비고
DD C0+i 8087 FFREE st(i) Sets tag for ST(i) to empty
2.2.5.4. FINIT/FNINIT
Opcode 추가 시점 Mnemonic 설명 비고
9B DB E3 8087 FINIT [114]
DB E3 8087 FNINIT [115]
[114] Initialize FPU after checking for pending unmasked floating-point exceptions.[115] Initialize FPU without checking for pending unmasked floating-point exceptions.
2.2.5.5. FCLEX/FNCLEX
Opcode 추가 시점 Mnemonic 설명 비고
9B DB E2 8087 FCLEX [116]
DB E2 8087 FNCLEX [117]
[116] Clear floating-point exception flags after checking for pending unmasked floating-point exceptions.[117] Clear floating-point exception flags without checking for pending unmasked floating-point exceptions.
2.2.5.6. FSTCW/FNSTCW
Opcode 추가 시점 Mnemonic 설명 비고
9B D9 /7 8087 FSTCW m2byte [118]
D9 /7 8087 FNSTCW m2byte [119]
[118] Store FPU control word to m2byte after checking for pending unmasked floating-point exceptions.[119] Store FPU control word to m2byte without checking for pending unmasked floating-point exceptions.
2.2.5.7. FLDCW
Opcode 추가 시점 Mnemonic 설명 비고
D9 /5 8087 FLDCW m2byte [120]
2.2.5.8. FSTENV/FNSTENV
Opcode 추가 시점 Mnemonic 설명 비고
9B D9 /6 8087 FSTENV m14byte [121] 32-bit 모드에서는 66h 접두사 필요
80387 FSTENV m28byte [122]
D9 /6 8087 FNSTENV m14byte [123] 32-bit 모드에서는 66h 접두사 필요
80387 FNSTENV m28byte [124]
[120] Load FPU control word from m2byte.[121] Store FPU environment to m14byte after checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.[122] Store FPU environment to m28byte after checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.[123] Store FPU environment to m14byte without checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.[124] Store FPU environment to m28byte without checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.
2.2.5.9. FLDENV
Opcode 추가 시점 Mnemonic 설명 비고
D9 /4 8087 FLDENV m14byte [125] 32-bit 모드에서는 66h 접두사 필요
80387 FLDENV m28byte [126]
[125] Load FPU environment from m14byte.[126] Load FPU environment from m28byte.
2.2.5.10. FSAVE/FNSAVE
Opcode 추가 시점 Mnemonic 설명 비고
9B DD /6 8087 FSAVE m94byte [127] 32-bit 모드에서는 66h 접두사 필요
80387 FSAVE m108byte [128]
DD /6 8087 FNSAVE m94byte [129] 32-bit 모드에서는 66h 접두사 필요
80387 FNSAVE m108byte [130]
[127] Store FPU state to m94byte after checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.[128] Store FPU state to m108byte after checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.[129] Store FPU state to m94byte without checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.[130] Store FPU state to m108byte without checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.
2.2.5.11. FRSTOR
Opcode 추가 시점 Mnemonic 설명 비고
DD /4 8087 FRSTOR m94byte [131] 32-bit 모드에서는 66h 접두사 필요
80387 FRSTOR m108byte [132]
[131] Load FPU state from m94byte.[132] Load FPU state from m108byte.
2.2.5.12. FSTSW/FNSTSW
Opcode 추가 시점 Mnemonic 설명 비고
9B DD /7 8087 FSTSW m2byte [133]
9B DF E0 80287 FSTSW ax [134]
DD /7 8087 FNSTSW m2byte [135]
DF E0 80287 FNSTSW ax [136]
[133] Store FPU status word at m2byte after checking for pending unmasked floating-point exceptions.[134] Store FPU status word in AX register after checking for pending unmasked floating-point exceptions.[135] Store FPU status word at m2byte without checking for pending unmasked floating-point exceptions.[136] Store FPU status word in AX register without checking for pending unmasked floating-point exceptions.
2.2.5.13. FNOP
Opcode 추가 시점 Mnemonic 설명 비고
D9 D0 8087 FNOP No operation is performed.
2.2.5.14. FXSAVE
Opcode 추가 시점 Mnemonic 설명 비고
0F AE /0 Pentium II FXSAVE m512byte [137]
[137] Save the x87 FPU, MMX technology, XMM, and MXCSR register state to m512byte
2.2.5.15. FXRSTOR
Opcode 추가 시점 Mnemonic 설명 비고
0F AE /1 Pentium II FXRSTOR m512byte [138]
[138] Restore the x87 FPU, MMX technology, XMM, and MXCSR register state from m512byte.

3. SIMD 명령어 목록

스트리밍 SIMD 확장 문서 참조

3.1. MMX 확장

  • AMD에서 만든 대응 명령어 3DNow!는 사실상 사장되었다.
  • 인텔 IA-32 소프트웨어 개발자 매뉴얼에서는 SSE에 포함된 MMX 명령어 또한 MMX 명령어로 분류하므로 이 또한 MMX 문단에 작성하나, SSE 확장과 함께 추가되었음을 명시한다. (NP: No Prefix. 접두사 없음.)

3.1.1. MMX 메모리 및 변환 명령어

3.1.1.1. MOVD
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 6E /r Pentium MMX MOVD mm,r/m32 mm = r/m32
NP 0F 7E /r Pentium MMX MOVD r/m32,mm r/m32 = mm
66 0F 6E /r Pentium 4 (SSE2) MOVD xmm,r/m32 xmm = r/m32
66 0F 7E /r Pentium 4 (SSE2) MOVD r/m32,xmm r/m32 = xmm
3.1.1.2. MOVQ
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 6F /r Pentium MMX MOVQ mm,mm/m64 mm = mm/m64
NP 0F 7F /r Pentium MMX MOVQ mm/m64,mm mm/m64 = mm
F3 0F 7E /r Pentium 4 (SSE2) MOVQ xmm1,xmm2/m64 xmm1 = xmm2/m64
66 0F D6 /r Pentium 4 (SSE2) MOVQ xmm2/m64,xmm1 xmm2/m64 = xmm1
3.1.1.3. PACKSSWB
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 63 /r Pentium MMX PACKSSWB mm1,mm2/m64
66 0F 63 /r Pentium 4 (SSE2) PACKSSWB xmm1,xmm2/m128
3.1.1.4. PACKSSDW
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 6B /r Pentium MMX PACKSSDW mm1,mm2/m64
66 0F 6B /r Pentium 4 (SSE2) PACKSSDW xmm1,xmm2/m128
3.1.1.5. PACKUSWB
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 67 /r Pentium MMX PACKUSWB mm1,mm2/m64
66 0F 67 /r Pentium 4 (SSE2) PACKUSWB xmm1,xmm2/m128
3.1.1.6. PUNPCKHBW
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 68 /r Pentium MMX PUNPCKHBW mm1,mm2/m64
66 0F 68 /r Pentium 4 (SSE2) PUNPCKHBW xmm1,xmm2/m128
3.1.1.7. PUNPCKHWD
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 69 /r Pentium MMX PUNPCKHWD mm1,mm2/m64
66 0F 69 /r Pentium 4 (SSE2) PUNPCKHWD xmm1,xmm2/m128
3.1.1.8. PUNPCKHDQ
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 6A /r Pentium MMX PUNPCKHDQ mm1,mm2/m64
66 0F 6A /r Pentium 4 (SSE2) PUNPCKHDQ xmm1,xmm2/m128
3.1.1.9. PUNPCKLBW
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 60 /r Pentium MMX PUNPCKLBW mm1,mm2/m32
66 0F 60 /r Pentium 4 (SSE2) PUNPCKLBW xmm1,xmm2/m128
3.1.1.10. PUNPCKLWD
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 61 /r Pentium MMX PUNPCKLWD mm1,mm2/m32
66 0F 61 /r Pentium 4 (SSE2) PUNPCKLWD xmm1,xmm2/m128
3.1.1.11. PUNPCKLDQ
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 62 /r Pentium MMX PUNPCKLDQ mm1,mm2/m32
66 0F 62 /r Pentium 4 (SSE2) PUNPCKLDQ xmm1,xmm2/m128

3.1.2. MMX Packed Arithmetic 명령어

3.1.2.1. PADDB/PADDW/PADDD
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F FC /r Pentium MMX PADDW mm,mm/m64 mm += mm/m64
NP 0F FD /r PADDD mm,mm/m64
NP 0F FE /r PADDQ mm,mm/m64
66 0F FC /r Pentium 4 (SSE2) PADDW xmm1,xmm2/m128 xmm1 += xmm2/m128
66 0F FD /r PADDD xmm1,xmm2/m128
66 0F FE /r PADDQ xmm1,xmm2/m128
3.1.2.2. PADDSB/PADDSW
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F EC /r Pentium MMX PADDSB mm,mm/m64 mm += mm/m64
NP 0F ED /r PADDSW mm,mm/m64
66 0F EC /r Pentium 4 (SSE2) PADDSB xmm1,xmm2/m128 xmm1 += xmm2/m128
66 0F ED /r PADDSW xmm1,xmm2/m128
3.1.2.3. PADDUSB/PADDUSW
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F DC /r Pentium MMX PADDUSB mm,mm/m64 mm += mm/m64
NP 0F DD /r PADDUSW mm,mm/m64
66 0F DC /r Pentium 4 (SSE2) PADDUSB xmm1,xmm2/m128 xmm1 += xmm2/m128
66 0F DD /r PADDUSW xmm1,xmm2/m128
3.1.2.4. PSUBB/PSUBW/PSUBD
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F F8 /r Pentium MMX PSUBW mm,mm/m64 mm -= mm/m64
NP 0F F9 /r PSUBD mm,mm/m64
NP 0F FA /r PSUBQ mm,mm/m64
66 0F F8 /r Pentium 4 (SSE2) PSUBW xmm1,xmm2/m128 xmm1 -= xmm2/m128
66 0F F9 /r PSUBD xmm1,xmm2/m128
66 0F FA /r PSUBQ xmm1,xmm2/m128
3.1.2.5. PSUBSB/PSUBSW
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F E8 /r Pentium MMX PSUBSB mm,mm/m64 mm -= mm/m64
NP 0F E9 /r PSUBSW mm,mm/m64
66 0F E8 /r Pentium 4 (SSE2) PSUBSB xmm1,xmm2/m128 xmm1 -= xmm2/m128
66 0F E9 /r PSUBSW xmm1,xmm2/m128
3.1.2.6. PSUBUSB/PSUBUSW
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F D8 /r Pentium MMX PSUBUSB mm,mm/m64 mm -= mm/m64
NP 0F D9 /r PSUBUSW mm,mm/m64
66 0F D8 /r Pentium 4 (SSE2) PSUBUSB xmm1,xmm2/m128 xmm1 -= xmm2/m128
66 0F D9 /r PSUBUSW xmm1,xmm2/m128
3.1.2.7. PMULHW
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F E5 /r Pentium MMX PMULHW mm,mm/m64
66 0F E5 /r Pentium 4 (SSE2) PMULHW xmm1,xmm2/m128
3.1.2.8. PMULLW
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F D5 /r Pentium MMX PMULLW mm,mm/m64
66 0F D5 /r Pentium 4 (SSE2) PMULLW xmm1,xmm2/m128
3.1.2.9. PMADDWD
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F F5 /r Pentium MMX PMADDWD mm,mm/m64 [* 
DEST[31:0] ← (DEST[15:0] ∗ SRC[15:0]) + (DEST[31:16] ∗ SRC[31:16]);
DEST[63:32] ← (DEST[47:32] ∗ SRC[47:32]) + (DEST[63:48] ∗ SRC[63:48]);
]
66 0F F5 /r Pentium 4 (SSE2) PMADDWD xmm1,xmm2/m128 [* 
DEST[31:0] ← (DEST[15:0] ∗ SRC[15:0]) + (DEST[31:16] ∗ SRC[31:16]);
DEST[63:32] ← (DEST[47:32] ∗ SRC[47:32]) + (DEST[63:48] ∗ SRC[63:48]);
DEST[95:64] ← (DEST[79:64] ∗ SRC[79:64]) + (DEST[95:80] ∗ SRC[95:80]);
DEST[127:96] ← (DEST[111:96] ∗ SRC[111:96]) + (DEST[127:112] ∗ SRC[127:112]);
]

3.1.3. MMX Comparison 명령어

3.1.3.1. PCMPEQB/PCMPEQW/PCMPEQD
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 74 /r Pentium MMX PCMPEQB mm,mm/m64 mm == mm/m64
NP 0F 75 /r PCMPEQW mm,mm/m64
NP 0F 76 /r PCMPEQD mm,mm/m64
66 0F 74 /r Pentium 4 (SSE2) PCMPEQB xmm1,xmm2/m128 xmm1 == xmm2/m128
66 0F 75 /r PCMPEQW xmm1,xmm2/m128
66 0F 76 /r PCMPEQD xmm1,xmm2/m128
3.1.3.2. PCMPGTB/PCMPGTW/PCMPGTD
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 64 /r Pentium MMX PCMPGTB mm,mm/m64 mm > mm/m64
NP 0F 65 /r PCMPGTW mm,mm/m64
NP 0F 66 /r PCMPGTD mm,mm/m64
66 0F 64 /r Pentium 4 (SSE2) PCMPGTB xmm1,xmm2/m128 xmm1 > xmm2/m128
66 0F 65 /r PCMPGTW xmm1,xmm2/m128
66 0F 66 /r PCMPGTD xmm1,xmm2/m128

3.1.4. MMX Bitwise 명령어

3.1.4.1. PAND
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F DB /r Pentium MMX PAND mm,mm/m64 mm &= mm/m64
66 0F DB /r Pentium 4 (SSE2) PAND xmm1,xmm2/m128 xmm1 &= xmm2/m128
3.1.4.2. PANDN
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F DF /r Pentium MMX PANDN mm,mm/m64 mm = ~mm & mm/m64
66 0F DF /r Pentium 4 (SSE2) PANDN xmm1,xmm2/m128 xmm1 = ~xmm1 & xmm2/m128
3.1.4.3. POR
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F EB /r Pentium MMX POR mm,mm/m64 mm |= mm/m64
66 0F EB /r Pentium 4 (SSE2) POR xmm1,xmm2/m128 xmm1 |= xmm2/m128
3.1.4.4. PXOR
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F EF /r Pentium MMX PXOR mm,mm/m64 mm ^= mm/m64
66 0F EF /r Pentium 4 (SSE2) PXOR xmm1,xmm2/m128 xmm1 ^= xmm2/m128

3.1.5. MMX Shift/Rotate 명령어

3.1.5.1. PSLLW/PSLLD/PSLLQ
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 71 /6 ib Pentium MMX PSLLW mm,imm8 mm <<= imm8 [psllw]
NP 0F 72 /6 ib PSLLD mm,imm8 [pslld]
NP 0F 73 /6 ib PSLLQ mm,imm8 [psllq]
NP 0F F1 /r Pentium MMX PSLLW mm,mm/m64 mm <<= mm/m64 [psllw]
NP 0F F2 /r PSLLD mm,mm/m64 [pslld]
NP 0F F3 /r PSLLQ mm,mm/m64 [psllq]
66 0F 71 /6 ib Pentium 4 (SSE2) PSLLW xmm1,imm8 xmm1 <<= imm8 [psllw]
66 0F 72 /6 ib PSLLD xmm1,imm8 [pslld]
66 0F 73 /6 ib PSLLQ xmm1,imm8 [psllq]
66 0F F1 /r Pentium 4 (SSE2) PSLLW xmm1,xmm2/m128 xmm1 <<= xmm2/m128 [psllw]
66 0F F2 /r PSLLD xmm1,xmm2/m128 [pslld]
66 0F F3 /r PSLLQ xmm1,xmm2/m128 [psllq]
[psllw] count가 15 이상인 경우 모두 0으로 채운다.[pslld] count가 31 이상인 경우 모두 0으로 채운다.[psllq] count가 63 이상인 경우 모두 0으로 채운다.[psllw] [pslld] [psllq] [psllw] [pslld] [psllq] [psllw] [pslld] [psllq]
3.1.5.2. PSRLW/PSRLD/PSRLQ
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 71 /2 ib Pentium MMX PSRLW mm,imm8 mm >>= imm8 [psrlw]
NP 0F 72 /2 ib PSRLD mm,imm8 [psrld]
NP 0F 73 /2 ib PSRLQ mm,imm8 [psrlq]
NP 0F D1 /r Pentium MMX PSRLW mm,mm/m64 mm >>= mm/m64 [psrlw]
NP 0F D2 /r PSRLD mm,mm/m64 [psrld]
NP 0F D3 /r PSRLQ mm,mm/m64 [psrlq]
66 0F 71 /2 ib Pentium 4 (SSE2) PSRLW xmm1,imm8 xmm1 >>= imm8 [psrlw]
66 0F 72 /2 ib PSRLD xmm1,imm8 [psrld]
66 0F 73 /2 ib PSRLQ xmm1,imm8 [psrlq]
66 0F D1 /r Pentium 4 (SSE2) PSRLW xmm1,xmm2/m128 xmm1 >>= xmm2/m128 [psrlw]
66 0F D2 /r PSRLD xmm1,xmm2/m128 [psrld]
66 0F D3 /r PSRLQ xmm1,xmm2/m128 [psrlq]
[psrlw] count가 15 이상인 경우 모두 0으로 채운다.[psrld] count가 31 이상인 경우 모두 0으로 채운다.[psrlq] count가 63 이상인 경우 모두 0으로 채운다.[psrlw] [psrld] [psrlq] [psrlw] [psrld] [psrlq] [psrlw] [psrld] [psrlq]
3.1.5.3. PSRAW/PSRAD
Opcode 추가 시점 Mnemonic 형식 비고
NP 0F 71 /4 ib Pentium MMX PSRAW mm,imm8 mm >>= imm8 [psraw]
NP 0F 72 /4 ib PSRAD mm,imm8 [psrad]
NP 0F E1 /r Pentium MMX PSRAW mm,mm/m64 mm >>= mm/m64 [psraw]
NP 0F E2 /r PSRAD mm,mm/m64 [psrad]
66 0F 71 /4 ib Pentium 4 (SSE2) PSRAW xmm1,imm8 xmm1 >>= imm8 [psraw]
66 0F 72 /4 ib PSRAD xmm1,imm8 [psrad]
66 0F E1 /r Pentium 4 (SSE2) PSRAW xmm1,xmm2/m128 xmm1 >>= xmm2/m128 [psraw]
66 0F E2 /r PSRAD xmm1,xmm2/m128 [psrad]
[psraw] count가 15 이상인 경우 모두 sign bit으로 채운다.[psrad] count가 31 이상인 경우 모두 sign bit으로 채운다.[psraw] [psrad] [psraw] [psrad] [psraw] [psrad]

3.1.6. MMX 제어 명령어

3.1.6.1. EMMS
Opcode 추가 시점 Mnemonic 설명 비고
0F 77 Pentium MMX EMMS Set the x87 FPU tag word to empty. x87FPUTagWord ← FFFFh;

3.2. SSE 확장

SSE의 초기 버전은 단정밀도(32-bit) 부동소수점만을 지원한다. (Scalar/Packed)
  • NP: No Prefix. 접두사 없음.

3.2.1. SSE 메모리 관련 명령어

3.2.1.1. MOVUPS
Opcode 추가 시점 Mnemonic 설명 비고
NP 0F 10 /r Pentium III (SSE) MOVUPS xmm1,xmm2/m128 xmm1 = xmm2/m128
NP 0F 11 /r Pentium III (SSE) MOVUPS xmm2/m128,xmm1 xmm2/m128 = xmm1
3.2.1.2. MOVSS
Opcode 추가 시점 Mnemonic 설명 비고
F3 0F 10 /r Pentium III (SSE) MOVSS xmm1,xmm2/m32 xmm1[0] = xmm2[0]/m32 [171]
F3 0F 11 /r Pentium III (SSE) MOVSS xmm2/m32,xmm1 xmm2[0]/m32 = xmm1[0]
[171] Source 피연산자가 m32인 경우 XMM[127:32]는 0으로 비워진다.
3.2.1.3. MOVLPS
3.2.1.4. MOVHLPS
3.2.1.5. MOVHPS
3.2.1.6. MOVLHPS
3.2.1.7. MOVAPS

3.2.2. SSE 변환 명령어

3.2.3. SSE Packed Arithmetic 명령어

3.2.4. SSE Comparison 명령어

3.2.5. SSE Bitwise 명령어

3.2.6. SSE Shuffle/Unpack 명령어

3.2.7. 기타 SSE 명령어

3.3. SSE2 확장

SSE2에서는 배정밀도(64-bit) 부동소수점 및 MMX 명령어 등을 지원한다.

3.3.1. SSE2 메모리 관련 명령어

3.3.2. SSE2 변환 명령어

3.3.3. SSE2 Packed Arithmetic 명령어

3.3.4. SSE2 Comparison 명령어

3.3.5. SSE2 Bitwise 명령어

3.3.6. SSE2 Shuffle/Unpack 명령어

3.3.7. 기타 SSE2 명령어

3.4. SSE3 확장

SSE3에서는 이전 SSE/SSE2와 달리 벡터 내의 각 항별로 다른 연산을 적용하거나(홀수번째 항은 덧셈, 짝수번째 항은 뺄셈) 한 벡터 내의 여러 항들 사이의 덧셈/뺄셈 연산을 지원해 3D 작업 등을 더 빠르게 수행할 수 있도록 하였다.

분류