[[분류:명령어 집합]]
[include(틀:상위 문서,top1=x86)]
[include(틀:명령어 집합)]
[Include(틀:x86 확장 명령어 집합)]
[목차]
[clearfix]
== 개요 ==
x86 아키텍처의 명령어 목록. AMD64 확장에 대해서는 다루지 않는다.

=== 약어 설명 ===
 * r : 레지스터
 * m : 메모리
 * imm : 상수 (ib: 8-bit, iw: 16-bit, id: 32-bit)

=== 표기법 ===
==== 인텔 문법과 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). 여기서는 인텔 문법을 기준으로 설명한다.

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

=== 명령어 인코딩 ===
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(명령어에 인코딩되는 숫자) 값으로 명령어에 따라 선택적으로 요구한다.

==== 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개씩 붙을 수 있으며 임의의 순서로 배치될 수 있으나[* "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.], 어셈블러에서는 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}}}
[각주]

====# x86 Opcode #====
|| 1-byte || 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || A || B || C || D || E || F ||
||<|2> 00 ||<-6> ADD ||<|2> [* PUSH ES] ||<|2> [* POP ES] ||<-6> OR ||<|2> [* PUSH CS] ||<|2> '''*'''[* 8086/8088에서는 {{{POP CS}}} 명령어로 동작하였으나, 80186부터는 사용되지 않으며 이후 2-byte 이상 opcode를 나타내는 escape로 사용된다.] ||
||<-2> r/m += r ||<-2> r += r/m ||<-2> a += imm ||<-2> r/m |= r ||<-2> r |= r/m ||<-2> a |= imm ||
||<|2> 10 ||<-6> ADC ||<|2> [* PUSH SS] ||<|2> [* POP SS] ||<-6> SBB ||<|2> [* PUSH DS] ||<|2> [* POP DS] ||
||<-2> r/m += r ||<-2> r += r/m ||<-2> a += imm ||<-2> r/m -= r ||<-2> r -= r/m ||<-2> a -= imm ||
||<|2> 20 ||<-6> AND ||<|2> [* ES segment override prefix] ||<|2> DAA[*i AMD64 확장의 64-bit 모드에서는 지원되지 않는다.] ||<-6> SUB ||<|2> [* CS segment override prefix] ||<|2> DAS[*i] ||
||<-2> r/m &= r ||<-2> r &= r/m ||<-2> a &= imm ||<-2> r/m -= r ||<-2> r -= r/m ||<-2> a -= imm ||
||<|2> 30 ||<-6> XOR ||<|2> [* SS segment override prefix] ||<|2> AAA[*i] ||<-6> CMP ||<|2> [* DS segment override prefix] ||<|2> AAS[*i] ||
||<-2> r/m ^= r ||<-2> r ^= r/m ||<-2> a ^= imm ||<-2> r/m - r ||<-2> r - r/m ||<-2> a - imm ||
||<|2> 40 ||<-8> INC[*a AMD64 확장에서는 REX 접두사로 사용되는 opcode이다.] ||<-8> DEC[*a] ||
|| EAX || ECX || EDX || EBX || ESP || EBP || ESI || EDI || EAX || ECX || EDX || EBX || ESP || EBP || ESI || EDI ||
||<|2> 50 ||<-8> PUSH ||<-8> POP ||
|| EAX || ECX || EDX || EBX || ESP || EBP || ESI || EDI || EAX || ECX || EDX || EBX || ESP || EBP || ESI || EDI ||
||<|2> 60 ||<|2> PUSHAD[*i] ||<|2> POPAD[*i] ||<|2> BOUND[*i] ||<|2> ARPL ||<-2> segment
override ||<-2> size
override ||<|2> PUSH ||<|2> IMUL ||<|2> PUSH ||<|2> IMUL ||<|2><-2> INS ||<|2><-2> OUTS ||
|| FS || GS || [* operand size override] || [* address size override] ||
||<|2> 70 ||<-16> 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 ||
||<|2> 80 ||<|2><-4> ALU (imm)[* (ADD/OR/ADC/SBB/AND/SUB/XOR/CMP) imm; {{{80+sw}}}로 인코딩된다. Opcode {{{82h}}}는 {{{80h}}}와 동일하게 동작하는 것으로 보이나, 매뉴얼에는 생략되어 있다.)] ||<|2><-2> TEST ||<|2><-2> XCHG ||<-4> MOV || MOV ||<|2> LEA || MOV ||<|2> POP ||
||<-2> r/m = r[* RISC의 store 명령어에 대응한다.] ||<-2> r = r/m[* RISC의 load 명령어에 대응한다.] || [* {{{mov r/m16,Sreg}}}, segment register의 값을 memory에 저장한다.] || [* {{{mov Sreg,r/m16}}}, memory의 값을 segment register에 불러온다.] ||
||<|2> 90 ||<|2> NOP[* {{{xchg eax,eax}}}로 인코딩된다. Intel 64 매뉴얼 또는 AMD 매뉴얼의 경우 operand size prefix를 붙인 {{{66 90h}}}({{{xchg ax,ax}}}) 또한 NOP으로 기재되어 있으니 IA-32 매뉴얼에는 등장하지 않는다.] ||<-7> XCHG EAX ||<|2> CWD ||<|2> CDQ ||<|2> CALLF ||<|2> WAIT ||<|2> PUSHFD ||<|2> POPFD ||<|2> SAHF ||<|2> LAHF ||
|| ECX || EDX || EBX || ESP || EBP || ESI || EDI ||
||<|2> A0 ||<-4> MOV EAX ||<|2><-2> MOVS ||<|2><-2> CMPS ||<|2><-2> TEST ||<|2><-2> STOS ||<|2><-2> LODS ||<|2><-2> SCAS ||
||<-2> a = (seg:offset) ||<-2> (seg:offset) = a ||
||<|2> B0 ||<-16> MOV (imm) ||
||<-8> r8 = imm8 ||<-8> r16(r32) = imm16(imm32) ||
||<|2> C0 ||<-2> SHIFT imm ||<|2><-2> RETN[*r 어셈블리 상에서는 RETN/RETF 구분 없이 {{{ret}}}으로 사용한다.] ||<|2> LES ||<|2> LDS ||<|2><-2> MOV imm ||<|2> ENTER ||<|2> LEAVE ||<|2><-2> RETF[*r] ||<|2> INT3 ||<|2> INT imm ||<|2> INTO ||<|2> IRETD ||
||<-2> [* (ROL/ROR/RCL/RCR/SHL/SHR/SAR) imm] ||
||<|2> D0 ||<-2> SHIFT 1 ||<-2> SHIFT CL ||<|2> AAM[*i] ||<|2> AAD[*i] ||<|2> SALC ||<|2> XLAT ||<|2><-8> FPU[* x87 명령어를 나타내는 escape이다.] ||
||<-2> [* (ROL/ROR/RCL/RCR/SHL/SHR/SAR) 1] ||<-2> [* (ROL/ROR/RCL/RCR/SHL/SHR/SAR) CL] ||
||<|2> E0 ||<-2> LOOPcc ||<|2> LOOP ||<|2> JECXZ ||<|2><-2> IN imm ||<|2><-2> OUT imm ||<|2> CALL ||<|2> JMP ||<|2> JMPF ||<|2> JMP short ||<|2><-2> IN DX ||<|2><-2> OUT DX ||
|| LOOPNZ || LOOPZ ||
||<|2> F0 || LOCK ||<|2> INT1
ICEBP ||<-2> REPcc ||<|2> HLT ||<|2> CMC ||<|2><-2> [* (TEST/NOT/NEG/(I)MUL/(I)DIV)] ||<|2> CLC ||<|2> STC ||<|2> CLI ||<|2> STI ||<|2> CLD ||<|2> STD ||<|2><-2> [* (INC/DEC/CALL/JMP/PUSH) (Mod R/M)] ||
|| [* prefix] || REPNE || REPE ||
[각주]
=====# 1-byte opcode 목록 #=====
=====# 2-byte 이상 opcode #=====
|| 명령어 || 확장 || Opcode ||
||<-3> 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}}} ||
||<-3> 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}}} ||
||<-3> 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}}} ||
||<-3> i586 ||
|| WRMSR || i586 ||{{{0F 30}}} ||
|| RDTSC || i586 ||{{{0F 31}}} ||
|| RDMSR || i586 ||{{{0F 32}}} ||
|| CPUID || i586 ||{{{0F A2}}} ||
|| RSM[* i386SL에서 도입되었으나, 전체 모델에 적용된 시점은 486 후기 및 Pentium이다.] || i586 ||{{{0F AA}}} ||
|| CMPXCHG8B || i586 ||{{{0F C7}}} ||
||<-3> i686 ||
|| UD2[* Raise invalid opcode exception] || 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}}} ||
[각주]
==== 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 값에 해당하는 주소를 지정한다.[* r/m 필드의 값이 '''{{{101}}}'''(ebp)인 경우 disp 값을 그대로 사용한다.]
  * '''{{{01}}}''': (m) (레지스터/SIB) 값에 disp8을 더한 주소를 지정한다.
  * '''{{{10}}}''': (m) (레지스터/SIB) 값에 disp16/disp32를 더한 주소를 지정한다.
  * '''{{{11}}}''': (r) 레지스터의 값을 operand로 사용한다.
 * reg/opcode
  * 레지스터 번호 또는 일부 명령어의 경우 opcode 정보를 담고 있다.
 * r/m
  * 레지스터 번호를 나타낸다.
[각주]
==== 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]}}}

=== 레지스터 ===
 * 범용 레지스터:
  * 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비트

==== 범용 레지스터 ====
|| 번호 / 종류 || 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[* x87과 동시에 사용할 수 없다.] || MM0 || MM1 || MM2 || MM3 || MM4 || MM5 || MM6 || MM7 ||
||128비트 SSE || XMM0 || XMM1 || XMM2 || XMM3 || XMM4 || XMM5 || XMM6 || XMM7 ||
[각주]
==== 세그멘트 레지스터 ====
|| 번호 || 레지스터 || 설명 || 비고 ||
|| 0|| ES ||Extra Segment || ||
|| 1|| CS ||Code Segment || ||
|| 2|| SS ||Stack Segment || ||
|| 3|| DS ||Data Segment || ||
|| 4|| FS || ||80386에서 추가 ||
|| 5|| GS || ||80386에서 추가 ||
[각주]
==== 플래그 레지스터 ====
 * 상태 플래그
  * 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
[각주]
===== 조건 코드 =====
조건 코드는 상태 플래그의 값에 따라 동작을 수행하는 데 사용되는 코드로, 총 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 ||
[각주]

=== x87 FPU ===
==== 레지스터 ====
x87은 8개의 80-bit 레지스터({{{R0-R7}}})를 스택처럼 사용한다. 레지스터는 각 레지스터의 번호가 아닌 스택 상의 상대적인 위치({{{ST(i)}}})로 접근하고, 다수의 명령어에 {{{ST(0)}}}이 피연산자로 고정되어 있으므로 병렬적인 실행이 어렵다.
[각주]
==== 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
[각주]
==== 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
[각주]
==== 명령어 인코딩 ====
||<|2> 인코딩 포맷 ||<-4> First Byte ||<-5> Second Byte ||
|| 15-11 || 10 || 9 || 8 || 7-6 || 5 || 4 || 3 || 2-0 ||
|| 1 || {{{11011}}} ||<-2> opA || 1 || mod || 1 ||<-2> opB || r/m ||
|| 2 || {{{11011}}} ||<-2> MF || opA || mod ||<-3> opB || r/m ||
|| 3 || {{{11011}}} || d || P || opA || {{{11}}} ||<-2> opB || R || ST(i) ||
|| 4 || {{{11011}}} || 0 || 0 || 1 || {{{11}}} || 1 ||<-3> op ||
|| 5 || {{{11011}}} || 0 || 1 || 1 || {{{11}}} || 1 ||<-3> 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 || 비고 ||
||<|2> {{{00}}} ||<|2> {{{00}}} ||<|2>{{{FLDENV}}} ||8087 ||{{{FLDENV m14byte}}} ||<|2>{{{D9 /4}}} ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FLDENV m28byte}}} || ||
|| {{{00}}} || {{{01}}} ||{{{FLDCW}}} ||8087 ||{{{FLDCW m2byte}}} ||{{{D9 /5}}} || ||
||<|2> {{{00}}} ||<|2> {{{10}}} ||<|2>{{{FNSTENV}}} ||8087 ||{{{FNSTENV m14byte}}} ||<|2>{{{D9 /6}}} ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FNSTENV m28byte}}} ||[* {{{FSTENV}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
|| {{{00}}} || {{{11}}} ||{{{FNSTCW}}} ||8087 ||{{{FNSTCW m2byte}}} ||{{{D9 /7}}} ||[* {{{FSTCW}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
|| {{{01}}} || {{{01}}} ||{{{FLD}}} ||8087 ||{{{FLD m80fp}}} ||{{{DB /5}}} || ||
|| {{{01}}} || {{{11}}} ||{{{FSTP}}} ||8087 ||{{{FSTP m80fp}}} ||{{{DB /7}}} || ||
||<|2> {{{10}}} ||<|2> {{{00}}} ||<|2>{{{FRSTOR}}} ||8087 ||{{{FRSTOR m94byte}}} ||<|2>{{{DD /4}}} ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FRSTOR m108byte}}} || ||
||<|2> {{{10}}} ||<|2> {{{10}}} ||<|2>{{{FNSAVE}}} ||8087 ||{{{FNSAVE m94byte}}} ||<|2>{{{DD /6}}} ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FNSAVE m108byte}}} ||[* {{{FSAVE}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
|| {{{10}}} || {{{11}}} ||{{{FNSTSW}}} ||8087 ||{{{FNSTSW m2byte}}} ||{{{DD /7}}} ||[* {{{FSTSW}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
|| {{{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}}} || ||
[각주]
=====# Format 2 #=====
|| opA || opB || 명령어 || 추가 시점 || MF || Mnemonic || HEX || 비고 ||
||<|2> {{{0}}} ||<|2> {{{000}}} ||<|2>{{{FADD}}} ||<|2>8087 || {{{00}}} ||{{{FADD m32fp}}} ||{{{D8 /0}}} || ||
|| {{{10}}} ||{{{FADD m64fp}}} ||{{{DC /0}}} || ||
||<|2> {{{0}}} ||<|2> {{{000}}} ||<|2>{{{FIADD}}} ||<|2>8087 || {{{01}}} ||{{{FIADD m32int}}} ||{{{DA /0}}} || ||
|| {{{11}}} ||{{{FIADD m16int}}} ||{{{DE /0}}} || ||
||<|2> {{{0}}} ||<|2> {{{001}}} ||<|2>{{{FMUL}}} ||<|2>8087 || {{{00}}} ||{{{FMUL m32fp}}} ||{{{D8 /1}}} || ||
|| {{{10}}} ||{{{FMUL m64fp}}} ||{{{DC /1}}} || ||
||<|2> {{{0}}} ||<|2> {{{001}}} ||<|2>{{{FIMUL}}} ||<|2>8087 || {{{01}}} ||{{{FIMUL m32int}}} ||{{{DA /1}}} || ||
|| {{{11}}} ||{{{FIMUL m16int}}} ||{{{DE /1}}} || ||
||<|2> {{{0}}} ||<|2> {{{010}}} ||<|2>{{{FCOM}}} ||<|2>8087 || {{{00}}} ||{{{FCOM m32fp}}} ||{{{D8 /2}}} || ||
|| {{{10}}} ||{{{FCOM m64fp}}} ||{{{DC /2}}} || ||
||<|2> {{{0}}} ||<|2> {{{010}}} ||<|2>{{{FICOM}}} ||<|2>8087 || {{{01}}} ||{{{FICOM m32int}}} ||{{{DA /2}}} || ||
|| {{{11}}} ||{{{FICOM m16int}}} ||{{{DE /2}}} || ||
||<|2> {{{0}}} ||<|2> {{{011}}} ||<|2>{{{FCOMP}}} ||<|2>8087 || {{{00}}} ||{{{FCOMP m32fp}}} ||{{{D8 /3}}} || ||
|| {{{10}}} ||{{{FCOMP m64fp}}} ||{{{DC /3}}} || ||
||<|2> {{{0}}} ||<|2> {{{011}}} ||<|2>{{{FICOMP}}} ||<|2>8087 || {{{01}}} ||{{{FICOMP m32int}}} ||{{{DA /3}}} || ||
|| {{{11}}} ||{{{FICOMP m16int}}} ||{{{DE /3}}} || ||
||<|2> {{{0}}} ||<|2> {{{100}}} ||<|2>{{{FSUB}}} ||<|2>8087 || {{{00}}} ||{{{FSUB m32fp}}} ||{{{D8 /4}}} || ||
|| {{{10}}} ||{{{FSUB m64fp}}} ||{{{DC /4}}} || ||
||<|2> {{{0}}} ||<|2> {{{100}}} ||<|2>{{{FISUB}}} ||<|2>8087 || {{{01}}} ||{{{FISUB m32int}}} ||{{{DA /4}}} || ||
|| {{{11}}} ||{{{FISUB m16int}}} ||{{{DE /4}}} || ||
||<|2> {{{0}}} ||<|2> {{{101}}} ||<|2>{{{FSUBR}}} ||<|2>8087 || {{{00}}} ||{{{FSUBR m32fp}}} ||{{{D8 /5}}} || ||
|| {{{10}}} ||{{{FSUBR m64fp}}} ||{{{DC /5}}} || ||
||<|2> {{{0}}} ||<|2> {{{101}}} ||<|2>{{{FISUBR}}} ||<|2>8087 || {{{01}}} ||{{{FISUBR m32int}}} ||{{{DA /5}}} || ||
|| {{{11}}} ||{{{FISUBR m16int}}} ||{{{DE /5}}} || ||
||<|2> {{{0}}} ||<|2> {{{110}}} ||<|2>{{{FDIV}}} ||<|2>8087 || {{{00}}} ||{{{FDIV m32fp}}} ||{{{D8 /6}}} || ||
|| {{{10}}} ||{{{FDIV m64fp}}} ||{{{DC /6}}} || ||
||<|2> {{{0}}} ||<|2> {{{110}}} ||<|2>{{{FIDIV}}} ||<|2>8087 || {{{01}}} ||{{{FIDIV m32int}}} ||{{{DA /6}}} || ||
|| {{{11}}} ||{{{FIDIV m16int}}} ||{{{DE /6}}} || ||
||<|2> {{{0}}} ||<|2> {{{111}}} ||<|2>{{{FDIVR}}} ||<|2>8087 || {{{00}}} ||{{{FDIVR m32fp}}} ||{{{D8 /7}}} || ||
|| {{{10}}} ||{{{FDIVR m64fp}}} ||{{{DC /7}}} || ||
||<|2> {{{0}}} ||<|2> {{{111}}} ||<|2>{{{FIDIVR}}} ||<|2>8087 || {{{01}}} ||{{{FIDIVR m32int}}} ||{{{DA /7}}} || ||
|| {{{11}}} ||{{{FIDIVR m16int}}} ||{{{DE /7}}} || ||
||<|2> {{{1}}} ||<|2> {{{000}}} ||<|2>{{{FLD}}} ||<|2>8087 || {{{00}}} ||{{{FLD m32fp}}} ||{{{D9 /0}}} || ||
|| {{{10}}} ||{{{FLD m64fp}}} ||{{{DD /0}}} || ||
||<|2> {{{1}}} ||<|2> {{{000}}} ||<|2>{{{FILD}}} ||<|2>8087 || {{{01}}} ||{{{FILD m32int}}} ||{{{DB /0}}} || ||
|| {{{11}}} ||{{{FILD m16int}}} ||{{{DF /0}}} || ||
||<|3> {{{1}}} ||<|3> {{{001}}} ||<|3>{{{FISTTP}}} ||<|3>SSE3 || {{{10}}} ||{{{FISTTP m64int}}} ||{{{DD /1}}} || ||
|| {{{01}}} ||{{{FISTTP m32int}}} ||{{{DB /1}}} || ||
|| {{{11}}} ||{{{FISTTP m16int}}} ||{{{DF /1}}} || ||
||<|2> {{{1}}} ||<|2> {{{010}}} ||<|2>{{{FST}}} ||<|2>8087 || {{{00}}} ||{{{FST m32fp}}} ||{{{D9 /2}}} || ||
|| {{{10}}} ||{{{FST m64fp}}} ||{{{DD /2}}} || ||
||<|2> {{{1}}} ||<|2> {{{010}}} ||<|2>{{{FIST}}} ||<|2>8087 || {{{01}}} ||{{{FIST m32int}}} ||{{{DB /2}}} || ||
|| {{{11}}} ||{{{FIST m16int}}} ||{{{DF /2}}} || ||
||<|2> {{{1}}} ||<|2> {{{011}}} ||<|2>{{{FSTP}}} ||<|2>8087 || {{{00}}} ||{{{FSTP m32fp}}} ||{{{D9 /3}}} || ||
|| {{{10}}} ||{{{FSTP m64fp}}} ||{{{DD /3}}} || ||
||<|2> {{{1}}} ||<|2> {{{011}}} ||<|2>{{{FISTP}}} ||<|2>8087 || {{{01}}} ||{{{FISTP m32int}}} ||{{{DB /3}}} || ||
|| {{{11}}} ||{{{FISTP m16int}}} ||{{{DF /3}}} || ||
[각주]
=====# Format 3 #=====
|| opA || opB || R || P || 명령어 || 추가 시점 || d || Mnemonic || HEX || 비고 ||
||<|2> {{{0}}} ||<|2> {{{00}}} ||<|2> 0 ||<|2> 0 ||<|2>{{{FADD}}} ||<|2>8087 || 0 ||{{{FADD st(0),st(i)}}} ||{{{D8 C0+i}}} || ||
|| 1 ||{{{FADD st(i),st(0)}}} ||{{{DC C0+i}}} || ||
||<|2> {{{0}}} ||<|2> {{{00}}} ||<|2> 0 ||<|2> 1 ||<|2>{{{FADDP}}} ||<|2>8087 ||<|2> 1 ||{{{FADDP st(i),st(0)}}} ||{{{DE C0+i}}} || ||
||{{{FADDP}}} ||{{{DE C1}}} || ||
||<|2> {{{0}}} ||<|2> {{{00}}} ||<|2> 1 ||<|2> 0 ||<|2>{{{FMUL}}} ||<|2>8087 || 0 ||{{{FMUL st(0),st(i)}}} ||{{{D8 C8+i}}} || ||
|| 1 ||{{{FMUL st(i),st(0)}}} ||{{{DC C8+i}}} || ||
||<|2> {{{0}}} ||<|2> {{{00}}} ||<|2> 1 ||<|2> 1 ||<|2>{{{FMULP}}} ||<|2>8087 ||<|2> 1 ||{{{FMULP st(i),st(0)}}} ||{{{DE C8+i}}} || ||
||{{{FMULP}}} ||{{{DE C9}}} || ||
||<|2> {{{0}}} ||<|2> {{{01}}} ||<|2> 0 ||<|2> 0 ||<|2>{{{FCOM}}} ||<|2>8087 ||<|2> * ||{{{FCOM st(i)}}} ||{{{D8 D0+i}}}
{{{DC D0+i}}} || ||
||{{{FCOM}}} ||{{{D8 D1}}}
{{{DC D1}}} || ||
||<|2> {{{0}}} ||<|2> {{{01}}} ||<|2> 0 ||<|2> 1 ||<|2>{{{FCOMP}}} ||<|2>8087 ||<|2> 1 ||{{{FCOMP st(i)}}} ||{{{DE D0+i}}} || ||
||{{{FCOMP}}} ||{{{DE D1}}} || ||
||<|2> {{{0}}} ||<|2> {{{01}}} ||<|2> 1 ||<|2> 0 ||<|2>{{{FCOMP}}} ||<|2>8087 ||<|2> * ||{{{FCOMP st(i)}}} ||{{{D8 D8+i}}}
{{{DC D8+i}}} || ||
||{{{FCOMP}}} ||{{{D8 D9}}}
{{{DC D9}}} || ||
|| {{{0}}} || {{{01}}} || 1 || 1 ||{{{FCOMPP}}} ||8087 || 1 ||{{{FCOMPP}}} ||{{{DE D9}}} || ||
||<|2> {{{0}}} ||<|2> {{{10}}} || 0 ||<|2> 0 ||<|2>{{{FSUB}}} ||<|2>8087 || 0 ||{{{FSUB st(0),st(i)}}} ||{{{D8 E0+i}}} || ||
|| 1 || 1 ||{{{FSUB st(i),st(0)}}} ||{{{DC E8+i}}} || ||
||<|2> {{{0}}} ||<|2> {{{10}}} ||<|2> 1 ||<|2> 1 ||<|2>{{{FSUBP}}} ||<|2>8087 ||<|2> 1 ||{{{FSUBP st(i),st(0)}}} ||{{{DE E8+i}}} || ||
||{{{FSUBP}}} ||{{{DE E9}}} || ||
||<|2> {{{0}}} ||<|2> {{{10}}} || 1 ||<|2> 0 ||<|2>{{{FSUBR}}} ||<|2>8087 || 0 ||{{{FSUBR st(0),st(i)}}} ||{{{D8 E8+i}}} || ||
|| 0 || 1 ||{{{FSUBR st(i),st(0)}}} ||{{{DC E0+i}}} || ||
||<|2> {{{0}}} ||<|2> {{{10}}} ||<|2> 0 ||<|2> 1 ||<|2>{{{FSUBRP}}} ||<|2>8087 ||<|2> 1 ||{{{FSUBRP st(i),st(0)}}} ||{{{DE E0+i}}} || ||
||{{{FSUBRP}}} ||{{{DE E1}}} || ||
||<|2> {{{0}}} ||<|2> {{{11}}} || 0 ||<|2> 0 ||<|2>{{{FDIV}}} ||<|2>8087 || 0 ||{{{FDIV st(0),st(i)}}} ||{{{D8 F0+i}}} || ||
|| 1 || 1 ||{{{FDIV st(i),st(0)}}} ||{{{DC F8+i}}} || ||
||<|2> {{{0}}} ||<|2> {{{11}}} ||<|2> 1 ||<|2> 1 ||<|2>{{{FDIVP}}} ||<|2>8087 ||<|2> 1 ||{{{FDIVP st(i),st(0)}}} ||{{{DE F8+i}}} || ||
||{{{FDIVP}}} ||{{{DE F9}}} || ||
||<|2> {{{0}}} ||<|2> {{{11}}} || 1 ||<|2> 0 ||<|2>{{{FDIVR}}} ||<|2>8087 || 0 ||{{{FDIVR st(0),st(i)}}} ||{{{D8 F8+i}}} || ||
|| 0 || 1 ||{{{FDIVR st(i),st(0)}}} ||{{{DC F0+i}}} || ||
||<|2> {{{0}}} ||<|2> {{{11}}} ||<|2> 0 ||<|2> 1 ||<|2>{{{FDIVRP}}} ||<|2>8087 ||<|2> 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}}} || ||
||<|3> {{{1}}} ||<|3> {{{00}}} ||<|3> 1 ||<|2> 0 ||<|3>{{{FXCH}}} ||<|3>8087 || 0 ||<|3>{{{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}}} || ||
||<|2> {{{1}}} ||<|2> {{{10}}} ||<|2> 0 ||<|2> 0 ||<|2>{{{FUCOM}}} ||<|2>80387 ||<|2> 1 ||{{{FUCOM st(i)}}} ||{{{DD E0+i}}} || ||
||{{{FUCOM}}} ||{{{DD E1}}} || ||
|| {{{1}}} || {{{10}}} || 0 || 1 ||{{{FNSTSW}}} ||80287 || 1 ||{{{FNSTSW AX}}} ||{{{DF E0}}} ||[* {{{FSTSW}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
||<|2> {{{1}}} ||<|2> {{{10}}} ||<|2> 1 ||<|2> 0 ||<|2>{{{FUCOMP}}} ||<|2>80387 ||<|2> 1 ||{{{FUCOMP st(i)}}} ||{{{DD E8+i}}} || ||
||{{{FUCOMP}}} ||{{{DD E9}}} || ||
|| {{{1}}} || {{{10}}} || 1 || 1 ||{{{FUCOMPP}}} ||80387 || 0 ||{{{FUCOMPP}}} ||{{{DA E9}}} || ||
[각주]
|| opA || opB || R || P || 명령어 || 추가 시점 || d || Mnemonic || HEX || 비고 ||
|| {{{0}}} || {{{00}}} || 0 ||<|8> 1 ||<|8>{{{FCMOVcc}}} ||<|8>Pentium Pro ||<|8> 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}}} ||[* {{{FCLEX}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
|| {{{00}}} || {{{011}}} ||{{{FNINIT}}} ||8087 ||{{{FNINIT}}} ||{{{DB E3}}} ||[* {{{FINIT}}} 명령어는 앞에 {{{9B}}}({{{WAIT}}}) 명령어가 추가되어 인코딩된다.] ||
|| {{{00}}} || {{{100}}} ||{{{FSETPM287_NOP}}} ||8087 ||{{{FSETPM287_NOP}}} ||{{{DB E4}}} ||32-bit x87 FPU에서는 NOP으로 다뤄짐 ||
[각주]

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

==== Tag Word ====
각 MMX 명령어가 실행되면 x87 FPU tag word 전체가 valid({{{00b}}})로 설정된다. EMMS('''E'''mpty '''MM'''X '''S'''tate) 명령어는 x87 FPU tag word 전체를 empty({{{11b}}})로 설정한다.
[각주]
==== 인코딩 ====
 * 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 필드에 인코딩된다.
[각주]

== 명령어 목록 ==
=== x86 명령어 [anchor(x86)] ===
==== x86 사칙연산 명령어 ====
===== ADD =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{00 /r}}} ||8086/8088 ||{{{ADD r/m8,r8}}} || r/m += r || ||
||<|2>{{{01 /r}}} ||8086/8088 ||{{{ADD r/m16,r16}}} ||<|2> r/m += r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ADD r/m32,r32}}} || ||
||{{{02 /r}}} ||8086/8088 ||{{{ADD r8,r/m8}}} || r += r/m || ||
||<|2>{{{03 /r}}} ||8086/8088 ||{{{ADD r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m += imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /0 id}}} ||80386 ||{{{ADD r/m32,imm32}}} || ||
||<|2>{{{83 /0 ib}}} ||8086/8088 ||{{{ADD r/m16,imm8}}} ||<|2> r/m += imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{ADD r/m32,imm8}}} || ||
[각주]
====== INC ======
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{40+rw}}}[* AMD64 확장에서 해당 opcode는 REX 접두사를 인코딩하는 데 사용된다.] ||8086/8088 ||{{{INC r16}}} ||<|2> r += 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{40+rd}}} ||80386 ||{{{INC r32}}} || ||
||{{{FE /0}}} ||8086/8088 ||{{{INC r/m8}}} || r/m += 1 || ||
||<|2>{{{FF /0}}} ||8086/8088 ||{{{INC r/m16}}} ||<|2> r/m += 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{INC r/m32}}} || ||
[각주]
===== ADC =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{10 /r}}} ||8086/8088 ||{{{ADC r/m8,r8}}} || r/m += r + CF || ||
||<|2>{{{11 /r}}} ||8086/8088 ||{{{ADC r/m16,r16}}} ||<|2> r/m += r + CF ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ADC r/m32,r32}}} || ||
||{{{12 /r}}} ||8086/8088 ||{{{ADC r8,r/m8}}} || r += r/m + CF || ||
||<|2>{{{13 /r}}} ||8086/8088 ||{{{ADC r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m += imm + CF ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /2 id}}} ||80386 ||{{{ADC r/m32,imm32}}} || ||
||<|2>{{{83 /2 ib}}} ||8086/8088 ||{{{ADC r/m16,imm8}}} ||<|2> r/m += imm + CF ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{ADC r/m32,imm8}}} || ||
[각주]
===== SUB =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{28 /r}}} ||8086/8088 ||{{{SUB r/m8,r8}}} || r/m -= r || ||
||<|2>{{{29 /r}}} ||8086/8088 ||{{{SUB r/m16,r16}}} ||<|2> r/m -= r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SUB r/m32,r32}}} || ||
||{{{2A /r}}} ||8086/8088 ||{{{SUB r8,r/m8}}} || r -= r/m || ||
||<|2>{{{2B /r}}} ||8086/8088 ||{{{SUB r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m -= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /5 id}}} ||80386 ||{{{SUB r/m32,imm32}}} || ||
||<|2>{{{83 /5 ib}}} ||8086/8088 ||{{{SUB r/m16,imm8}}} ||<|2> r/m -= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{SUB r/m32,imm8}}} || ||
[각주]
====== DEC ======
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{48+rw}}}[* AMD64 확장에서 해당 opcode는 REX 접두사를 인코딩하는 데 사용된다.] ||8086/8088 ||{{{DEC r16}}} ||<|2> r -= 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{48+rd}}} ||80386 ||{{{DEC r32}}} || ||
||{{{FE /1}}} ||8086/8088 ||{{{DEC r/m8}}} || r/m -= 1 || ||
||<|2>{{{FF /1}}} ||8086/8088 ||{{{DEC r/m16}}} ||<|2> r/m -= 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{DEC r/m32}}} || ||
[각주]
===== SBB =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{18 /r}}} ||8086/8088 ||{{{SBB r/m8,r8}}} || r/m -= r + CF || ||
||<|2>{{{19 /r}}} ||8086/8088 ||{{{SBB r/m16,r16}}} ||<|2> r/m -= r + CF ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SBB r/m32,r32}}} || ||
||{{{1A /r}}} ||8086/8088 ||{{{SBB r8,r/m8}}} || r -= r/m + CF || ||
||<|2>{{{1B /r}}} ||8086/8088 ||{{{SBB r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m -= imm + CF ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /3 id}}} ||80386 ||{{{SBB r/m32,imm32}}} || ||
||<|2>{{{83 /3 ib}}} ||8086/8088 ||{{{SBB r/m16,imm8}}} ||<|2> r/m -= imm + CF ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{SBB r/m32,imm8}}} || ||
[각주]
===== NEG =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{F6 /3}}} ||8086/8088 ||{{{NEG r/m8}}} || r/m = -(r/m) || ||
||<|2>{{{F7 /3}}} ||8086/8088 ||{{{NEG r/m16}}} ||<|2> r/m = -(r/m) ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{NEG r/m32}}} || ||
[각주]
===== CMP =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{38 /r}}} ||8086/8088 ||{{{CMP r/m8,r8}}} || temp = r/m - r || ||
||<|2>{{{39 /r}}} ||8086/8088 ||{{{CMP r/m16,r16}}} ||<|2> temp = r/m - r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{CMP r/m32,r32}}} || ||
||{{{3A /r}}} ||8086/8088 ||{{{CMP r8,r/m8}}} || temp = r - r/m || ||
||<|2>{{{3B /r}}} ||8086/8088 ||{{{CMP r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> temp = r/m - imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /7 id}}} ||80386 ||{{{CMP r/m32,imm32}}} || ||
||<|2>{{{83 /7 ib}}} ||8086/8088 ||{{{CMP r/m16,imm8}}} ||<|2> temp = r/m - imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{CMP r/m32,imm8}}} || ||
{{{SUB}}} 연산을 수행 후 결과값을 레지스터에 저장하지 않고 플래그만 설정하는 명령어이다.
[각주]
===== MUL =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{F6 /4}}} ||8086/8088 ||{{{MUL r/m8}}} ||{{{    ax  = al * (r/m8);}}} || ||
||<|2>{{{F7 /4}}} ||8086/8088 ||{{{MUL r/m16}}} ||{{{ dx:ax  = ax * (r/m16);}}} ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{MUL r/m32}}} ||{{{edx:eax = eax * (r/m32);}}} || ||
[각주]
===== IMUL =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||<|2>{{{0F AF /r}}} ||<|2>80386 ||{{{IMUL r16,r/m16}}} ||<|2> 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 || ||
||<|2>{{{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);}}} || ||
||<|2>{{{F7 /5}}} ||8086/8088 ||{{{IMUL r/m16}}} ||{{{ dx:ax  = ax * (r/m16);}}} ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{IMUL r/m32}}} ||{{{edx:eax = eax * (r/m32);}}} || ||
[각주]
===== DIV =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{F6 /6}}} ||8086/8088 ||{{{DIV r/m8}}} ||{{{ al = ax / (r/m8);}}}
{{{ ah = ax % (r/m8);}}} || ||
||<|2>{{{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);}}} || ||
[각주]
===== IDIV =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{F6 /7}}} ||8086/8088 ||{{{IDIV r/m8}}} ||{{{ al = ax / (r/m8);}}}
{{{ ah = ax % (r/m8);}}} || ||
||<|2>{{{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);}}} || ||
[각주]
==== x86 논리연산 명령어 ====
===== AND =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{20 /r}}} ||8086/8088 ||{{{AND r/m8,r8}}} || r/m &= r || ||
||<|2>{{{21 /r}}} ||8086/8088 ||{{{AND r/m16,r16}}} ||<|2> r/m &= r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{AND r/m32,r32}}} || ||
||{{{22 /r}}} ||8086/8088 ||{{{AND r8,r/m8}}} || r &= r/m || ||
||<|2>{{{23 /r}}} ||8086/8088 ||{{{AND r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m &= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /4 id}}} ||80386 ||{{{AND r/m32,imm32}}} || ||
||<|2>{{{83 /4 ib}}} ||8086/8088 ||{{{AND r/m16,imm8}}} ||<|2> r/m &= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{AND r/m32,imm8}}} || ||
[각주]
===== OR =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{08 /r}}} ||8086/8088 ||{{{OR r/m8,r8}}} || r/m |= r || ||
||<|2>{{{09 /r}}} ||8086/8088 ||{{{OR r/m16,r16}}} ||<|2> r/m |= r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{OR r/m32,r32}}} || ||
||{{{0A /r}}} ||8086/8088 ||{{{OR r8,r/m8}}} || r |= r/m || ||
||<|2>{{{0B /r}}} ||8086/8088 ||{{{OR r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m |= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /1 id}}} ||80386 ||{{{OR r/m32,imm32}}} || ||
||<|2>{{{83 /1 ib}}} ||8086/8088 ||{{{OR r/m16,imm8}}} ||<|2> r/m |= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{OR r/m32,imm8}}} || ||
[각주]
===== XOR =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{30 /r}}} ||8086/8088 ||{{{XOR r/m8,r8}}} || r/m ^= r || ||
||<|2>{{{31 /r}}} ||8086/8088 ||{{{XOR r/m16,r16}}} ||<|2> r/m ^= r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{XOR r/m32,r32}}} || ||
||{{{32 /r}}} ||8086/8088 ||{{{XOR r8,r/m8}}} || r ^= r/m || ||
||<|2>{{{33 /r}}} ||8086/8088 ||{{{XOR r16,r/m16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> r/m ^= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{81 /6 id}}} ||80386 ||{{{XOR r/m32,imm32}}} || ||
||<|2>{{{83 /6 ib}}} ||8086/8088 ||{{{XOR r/m16,imm8}}} ||<|2> r/m ^= imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{XOR r/m32,imm8}}} || ||
[각주]
===== NOT =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{F6 /2}}} ||8086/8088 ||{{{NOT r/m8}}} || r/m = ~(r/m) || ||
||<|2>{{{F7 /2}}} ||8086/8088 ||{{{NOT r/m16}}} ||<|2> r/m = ~(r/m) ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{NOT r/m32}}} || ||
[각주]
===== TEST =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{84 /r}}} ||8086/8088 ||{{{TEST r/m8,r8}}} || temp = r/m & r || ||
||<|2>{{{85 /r}}} ||8086/8088 ||{{{TEST r/m16,r16}}} ||<|2> 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}}} ||<|2> 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}}} ||<|2> temp = r/m & imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||{{{F7 /0 id}}} ||80386 ||{{{TEST r/m32,imm32}}} || ||
{{{AND}}} 연산을 수행 후 결과값을 레지스터에 저장하지 않고 플래그만 설정하는 명령어이다.
[각주]
==== x86 Shift 명령어 ====
Barrel Shifter를 사용하는 명령어의 목록이다. 1만큼 rotate/shift하는 명령어가 별도의 opcode에 인코딩된 것이 특징이다.
===== ROL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{C0 /0 ib}}} ||80186 ||{{{ROL r/m8,imm8}}} || || ||
||<|2>{{{C1 /0 ib}}} ||80186 ||{{{ROL r/m16,imm8}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ROL r/m32,imm8}}} || || ||
||{{{D0 /0}}} ||8086/8088 ||{{{ROL r/m8,1}}} || || ||
||<|2>{{{D1 /0}}} ||8086/8088 ||{{{ROL r/m16,1}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ROL r/m32,1}}} || || ||
||{{{D2 /0}}} ||8086/8088 ||{{{ROL r/m8,CL}}} || || ||
||<|2>{{{D3 /0}}} ||8086/8088 ||{{{ROL r/m16,CL}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ROL r/m32,CL}}} || || ||
[각주]
===== ROR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{C0 /1 ib}}} ||80186 ||{{{ROR r/m8,imm8}}} || || ||
||<|2>{{{C1 /1 ib}}} ||80186 ||{{{ROR r/m16,imm8}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ROR r/m32,imm8}}} || || ||
||{{{D0 /1}}} ||8086/8088 ||{{{ROR r/m8,1}}} || || ||
||<|2>{{{D1 /1}}} ||8086/8088 ||{{{ROR r/m16,1}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ROR r/m32,1}}} || || ||
||{{{D2 /1}}} ||8086/8088 ||{{{ROR r/m8,CL}}} || || ||
||<|2>{{{D3 /1}}} ||8086/8088 ||{{{ROR r/m16,CL}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{ROR r/m32,CL}}} || || ||
[각주]
===== RCL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{C0 /2 ib}}} ||80186 ||{{{RCL r/m8,imm8}}} || || ||
||<|2>{{{C1 /2 ib}}} ||80186 ||{{{RCL r/m16,imm8}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{RCL r/m32,imm8}}} || || ||
||{{{D0 /2}}} ||8086/8088 ||{{{RCL r/m8,1}}} || || ||
||<|2>{{{D1 /2}}} ||8086/8088 ||{{{RCL r/m16,1}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{RCL r/m32,1}}} || || ||
||{{{D2 /2}}} ||8086/8088 ||{{{RCL r/m8,CL}}} || || ||
||<|2>{{{D3 /2}}} ||8086/8088 ||{{{RCL r/m16,CL}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{RCL r/m32,CL}}} || || ||
[각주]
===== RCR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{C0 /3 ib}}} ||80186 ||{{{RCR r/m8,imm8}}} || || ||
||<|2>{{{C1 /3 ib}}} ||80186 ||{{{RCR r/m16,imm8}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{RCR r/m32,imm8}}} || || ||
||{{{D0 /3}}} ||8086/8088 ||{{{RCR r/m8,1}}} || || ||
||<|2>{{{D1 /3}}} ||8086/8088 ||{{{RCR r/m16,1}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{RCR r/m32,1}}} || || ||
||{{{D2 /3}}} ||8086/8088 ||{{{RCR r/m8,CL}}} || || ||
||<|2>{{{D3 /3}}} ||8086/8088 ||{{{RCR r/m16,CL}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{RCR r/m32,CL}}} || || ||
[각주]
===== SHL / SAL =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{C0 /4 ib}}} ||80186 ||{{{SHL r/m8,imm8}}} || r/m <<= imm & 0x1f || ||
||<|2>{{{C1 /4 ib}}} ||80186 ||{{{SHL r/m16,imm8}}} ||<|2> r/m <<= imm & 0x1f ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SHL r/m32,imm8}}} || ||
||{{{D0 /4}}} ||8086/8088 ||{{{SHL r/m8}}} || r/m <<= 1 || ||
||<|2>{{{D1 /4}}} ||8086/8088 ||{{{SHL r/m16}}} ||<|2> r/m <<= 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SHL r/m32}}} || ||
||{{{D2 /4}}} ||8086/8088 ||{{{SHL r/m8,CL}}} || r/m <<= cl & 0x1f || ||
||<|2>{{{D3 /4}}} ||8086/8088 ||{{{SHL r/m16,CL}}} ||<|2> r/m <<= cl & 0x1f ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SHL r/m32,CL}}} || ||
{{{SHL}}} 명령어와 {{{SAL}}} 명령어는 동일한 연산을 수행한다.
[각주]
===== SHR =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{C0 /5 ib}}} ||80186 ||{{{SHR r/m8,imm8}}} || r/m >>= imm & 0x1f || ||
||<|2>{{{C1 /5 ib}}} ||80186 ||{{{SHR r/m16,imm8}}} ||<|2> r/m >>= imm & 0x1f ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SHR r/m32,imm8}}} || ||
||{{{D0 /5}}} ||8086/8088 ||{{{SHR r/m8}}} || r/m >>= 1 || ||
||<|2>{{{D1 /5}}} ||8086/8088 ||{{{SHR r/m16}}} ||<|2> r/m >>= 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SHR r/m32}}} || ||
||{{{D2 /5}}} ||8086/8088 ||{{{SHR r/m8,CL}}} || r/m >>= cl & 0x1f || ||
||<|2>{{{D3 /5}}} ||8086/8088 ||{{{SHR r/m16,CL}}} ||<|2> r/m >>= cl & 0x1f ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SHR r/m32,CL}}} || ||
[각주]
===== SAR =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{C0 /7 ib}}} ||80186 ||{{{SAR r/m8,imm8}}} || r/m >>= imm & 0x1f || ||
||<|2>{{{C1 /7 ib}}} ||80186 ||{{{SAR r/m16,imm8}}} ||<|2> r/m >>= imm & 0x1f ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SAR r/m32,imm8}}} || ||
||{{{D0 /7}}} ||8086/8088 ||{{{SAR r/m8}}} || r/m >>= 1 || ||
||<|2>{{{D1 /7}}} ||8086/8088 ||{{{SAR r/m16}}} ||<|2> r/m >>= 1 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SAR r/m32}}} || ||
||{{{D2 /7}}} ||8086/8088 ||{{{SAR r/m8,CL}}} || r/m >>= cl & 0x1f || ||
||<|2>{{{D3 /7}}} ||8086/8088 ||{{{SAR r/m16,CL}}} ||<|2> r/m >>= cl & 0x1f ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SAR r/m32,CL}}} || ||
[각주]
===== SHLD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F A4}}} ||<|2>80386 ||{{{SHLD r/m16,r16,imm8}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{SHLD r/m32,r32,imm8}}} || ||
||<|2>{{{0F A5}}} ||<|2>80386 ||{{{SHLD r/m16,r16,CL}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{SHLD r/m32,r32,CL}}} || ||
[각주]
===== SHRD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F AC}}} ||<|2>80386 ||{{{SHRD r/m16,r16,imm8}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{SHRD r/m32,r32,imm8}}} || ||
||<|2>{{{0F AD}}} ||<|2>80386 ||{{{SHRD r/m16,r16,CL}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{SHRD r/m32,r32,CL}}} || ||
[각주]
==== x86 메모리 관련 명령어 ====
===== MOV =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{88 /r}}} ||8086/8088 ||{{{MOV r/m8,r8}}} || r/m = r || ||
||<|2>{{{89 /r}}} ||8086/8088 ||{{{MOV r/m16,r16}}} ||<|2> r/m = r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{MOV r/m32,r32}}} || ||
||{{{8A /r}}} ||8086/8088 ||{{{MOV r8,r/m8}}} || r = r/m || ||
||<|2>{{{8B /r}}} ||8086/8088 ||{{{MOV r16,r/m16}}} ||<|2> 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}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{B8+rd id}}} ||80386 ||{{{MOV r32,imm32}}} || ||
||{{{C6 /0}}} ||8086/8088 ||{{{MOV r/m8,imm8}}} || || ||
||<|2>{{{C7 /0}}} ||8086/8088 ||{{{MOV r/m16,imm16}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{MOV r/m32,imm32}}} || ||
====== 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) || ||
||<|2>{{{A1 /r}}} ||8086/8088 ||{{{MOV ax,moffs16}}} ||<|2> a = (seg:offset) ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{MOV eax,moffs32}}} || ||
||{{{A2 /r}}} ||8086/8088 ||{{{MOV moffs8,al}}} || (seg:offset) = a || ||
||<|2>{{{A3 /r}}} ||8086/8088 ||{{{MOV moffs16,ax}}} ||<|2> (seg:offset) = a ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{MOV moffs32,eax}}} || ||
[각주]
===== XCHG =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{86 /r}}} ||8086/8088 ||{{{XCHG r/m8,r8}}}
{{{XCHG r8,r/m8}}} || || ||
||<|2>{{{87 /r}}} ||8086/8088 ||{{{XCHG r/m16,r16}}}
{{{XCHG r16,r/m16}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{XCHG r/m32,r32}}}
{{{XCHG r32,r/m32}}} || ||
||{{{90+rw}}} ||8086/8088 ||{{{XCHG ax,r16}}}
{{{XCHG r16,ax}}} ||<|2> ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{90+rd}}} ||80386 ||{{{XCHG eax,r32}}}
{{{XCHG r32,eax}}} || ||
[각주]
===== CMPXCHG =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F B0 /r}}} ||80486 ||{{{CMPXCHG r/m8,r8}}} ||[* 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.] || ||
||<|2>{{{0F B1 /r}}} ||<|2>80486 ||{{{CMPXCHG r/m16,r16}}} ||[* 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.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{CMPXCHG r/m32,r32}}} ||[* 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.] || ||
LOCK 접두사와 함께 사용하는 경우 원자적으로 실행된다.
[각주]
====== CMPXCHG8B ======
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F C7 /1 m64}}} ||Pentium ||{{{CMPXCHG8B m64}}} ||[* Compare EDX:EAX with m64. If equal, set ZF and load ECX:EBX into m64. Else, clear ZF and load m64 into EDX:EAX.] ||레지스터 operand는 허용되지 않는다.[* 레지스터 operand 사용 시 예외를 발생시킨다. 그러나 LOCK 접두사와 함께 레지스터 operand를 사용하는 경우 프로세서에 따라 LOCK 접두사가 실행되어 예외 처리 과정이 정상적으로 작동하지 않아 프로세서가 뻗어버리는(!) 버그가 발생하기도 한다. [[인텔 펜티엄 시리즈#s-1.1.1|펜티엄]] 문서에서 언급된 '''F00F 버그'''가 이에 해당한다. 문제의 명령어는 {{{lock cmpxchg8b eax}}}({{{F0 0F C7 C8}}}))] ||
LOCK 접두사와 함께 사용하는 경우 원자적으로 실행된다.
[각주]
===== PUSH =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{50+rw}}} ||8086/8088 ||{{{PUSH r16}}} ||<|2> *--SP = r ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{50+rd}}} ||80386 ||{{{PUSH r32}}} || ||
||{{{6A}}} ||80186 ||{{{PUSH imm8}}} || *--SP = imm || ||
||<|2>{{{68}}} ||80186 ||{{{PUSH imm16}}} ||<|2> *--SP = imm ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{PUSH imm32}}} || ||
||<|2>{{{FF /6}}} ||8086/8088 ||{{{PUSH r/m16}}} ||<|2> *--SP = r/m ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{PUSH r/m32}}} || ||
{{{67h}}} 접두사 사용 시 16-bit 스택 포인터인 {{{SP}}} 레지스터가 사용된다. PUSH 연산 실행 시 16-bit 모드 또는 {{{66h}}} 접두사 사용 시 스택 포인터가 2 감소하고, 32-bit 모드에서는 스택 포인터가 4 감소한다.
====== 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 || ||
====== PUSHA/PUSHAD ======
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{60}}} ||80186 ||{{{PUSHA}}} || [* 16-bit 범용 레지스터 전체를 번호 오름차순으로 스택에 push한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{PUSHAD}}} || [* 32-bit 범용 레지스터 전체를 번호 오름차순으로 스택에 push한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.] || ||
====== PUSHF/PUSHFD [anchor(pushf)] ======
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||<|2>{{{9C}}} ||8086/8088 ||{{{PUSHF}}} || *--SP = FLAGS ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{PUSHFD}}} || *--SP = EFLAGS || ||
[각주]
===== POP =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{58+rw}}} ||8086/8088 ||{{{POP r16}}} ||<|2> r = *SP++ ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{58+rd}}} ||80386 ||{{{POP r32}}} || ||
||<|2>{{{8F /0}}} ||8086/8088 ||{{{POP r/m16}}} ||<|2> r/m = *SP++ ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{POP r/m32}}} || ||
====== 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}}}를 변경할 때까지 인터럽트를 억제시킨다.
====== POPA/POPAD ======
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{61}}} ||80186 ||{{{POPA}}} || [* 16-bit 범용 레지스터 전체를 번호 내림차순으로 스택으로부터 pop한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{POPAD}}} || [* 32-bit 범용 레지스터 전체를 번호 내림차순으로 스택으로부터 pop한다. AMD64 확장의 64-bit 모드에서는 지원되지 않는다.] || ||
====== POPF/POPFD [anchor(popf)] ======
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||<|2>{{{9D}}} ||8086/8088 ||{{{POPF}}} || FLAGS = *SP++ ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{POPFD}}} || EFLAGS = *SP++ || ||
[각주]
===== CBW/CWDE =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{98}}} ||8086/8088 ||{{{CBW}}} ||AX ← sign-extend of AL ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{CWDE}}} ||EAX ← sign-extend of AX || ||
[각주]
===== CWD/CDQ =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{99}}} ||8086/8088 ||{{{CWD}}} ||DX:AX ← sign-extend of AX ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{CDQ}}} ||EDX:EAX ← sign-extend of EAX || ||
[각주]
===== MOVZX =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F B6 /r}}} ||<|2>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 || ||
[각주]
===== MOVSX =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F BE /r}}} ||<|2>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 || ||
[각주]
===== LEA =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||<|2>{{{8D /r}}} ||8086/8088 ||{{{LEA r16,m}}} ||<|2> 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 레지스터에 저장된다. ||
[각주]
===== ENTER =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{C8 iw 00}}} ||80186 ||{{{ENTER imm16,0}}} ||Create a stack frame for a procedure || ||
||{{{C8 iw 01}}} ||<|2>80186 ||{{{ENTER imm16,1}}} ||<|2>Create a nested stack frame for a procedure || ||
||{{{C8 iw ib}}} ||{{{ENTER imm16,imm8}}} ||[* Nesting level에는 imm8을 32로 나눈 나머지 값(0-31)이 사용됨] ||
16-bit 모드 또는 {{{66h}}} 접두사 사용 시 스택에서 {{{BP}}} 레지스터 값에 대한 push를 수행하고, 32-bit 모드에서는 {{{EBP}}} 레지스터 값에 대한 push를 수행한다.
[각주]
===== LEAVE =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||<|2>{{{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을 수행한다.
[각주]
===== BOUND =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{62 /r}}} ||80186 ||{{{BOUND r16,m16&16}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{BOUND r32,m32&32}}} || || ||
[각주]
===== 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}}})
[각주]
===== XADD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F C0 /r}}} ||80486 ||{{{XADD r/m8,r8}}} ||Exchange r8 and r/m8; load sum into r/m8. || ||
||<|2>{{{0F C1 /r}}} ||<|2>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 접두사와 함께 사용하는 경우 원자적으로 실행된다.
[각주]
===== 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]}}}을 사용한다.
[각주]
===== LAHF =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9F}}} ||8086/8088 ||{{{LAHF}}} ||Load: AH ← EFLAGS(SF:ZF:0:AF:0:PF:1:CF) || ||
[각주]
===== SAHF =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9E}}} ||8086/8088 ||{{{SAHF}}} ||Loads SF, ZF, AF, PF, and CF from AH into EFLAGS register || ||
[각주]
===== LDS/LES/LFS/LGS/LSS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{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 || ||
||<|2>{{{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 || ||
||<|2>{{{0F B2 /r}}} ||<|2>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 || ||
||<|2>{{{0F B4 /r}}} ||<|2>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 || ||
||<|2>{{{0F B5 /r}}} ||<|2>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 || ||
[각주]
==== x86 제어/조건부 명령어 ====
===== JMP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{EB cb}}} ||8086/8088 ||{{{JMP rel8}}} ||Jump short, relative || ||
||{{{E9 cw}}} ||8086/8088 ||{{{JMP rel16}}} ||<|2>Jump near, relative ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*jmp-ip 이때 ip는 16-bit로 간주되어 eip의 상위 16-bit가 비워진다.] ||
||{{{E9 cd}}} ||80386 ||{{{JMP rel32}}} || ||
||{{{EA cd}}} ||8086/8088 ||{{{JMP ptr16:16}}} ||<|2>Jump far, absolute ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*jmp-ip] ||
||{{{EA cp}}} ||80386 ||{{{JMP ptr16:32}}} || ||
||<|2>{{{FF /4}}} ||8086/8088 ||{{{JMP r/m16}}} ||<|2>Jump near, absolute indirect ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*jmp-ip] ||
||80386 ||{{{JMP r/m32}}} || ||
||<|2>{{{FF /5}}} ||8086/8088 ||{{{JMP m16:16}}} ||<|2>Jump far, absolute indirect ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*jmp-ip] ||
||80386 ||{{{JMP m16:32}}} || ||
===== Jcc =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{70+cc cb}}} ||8086/8088 ||{{{Jcc rel8}}} ||Jump short if (condition) || ||
||{{{0F 80+cc cw}}} ||80386 ||{{{Jcc rel16}}} ||<|2>Jump near if (condition) ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*jcc-ip 이때 ip는 16-bit로 간주되어 eip의 상위 16-bit가 비워진다.] ||
||{{{0F 80+cc cd}}} ||80386 ||{{{Jcc rel32}}} || ||
====== JCXZ/JECXZ ======
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{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 || ||
[각주]
===== CALL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{E8 cw}}} ||8086/8088 ||{{{CALL rel16}}} ||<|2>Call near, relative ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*call-ip 이때 ip는 16-bit로 간주되어 eip의 상위 16-bit가 비워진다.] ||
||{{{E8 cd}}} ||80386 ||{{{CALL rel32}}} || ||
||{{{9A cd}}} ||8086/8088 ||{{{CALL ptr16:16}}} ||<|2>Call far, absolute ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*call-ip] ||
||{{{9A cp}}} ||80386 ||{{{CALL ptr16:32}}} || ||
||<|2>{{{FF /2}}} ||8086/8088 ||{{{CALL r/m16}}} ||<|2>Call near, absolute indirect ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*call-ip] ||
||80386 ||{{{CALL r/m32}}} || ||
||<|2>{{{FF /3}}} ||8086/8088 ||{{{CALL m16:16}}} ||<|2>Call far, absolute indirect ||32-bit 모드에서는 {{{66h}}} 접두사 필요[*call-ip] ||
||80386 ||{{{CALL m16:32}}} || ||
[각주]
===== 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}}}가 사용된다.
[각주]
===== 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 || ||
[각주]
===== 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}}} || ||[* 2018년까지 문서화되지 않음] ||
[각주]
===== IRET/IRETD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{CF}}} ||8086/8088 ||{{{IRET}}} ||<|2>Interrupt return ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{IRETD}}} || ||
[각주]
===== CMOVcc =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F 40+cc /r}}} ||<|2>Pentium Pro ||{{{CMOVcc r16, r/m16}}} ||<|2>Move if (condition) ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{CMOVcc r32, r/m32}}} || ||
[각주]
===== SETcc =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 90+cc}}} ||80386 ||{{{SETcc r/m8}}} ||Set byte if (condition) || ||
[각주]
==== x86 프로세서 제어 명령어 ====
===== LOCK prefix =====
|| Opcode || 추가 시점 || Mnemonic || 해당 명령어 || 설명 || 비고 ||
||{{{F0}}} ||8086/8088 ||{{{LOCK}}} ||[* ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCH8B, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD, XCHG.] ||[* Asserts LOCK# signal for duration of the accompanying instruction] ||[* destination operand가 memory인 경우에만 사용 가능] ||
[각주]
===== 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

===== ESC =====
|| Opcode || 추가 시점 || Mnemonic || 비고 ||
||{{{D8..DF}}} ||8086/8088 || ||외부 장치(x87 FPU)에 접근하는 명령어이다. ||
[[x86/명령어 목록#x87|x87]] 섹션 참조.
[각주]
===== WAIT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9B}}} ||8086/8088 ||{{{WAIT}}}
{{{FWAIT}}} ||Check pending unmasked floating-point exceptions. || ||
[각주]
===== HLT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{F4}}} ||8086/8088 ||{{{HLT}}} ||Halt || ||
인터럽트 또는 특정한 신호가 활성화될 때까지 명령어의 실행을 멈추고 프로세서를 HALT 상태로 둔다. 하이퍼쓰레딩이 활성화된 경우 해당 명령어를 실행한 논리 프로세서만이 비활성화되고, 같은 코어에 존재하는 다른 논리 프로세서에는 적용되지 않는다.
[각주]
==== x86 플래그 제어 및 기타 명령어 ====
===== CLC =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{F8}}} ||8086/8088 ||{{{CLC}}} ||Clear carry ||CF = 0 ||
[각주]
===== CMC =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{F5}}} ||8086/8088 ||{{{CMC}}} ||Complement carry ||CF = ~CF ||
[각주]
===== STC =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{F9}}} ||8086/8088 ||{{{STC}}} ||Set carry ||CF = 1 ||
[각주]
===== CLD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{FC}}} ||8086/8088 ||{{{CLC}}} ||Clear direction ||DF = 0 ||
[각주]
===== STD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{FD}}} ||8086/8088 ||{{{STD}}} ||Set direction ||DF = 1 ||
[각주]
===== CLI =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{FA}}} ||8086/8088 ||{{{CLI}}} ||Clear interrupt ||IF = 0 ||
[각주]
===== STI =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{FB}}} ||8086/8088 ||{{{STI}}} ||Set interrupt ||IF = 1 ||
[각주]
===== CPUID =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F A2}}} ||Pentium ||{{{CPUID}}} ||CPU Identification || ||
EAX 레지스터 값에 따라 EAX, EBX, ECX, EDX 레지스터에 프로세서 정보를 반환한다.
[각주]
==== x86 시스템 명령어 ====
===== LLDT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 00 /2}}} ||80286 ||{{{LLDT r/m16}}} ||Load segment selector r/m16 into LDTR || ||
[각주]
===== SLDT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F 00 /0}}} ||80286 ||{{{SLDT r/m16}}} ||Stores segment selector from LDTR in r/m16 ||[* 16-bit 레지스터 지정시 32-bit 모드에서는 {{{66h}}} 접두사 필요] ||
||80386 ||{{{SLDT r32}}} ||Stores segment selector from LDTR in low-order 16 bits of r32 || ||
[각주]
===== LTR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 00 /3}}} ||80286 ||{{{LTR r/m16}}} ||Load r/m16 into task register || ||
[각주]
===== STR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 00 /1}}} ||80286 ||{{{STR r/m16}}} ||Stores segment selector from TR in r/m16 || ||
[각주]
===== 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으로 간주).
[각주]
===== 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) 값이 기록된다. 
[각주]
===== 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으로 간주).
[각주]
===== 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) 값이 기록된다. 
[각주]
===== LMSW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 01 /6}}} ||80286 ||{{{LMSW r/m16}}} ||Loads r/m16 in machine status word of CR0 || ||
[각주]
===== SMSW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F 01 /4}}} ||80286 ||{{{SMSW r/m16}}} ||Store machine status word to r/m16 ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{SMSW r32/m16}}} ||[* Store machine status word in low-order 16 bits of r32/m16; high-order 16 bits of r32 are undefined] || ||
[각주]
===== VERR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 00 /4}}} ||80286 ||{{{VERR r/m16}}} ||Set ZF=1 if segment specified with r/m16 can be read || ||
[각주]
===== VERW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 00 /5}}} ||80286 ||{{{VERW r/m16}}} ||Set ZF=1 if segment specified with r/m16 can be written || ||
[각주]
===== ARPL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{63 /r}}} ||80286 ||{{{ARPL r/m16,r16}}} ||Adjust RPL of r/m16 to not less than RPL of r16 || ||
[각주]
===== LAR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F 02 /r}}} ||80286 ||{{{LAR r16,r/m16}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{LAR r32,r/m32}}} || || ||
===== LSL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F 03 /r}}} ||80286 ||{{{LSL r16,r/m16}}} || ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80386 ||{{{LSL r32,r/m32}}} || || ||
===== CLTS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 06}}} ||80286 ||{{{CLTS}}} ||Clears TS flag in CR0 || ||
===== INVD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 08}}} ||80486 ||{{{INVD}}} ||[* Flush internal caches; initiate flushing of external caches.] || ||
내부 캐시에만 존재하고 메모리에 기록되지 않은 데이터는 사라지므로 {{{WBINVD}}} 명령어를 사용하는 것이 좋다.
[각주]
===== WBINVD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 09}}} ||80486 ||{{{WBINVD}}} ||[* Write back and flush Internal caches; initiate writing-back and flushing of external caches.] || ||
[각주]
===== INVLPG =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 01 /7}}} ||80486 ||{{{INVLPG m}}} ||Invalidate TLB Entry for page that contains m || ||
[각주]
===== RSM =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F AA}}} ||i386SL[* i386SL/i486SL/후기 486 및 Pentium 이후 프로세서에서 지원된다.] ||{{{RSM}}} ||Resume operation of interrupted program || ||
[각주]
===== RDMSR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 32}}} ||Pentium ||{{{RDMSR}}} ||Load MSR specified by ECX into EDX:EAX || ||
[각주]
===== WRMSR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 30}}} ||Pentium ||{{{WRMSR}}} ||Write the value in EDX:EAX to MSR specified by ECX || ||
[각주]
===== RDPMC =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 33}}} ||Pentium MMX ||{{{RDPMC}}} ||[* Read performance-monitoring counter specified by ECX into EDX:EAX] || ||
[각주]
===== RDTSC =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 31}}} ||Pentium ||{{{RDTSC}}} ||Read time-stamp counter into EDX:EAX || ||
[각주]
===== SYSENTER =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 34}}} ||Pentium Pro ||{{{SYSENTER}}} ||Fast call to privilege level 0 system procedures || ||
[각주]
===== SYSEXIT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 35}}} ||Pentium Pro ||{{{SYSEXIT}}} ||Fast return to privilege level 3 user code. || ||
[각주]
==== x86 IO 명령어 ====
===== IN =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{E4}}} ||8086/8088 ||{{{IN al,imm8}}} ||Input byte from imm8 I/O port address into AL || ||
||<|2>{{{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 || ||
||<|2>{{{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 || ||
[각주]
===== OUT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{E6}}} ||8086/8088 ||{{{OUT imm8,al}}} ||Output byte in AL to I/O port address imm8 || ||
||<|2>{{{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 || ||
||<|2>{{{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 || ||
[각주]
==== 비트 조작 명령어 ====
===== BT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F A3}}} ||<|2>80386 ||{{{BT r/m16,r16}}} ||<|2> Store selected bit in CF flag ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BT r/m32,r32}}} || ||
||<|2>{{{0F BA /4 ib}}} ||<|2>80386 ||{{{BT r/m16,imm8}}} ||<|2> Store selected bit in CF flag ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BT r/m32,imm8}}} || ||
[각주]
===== BTS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F AB}}} ||<|2>80386 ||{{{BTS r/m16,r16}}} ||<|2> Store selected bit in CF flag and set ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BTS r/m32,r32}}} || ||
||<|2>{{{0F BA /5 ib}}} ||<|2>80386 ||{{{BTS r/m16,imm8}}} ||<|2> Store selected bit in CF flag and set ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BTS r/m32,imm8}}} || ||
[각주]
===== BTR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F B3}}} ||<|2>80386 ||{{{BTR r/m16,r16}}} ||<|2> Store selected bit in CF flag and clear ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BTR r/m32,r32}}} || ||
||<|2>{{{0F BA /6 ib}}} ||<|2>80386 ||{{{BTR r/m16,imm8}}} ||<|2> Store selected bit in CF flag and clear ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BTR r/m32,imm8}}} || ||
[각주]
===== BTC =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F BB}}} ||<|2>80386 ||{{{BTC r/m16,r16}}} ||<|2> Store selected bit in CF flag and complement ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BTC r/m32,r32}}} || ||
||<|2>{{{0F BA /7 ib}}} ||<|2>80386 ||{{{BTC r/m16,imm8}}} ||<|2> Store selected bit in CF flag and complement ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||{{{BTC r/m32,imm8}}} || ||
[각주]
===== BSF =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F BC}}} ||<|2>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를 찾아 그 위치를 저장한다.
[각주]
===== BSR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{0F BD}}} ||<|2>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를 찾아 그 위치를 저장한다.
[각주]
==== 문자열 조작 명령어 ====
===== REP prefix =====
|| Opcode || 추가 시점 || Mnemonic || 해당 명령어 || 중단 조건 1 || 중단 조건 2 || 비고 ||
||<|2>{{{F3}}} ||8086/8088 ||{{{REP}}} || {{{INS}}}, {{{OUTS}}}, {{{MOVS}}}, {{{LODS}}}, {{{STOS}}} || ECX=0 || None || ||
||8086/8088 ||{{{REPE}}}[br]{{{REPZ}}} || {{{CMPS}}}, {{{SCAS}}} || ECX=0 || ZF=0 ||Find nonmatching ||
||{{{F2}}} ||8086/8088 ||{{{REPNE}}}[br]{{{REPNZ}}} || {{{CMPS}}}, {{{SCAS}}} || ECX=0 || ZF=1 ||Find matching ||
[각주]
===== MOVS/MOVSB/MOVSW/MOVSD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{A4}}} ||8086/8088 ||{{{MOVS m8,m8}}}
{{{MOVSB}}} ||[* Move byte at address DS:(E)SI to address ES:(E)DI] || ||
||<|2>{{{A5}}} ||8086/8088 ||{{{MOVS m16,m16}}}
{{{MOVSW}}} ||[* Move word at address DS:(E)SI to address ES:(E)DI] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{MOVS m32,m32}}}
{{{MOVSD}}} ||[* Move doubleword at address DS:(E)SI to address ES:(E)DI] || ||
[각주]
===== CMPS/CMPSB/CMPSW/CMPSD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{A6}}} ||8086/8088 ||{{{CMPS m8,m8}}}
{{{CMPSB}}} ||[* Compares byte at address DS:(E)SI with byte at address ES:(E)DI and sets the status flags accordingly] || ||
||<|2>{{{A7}}} ||8086/8088 ||{{{CMPS m16,m16}}}
{{{CMPSW}}} ||[* Compares word at address DS:(E)SI with word at address ES:(E)DI and sets the status flags accordingly] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{CMPS m32,m32}}}
{{{CMPSD}}} ||[* Compares doubleword at address DS:(E)SI with doubleword at address ES:(E)DI and sets the status flags accordingly] || ||
[각주]
===== LODS/LODSB/LODSW/LODSD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{AC}}} ||8086/8088 ||{{{LODS m8}}}
{{{LODSB}}} ||[* Load byte at address DS:(E)SI into AL] || ||
||<|2>{{{AD}}} ||8086/8088 ||{{{LODS m16}}}
{{{LODSW}}} ||[* Load word at address DS:(E)SI into AX] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{LODS m32}}}
{{{LODSD}}} ||[* Load doubleword at address DS:(E)SI into EAX] || ||
[각주]
===== SCAS/SCASB/SCASW/SCASD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{AE}}} ||8086/8088 ||{{{SCAS m8}}}
{{{SCASB}}} ||[* Compare AL with byte at ES:(E)DI and set status flags] || ||
||<|2>{{{AF}}} ||8086/8088 ||{{{SCAS m16}}}
{{{SCASW}}} ||[* Compare AX with word at ES:(E)DI and set status flags] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{SCAS m32}}}
{{{SCASD}}} ||[* Compare EAX with doubleword at ES(E)DI and set status flags] || ||
[각주]
===== STOS/STOSB/STOSW/STOSD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{AA}}} ||8086/8088 ||{{{STOS m8}}}
{{{STOSB}}} ||[* Store AL at address ES:(E)DI] || ||
||<|2>{{{AB}}} ||8086/8088 ||{{{STOS m16}}}
{{{STOSW}}} ||[* Store AX at address ES:(E)DI] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{STOS m32}}}
{{{STOSD}}} ||[* Store EAX at address ES:(E)DI] || ||
[각주]
===== INS/INSB/INSW/INSD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{6C}}} ||80186 ||{{{INS m8,dx}}}
{{{INSB}}} ||[* Input byte from I/O port specified in DX into memory location specified in ES:(E)DI] || ||
||<|2>{{{6D}}} ||80186 ||{{{INS m16,dx}}}
{{{INSW}}} ||[* Input word from I/O port specified in DX into memory location specified in ES:(E)DI] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{INS m32,dx}}}
{{{INSD}}} ||[* Input doubleword from I/O port specified in DX into memory location specified in ES:(E)DI] || ||
[각주]
===== OUTS/OUTSB/OUTSW/OUTSD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{6E}}} ||80186 ||{{{OUTS dx,m8}}}
{{{OUTSB}}} ||[* Output byte from memory location specified in DS:(E)SI to I/O port specified in DX] || ||
||<|2>{{{6F}}} ||80186 ||{{{OUTS dx,m16}}}
{{{OUTSW}}} ||[* Output word from memory location specified in DS:(E)SI to I/O port specified in DX] ||32-bit 모드에서는 {{{66h}}} 접두사 필요  ||
||80386 ||{{{OUTS dx,m32}}}
{{{OUTSD}}} ||[* Output doubleword from memory location specified in DS:(E)SI to I/O port specified in DX] || ||
[각주]
==== BCD 명령어 ====
===== AAA =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{37}}} ||8086/8088 ||{{{AAA}}} ||ASCII adjust AL after addition || ||
[각주]
===== AAS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{3F}}} ||8086/8088 ||{{{AAS}}} ||ASCII adjust AL after subtraction || ||
[각주]
===== 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 || ||
[각주]
===== 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 || ||
[각주]
===== DAA =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{27}}} ||8086/8088 ||{{{DAA}}} ||Decimal adjust AL after addition || ||
예: {{{79h}}} + {{{35h}}} = {{{AEh}}} → {{{14h}}} (DAA)
[각주]
===== DAS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{2F}}} ||8086/8088 ||{{{DAS}}} ||Decimal adjust AL after subtraction || ||
예: {{{35h}}} - {{{47h}}} = {{{EEh}}} → {{{88h}}} (DAS)
[각주]
=== x87 FPU 명령어 [anchor(x87)] ===
==== x87 메모리 명령어 ====
===== FLD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 /0}}} ||<|2>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)) || ||
[각주]
===== FST =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 /2}}} ||<|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) || ||
[각주]
===== FSTP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 /3}}} ||<|2>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() ||[* {{{DF D0+i}}} 등 비공식적인 opcode가 존재한다.] ||
[각주]
===== FXCH =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 C8+i}}} ||<|2>8087 ||{{{FXCH st(i)}}} || st(0) <-> st(i) ||[* {{{DD C8+i}}} 등 비공식적인 opcode가 존재한다.] ||
||{{{D9 C9}}} ||{{{FXCH}}} || st(0) <-> st(1) || ||
[각주]
===== FCMOVcc =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA C0+i}}} ||<|8>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}}} 레지스터에 있는 상태 플래그의 값에 따라 이동 연산을 수행한다.
[각주]
===== FILD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DF /0}}} ||<|2>8087 ||{{{FILD m16int}}} || PUSH(m16int) || ||
||{{{DB /0}}} ||{{{FILD m32int}}} || PUSH(m32int) || ||
||{{{DF /5}}} ||8087 ||{{{FILD m64int}}} || PUSH(m64int) || ||
[각주]
===== FIST =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DF /2}}} ||<|2>8087 ||{{{FIST m16int}}} || m16int = st(0) || ||
||{{{DB /2}}} ||{{{FIST m32int}}} || m32int = st(0) || ||
[각주]
===== FISTP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DF /3}}} ||<|2>8087 ||{{{FISTP m16int}}} || m16int = st(0); POP() || ||
||{{{DB /3}}} ||{{{FISTP m32int}}} || m32int = st(0); POP() || ||
||{{{DF /7}}} ||8087 ||{{{FISTP m64int}}} || m64int = st(0); POP() || ||
[각주]
===== FISTTP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DF /1}}} ||<|3>SSE3 ||{{{FISTTP m16int}}} || m16int = st(0); POP() || ||
||{{{DB /1}}} ||{{{FISTTP m32int}}} || m32int = st(0); POP() || ||
||{{{DD /1}}} ||{{{FISTTP m64int}}} || m64int = st(0); POP() || ||
[각주]
===== FBLD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DF /4}}} ||8087 ||{{{FBLD m80bcd}}} || PUSH(m80bcd) || ||
[각주]
===== FBSTP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DF /6}}} ||8087 ||{{{FBSTP m80bcd}}} || m80bcd = st(0); POP() || ||
[각주]
===== FLD1/FLDL2T/FLDL2E/FLDPI/FLDLG2/FLDLN2/FLDZ =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 E8}}} ||<|7>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. || ||
[각주]
==== x87 사칙연산 명령어 ====
===== FADD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /0}}} ||<|2>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) || ||
[각주]
===== FADDP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE C0+i}}} ||<|2>8087 ||{{{FADDP st(i), st(0)}}} || st(i) += st(0); POP() || ||
||{{{DE C1}}} ||{{{FADDP}}} || st(1) += st(0); POP() || ||
[각주]
===== FSUB =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /4}}} ||<|2>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) || ||
[각주]
===== FSUBP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE E8+i}}} ||<|2>8087 ||{{{FSUBP st(i), st(0)}}} || st(i) -= st(0); POP() || ||
||{{{DE E9}}} ||{{{FSUBP}}} || st(1) -= st(0); POP() || ||
[각주]
===== FSUBR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /5}}} ||<|2>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) || ||
[각주]
===== FSUBRP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE E0+i}}} ||<|2>8087 ||{{{FSUBRP st(i), st(0)}}} || st(i) = st(0) - st(i); POP() || ||
||{{{DE E1}}} ||{{{FSUBRP}}} || st(1) = st(0) - st(1); POP() || ||
[각주]
===== FMUL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /1}}} ||<|2>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) || ||
[각주]
===== FMULP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE C8+i}}} ||<|2>8087 ||{{{FMULP st(i), st(0)}}} || st(i) *= st(0); POP() || ||
||{{{DE C9}}} ||{{{FMULP}}} || st(1) *= st(0); POP() || ||
[각주]
===== FDIV =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /6}}} ||<|2>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) || ||
[각주]
===== FDIVP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE F8+i}}} ||<|2>8087 ||{{{FDIVP st(i), st(0)}}} || st(i) /= st(0); POP() || ||
||{{{DE F9}}} ||{{{FDIVP}}} || st(1) /= st(0); POP() || ||
[각주]
===== FDIVR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /7}}} ||<|2>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) || ||
[각주]
===== FDIVRP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE F0+i}}} ||<|2>8087 ||{{{FDIVRP st(i), st(0)}}} || st(i) = st(0) / st(i); POP() || ||
||{{{DE F1}}} ||{{{FDIVRP}}} || st(1) = st(0) / st(1); POP() || ||
[각주]
===== FCHS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 E0}}} ||8087 ||{{{FCHS}}} || st(0) = -st(0) || ||
[각주]
===== FABS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 E1}}} ||8087 ||{{{FABS}}} ||Replace ST(0) with its absolute value. || ||
[각주]
===== FSQRT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 FA}}} ||8087 ||{{{FABS}}} ||Computes square root of ST(0) and stores the result in ST(0). || ||
[각주]
===== FPREM =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F8}}} ||8087 ||{{{FPREM}}} ||st(0) −= (Q ∗ st(1)) ||Truncate ||
[각주]
===== FPREM1 =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F5}}} ||80387 ||{{{FPREM1}}} ||st(0) −= (Q ∗ st(1)) ||Round to nearest (IEEE-754 compliant) ||
[각주]
===== FRNDINT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 FC}}} ||8087 ||{{{FRNDINT}}} ||Round ST(0) to an integer. || ||
[각주]
===== FXTRACT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F4}}} ||8087 ||{{{FXTRACT}}} ||st(0) = Exponent(ST), PUSH(Significand(ST)) || ||
[각주]
===== FIADD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA /0}}} ||<|2>8087 ||{{{FIADD m32int}}} || st(0) += m32int || ||
||{{{DE /0}}} ||{{{FIADD m16int}}} || st(0) += m16int || ||
[각주]
===== FISUB =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA /4}}} ||<|2>8087 ||{{{FISUB m32int}}} || st(0) -= m32int || ||
||{{{DE /4}}} ||{{{FISUB m16int}}} || st(0) -= m16int || ||
[각주]
===== FISUBR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA /5}}} ||<|2>8087 ||{{{FISUBR m32int}}} || st(0) = m32int - st(0) || ||
||{{{DE /5}}} ||{{{FISUBR m16int}}} || st(0) = m16int - st(0) || ||
[각주]
===== FIMUL =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA /1}}} ||<|2>8087 ||{{{FIMUL m32int}}} || st(0) *= m32int || ||
||{{{DE /1}}} ||{{{FIMUL m16int}}} || st(0) *= m16int || ||
[각주]
===== FIDIV =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA /6}}} ||<|2>8087 ||{{{FIDIV m32int}}} || st(0) /= m32int || ||
||{{{DE /6}}} ||{{{FIDIV m16int}}} || st(0) /= m16int || ||
[각주]
===== FIDIVR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DA /7}}} ||<|2>8087 ||{{{FIDIVR m32int}}} || st(0) = m32int / st(0) || ||
||{{{DE /7}}} ||{{{FIDIVR m16int}}} || st(0) = m16int / st(0) || ||
[각주]
==== x87 비교 명령어 ====
===== FCOM/FCOMP/FCOMPP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D8 /2}}} ||<|2>8087 ||{{{FCOM m32fp}}} ||Compare ST(0) with m32fp. || ||
||{{{DC /2}}} ||{{{FCOM m64fp}}} ||Compare ST(0) with m64fp. || ||
||{{{D8 D0+i}}} ||<|2>8087 ||{{{FCOM st(i)}}} ||Compare ST(0) with ST(i). ||[* {{{DC D0+i}}} 등 비공식적인 opcode가 존재한다.] ||
||{{{D8 D1}}} ||{{{FCOM}}} ||Compare ST(0) with ST(1). || ||
||{{{D8 /3}}} ||<|2>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}}} ||<|2>8087 ||{{{FCOMP st(i)}}} ||Compare ST(0) with ST(i) and pop register stack. ||[* {{{DC D8+i}}}, {{{DE D0+i}}} 등 비공식적인 opcode가 존재한다.] ||
||{{{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. || ||
[각주]
===== FUCOM/FUCOMP/FUCOMPP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DD E0+i}}} ||<|2>80387 ||{{{FUCOM st(i)}}} ||Compare ST(0) with ST(i) || ||
||{{{DD E1}}} ||{{{FUCOM}}} ||Compare ST(0) with ST(1) || ||
||{{{DD E8+i}}} ||<|2>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 || ||
[각주]
===== FICOM/FICOMP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DE /2}}} ||<|2>8087 ||{{{FICOM m16int}}} ||Compare ST(0) with m16int || ||
||{{{DA /2}}} ||{{{FICOM m32int}}} ||Compare ST(0) with m32int || ||
||{{{DE /3}}} ||<|2>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 || ||
[각주]
===== FCOMI/FCOMIP/FUCOMI/FUCOMIP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DB F0+i}}} ||Pentium Pro ||{{{FCOMI st(0),st(i)}}} ||[* Compare ST(0) with ST(i) and set status flags accordingly] || ||
||{{{DF F0+i}}} ||Pentium Pro ||{{{FCOMIP st(0),st(i)}}} ||[* Compare ST(0) with ST(i), set status flags accordingly, and pop register stack] || ||
||{{{DB E8+i}}} ||Pentium Pro ||{{{FUCOMI st(0),st(i)}}} ||[* Compare ST(0) with ST(i), check for ordered values, and set status flags accordingly] || ||
||{{{DF E8+i}}} ||Pentium Pro ||{{{FUCOMIP st(0),st(i)}}} ||[* Compare ST(0) with ST(i), check for ordered values, set status flags accordingly, and pop register stack] || ||
[각주]
===== FTST =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 E4}}} ||8087 ||{{{FTST}}} ||Compare ST(0) with 0.0. || ||
[각주]
===== FXAM =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 E5}}} ||8087 ||{{{FXAM}}} ||Classify value or number in ST(0) || ||
[각주]
==== x87 특수 함수 명령어 ====
===== FSIN =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 FE}}} ||80387 ||{{{FSIN}}} ||Replace ST(0) with its sine. || ||
[각주]
===== FCOS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 FF}}} ||80387 ||{{{FCOS}}} ||Replace ST(0) with its cosine || ||
[각주]
===== FSINCOS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 FB}}} ||80387 ||{{{FSINCOS}}} ||[* Compute the sine and cosine of ST(0); replace ST(0) with the sine, and push the cosine onto the register stack.] || ||
[각주]
===== FPTAN =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F2}}} ||8087 ||{{{FPTAN}}} ||Replace ST(0) with its tangent and push 1 onto the FPU stack. || ||
[각주]
===== FPATAN =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F3}}} ||8087 ||{{{FPATAN}}} ||Replace ST(1) with arctan(ST(1)/ST(0)) and pop the register stack || ||
[각주]
===== 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 || ||
[각주]
===== 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 || ||
[각주]
===== F2XM1 =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F0}}} ||8087 ||{{{F2XM1}}} ||Replace [math(\textrm{ST}(0))] with [math(2^{\textrm{ST}(0)} – 1)] || ||
[각주]
===== FSCALE =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 FD}}} ||8087 ||{{{FSCALE}}} ||Scale ST(0) by ST(1). || ||
[각주]
==== x87 FPU 제어 명령어 ====
===== FINCSTP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F7}}} ||8087 ||{{{FINCSTP}}} ||Increment the TOP field in the FPU status register || ||
[각주]
===== FDECSTP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 F6}}} ||8087 ||{{{FDECSTP}}} ||Decrement TOP field in FPU status word. || ||
[각주]
===== FFREE =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{DD C0+i}}} ||8087 ||{{{FFREE st(i)}}} ||Sets tag for ST(i) to empty || ||
[각주]
===== FINIT/FNINIT =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9B DB E3}}} ||8087 ||{{{FINIT}}} ||[* Initialize FPU after checking for pending unmasked floating-point exceptions.] || ||
||{{{DB E3}}} ||8087 ||{{{FNINIT}}} ||[* Initialize FPU without checking for pending unmasked floating-point exceptions.] || ||
[각주]
===== FCLEX/FNCLEX =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9B DB E2}}} ||8087 ||{{{FCLEX}}} ||[* Clear floating-point exception flags after checking for pending unmasked floating-point exceptions.] || ||
||{{{DB E2}}} ||8087 ||{{{FNCLEX}}} ||[* Clear floating-point exception flags without checking for pending unmasked floating-point exceptions.] || ||
[각주]
===== FSTCW/FNSTCW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9B D9 /7}}} ||8087 ||{{{FSTCW m2byte}}} ||[* Store FPU control word to m2byte after checking for pending unmasked floating-point exceptions.] || ||
||{{{D9 /7}}} ||8087 ||{{{FNSTCW m2byte}}} ||[* Store FPU control word to m2byte without checking for pending unmasked floating-point exceptions.] || ||
[각주]
===== FLDCW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 /5}}} ||8087 ||{{{FLDCW m2byte}}} ||[* Load FPU control word from m2byte.] || ||
===== FSTENV/FNSTENV =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{9B D9 /6}}} ||8087 ||{{{FSTENV m14byte}}} ||[* Store FPU environment to m14byte after checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FSTENV m28byte}}} ||[* Store FPU environment to m28byte after checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.] || ||
||<|2>{{{D9 /6}}} ||8087 ||{{{FNSTENV m14byte}}} ||[* Store FPU environment to m14byte without checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FNSTENV m28byte}}} ||[* Store FPU environment to m28byte without checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions.] || ||
[각주]
===== FLDENV =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{D9 /4}}} ||8087 ||{{{FLDENV m14byte}}} ||[* Load FPU environment from m14byte.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FLDENV m28byte}}} ||[* Load FPU environment from m28byte.] || ||
[각주]
===== FSAVE/FNSAVE =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{9B DD /6}}} ||8087 ||{{{FSAVE m94byte}}} ||[* Store FPU state to m94byte after checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FSAVE m108byte}}} ||[* Store FPU state to m108byte after checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.] || ||
||<|2>{{{DD /6}}} ||8087 ||{{{FNSAVE m94byte}}} ||[* Store FPU state to m94byte without checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FNSAVE m108byte}}} ||[* Store FPU state to m108byte without checking for pending unmasked floating-point exceptions. Then re-initialize the FPU.] || ||
[각주]
===== FRSTOR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||<|2>{{{DD /4}}} ||8087 ||{{{FRSTOR m94byte}}} ||[* Load FPU state from m94byte.] ||32-bit 모드에서는 {{{66h}}} 접두사 필요 ||
||80387 ||{{{FRSTOR m108byte}}} ||[* Load FPU state from m108byte.] || ||
[각주]
===== FSTSW/FNSTSW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{9B DD /7}}} ||8087 ||{{{FSTSW m2byte}}} ||[* Store FPU status word at m2byte after checking for pending unmasked floating-point exceptions.] || ||
||{{{9B DF E0}}} ||80287 ||{{{FSTSW ax}}} ||[* Store FPU status word in AX register after checking for pending unmasked floating-point exceptions.] || ||
||{{{DD /7}}} ||8087 ||{{{FNSTSW m2byte}}} ||[* Store FPU status word at m2byte without checking for pending unmasked floating-point exceptions.] || ||
||{{{DF E0}}} ||80287 ||{{{FNSTSW ax}}} ||[* Store FPU status word in AX register without checking for pending unmasked floating-point exceptions.] || ||
[각주]
===== FNOP =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{D9 D0}}} ||8087 ||{{{FNOP}}} ||No operation is performed. || ||
[각주]
===== FXSAVE =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F AE /0}}} ||Pentium II ||{{{FXSAVE m512byte}}} ||[* Save the x87 FPU, MMX technology, XMM, and MXCSR register state to m512byte] || ||
[각주]
===== FXRSTOR =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F AE /1}}} ||Pentium II ||{{{FXRSTOR m512byte}}} ||[* Restore the x87 FPU, MMX technology, XMM, and MXCSR register state from m512byte.] || ||
[각주]
== [[SIMD]] 명령어 목록 [anchor(simd)] ==
[[스트리밍 SIMD 확장]] 문서 참조
=== MMX 확장 [anchor(mmx)] ===
 * AMD에서 만든 대응 명령어 3DNow!는 사실상 사장되었다.
 * 인텔 IA-32 소프트웨어 개발자 매뉴얼에서는 SSE에 포함된 MMX 명령어 또한 MMX 명령어로 분류하므로 이 또한 MMX 문단에 작성하나, SSE 확장과 함께 추가되었음을 명시한다. ({{{NP}}}: No Prefix. 접두사 없음.)
[각주]
==== MMX 메모리 및 변환 명령어 ====
===== 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 || ||
[각주]
===== 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 || ||
[각주]
===== PACKSSWB =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 63 /r}}} ||Pentium MMX ||{{{PACKSSWB mm1,mm2/m64}}} || || ||
||{{{66 0F 63 /r}}} ||Pentium 4 (SSE2) ||{{{PACKSSWB xmm1,xmm2/m128}}} || || ||
[각주]
===== PACKSSDW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 6B /r}}} ||Pentium MMX ||{{{PACKSSDW mm1,mm2/m64}}} || || ||
||{{{66 0F 6B /r}}} ||Pentium 4 (SSE2) ||{{{PACKSSDW xmm1,xmm2/m128}}} || || ||
[각주]
===== PACKUSWB =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 67 /r}}} ||Pentium MMX ||{{{PACKUSWB mm1,mm2/m64}}} || || ||
||{{{66 0F 67 /r}}} ||Pentium 4 (SSE2) ||{{{PACKUSWB xmm1,xmm2/m128}}} || || ||
[각주]
===== PUNPCKHBW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 68 /r}}} ||Pentium MMX ||{{{PUNPCKHBW mm1,mm2/m64}}} || || ||
||{{{66 0F 68 /r}}} ||Pentium 4 (SSE2) ||{{{PUNPCKHBW xmm1,xmm2/m128}}} || || ||
[각주]
===== PUNPCKHWD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 69 /r}}} ||Pentium MMX ||{{{PUNPCKHWD mm1,mm2/m64}}} || || ||
||{{{66 0F 69 /r}}} ||Pentium 4 (SSE2) ||{{{PUNPCKHWD xmm1,xmm2/m128}}} || || ||
[각주]
===== PUNPCKHDQ =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 6A /r}}} ||Pentium MMX ||{{{PUNPCKHDQ mm1,mm2/m64}}} || || ||
||{{{66 0F 6A /r}}} ||Pentium 4 (SSE2) ||{{{PUNPCKHDQ xmm1,xmm2/m128}}} || || ||
[각주]
===== PUNPCKLBW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 60 /r}}} ||Pentium MMX ||{{{PUNPCKLBW mm1,mm2/m32}}} || || ||
||{{{66 0F 60 /r}}} ||Pentium 4 (SSE2) ||{{{PUNPCKLBW xmm1,xmm2/m128}}} || || ||
[각주]
===== PUNPCKLWD =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 61 /r}}} ||Pentium MMX ||{{{PUNPCKLWD mm1,mm2/m32}}} || || ||
||{{{66 0F 61 /r}}} ||Pentium 4 (SSE2) ||{{{PUNPCKLWD xmm1,xmm2/m128}}} || || ||
[각주]
===== PUNPCKLDQ =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F 62 /r}}} ||Pentium MMX ||{{{PUNPCKLDQ mm1,mm2/m32}}} || || ||
||{{{66 0F 62 /r}}} ||Pentium 4 (SSE2) ||{{{PUNPCKLDQ xmm1,xmm2/m128}}} || || ||
[각주]
==== MMX Packed Arithmetic 명령어 ====
===== PADDB/PADDW/PADDD =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F FC /r}}} ||<|3>Pentium MMX ||{{{PADDW mm,mm/m64}}} ||<|3> mm += mm/m64 || ||
||{{{NP 0F FD /r}}} ||{{{PADDD mm,mm/m64}}} || ||
||{{{NP 0F FE /r}}} ||{{{PADDQ mm,mm/m64}}} || ||
||{{{66 0F FC /r}}} ||<|3>Pentium 4 (SSE2) ||{{{PADDW xmm1,xmm2/m128}}} ||<|3> xmm1 += xmm2/m128 || ||
||{{{66 0F FD /r}}} ||{{{PADDD xmm1,xmm2/m128}}} || ||
||{{{66 0F FE /r}}} ||{{{PADDQ xmm1,xmm2/m128}}} || ||
[각주]
===== PADDSB/PADDSW =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F EC /r}}} ||<|2>Pentium MMX ||{{{PADDSB mm,mm/m64}}} ||<|2> mm += mm/m64 || ||
||{{{NP 0F ED /r}}} ||{{{PADDSW mm,mm/m64}}} || ||
||{{{66 0F EC /r}}} ||<|2>Pentium 4 (SSE2) ||{{{PADDSB xmm1,xmm2/m128}}} ||<|2> xmm1 += xmm2/m128 || ||
||{{{66 0F ED /r}}} ||{{{PADDSW xmm1,xmm2/m128}}} || ||
[각주]
===== PADDUSB/PADDUSW =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F DC /r}}} ||<|2>Pentium MMX ||{{{PADDUSB mm,mm/m64}}} ||<|2> mm += mm/m64 || ||
||{{{NP 0F DD /r}}} ||{{{PADDUSW mm,mm/m64}}} || ||
||{{{66 0F DC /r}}} ||<|2>Pentium 4 (SSE2) ||{{{PADDUSB xmm1,xmm2/m128}}} ||<|2> xmm1 += xmm2/m128 || ||
||{{{66 0F DD /r}}} ||{{{PADDUSW xmm1,xmm2/m128}}} || ||
[각주]
===== PSUBB/PSUBW/PSUBD =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F F8 /r}}} ||<|3>Pentium MMX ||{{{PSUBW mm,mm/m64}}} ||<|3> mm -= mm/m64 || ||
||{{{NP 0F F9 /r}}} ||{{{PSUBD mm,mm/m64}}} || ||
||{{{NP 0F FA /r}}} ||{{{PSUBQ mm,mm/m64}}} || ||
||{{{66 0F F8 /r}}} ||<|3>Pentium 4 (SSE2) ||{{{PSUBW xmm1,xmm2/m128}}} ||<|3> xmm1 -= xmm2/m128 || ||
||{{{66 0F F9 /r}}} ||{{{PSUBD xmm1,xmm2/m128}}} || ||
||{{{66 0F FA /r}}} ||{{{PSUBQ xmm1,xmm2/m128}}} || ||
[각주]
===== PSUBSB/PSUBSW =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F E8 /r}}} ||<|2>Pentium MMX ||{{{PSUBSB mm,mm/m64}}} ||<|2> mm -= mm/m64 || ||
||{{{NP 0F E9 /r}}} ||{{{PSUBSW mm,mm/m64}}} || ||
||{{{66 0F E8 /r}}} ||<|2>Pentium 4 (SSE2) ||{{{PSUBSB xmm1,xmm2/m128}}} ||<|2> xmm1 -= xmm2/m128 || ||
||{{{66 0F E9 /r}}} ||{{{PSUBSW xmm1,xmm2/m128}}} || ||
[각주]
===== PSUBUSB/PSUBUSW =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F D8 /r}}} ||<|2>Pentium MMX ||{{{PSUBUSB mm,mm/m64}}} ||<|2> mm -= mm/m64 || ||
||{{{NP 0F D9 /r}}} ||{{{PSUBUSW mm,mm/m64}}} || ||
||{{{66 0F D8 /r}}} ||<|2>Pentium 4 (SSE2) ||{{{PSUBUSB xmm1,xmm2/m128}}} ||<|2> xmm1 -= xmm2/m128 || ||
||{{{66 0F D9 /r}}} ||{{{PSUBUSW xmm1,xmm2/m128}}} || ||
[각주]
===== PMULHW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F E5 /r}}} ||Pentium MMX ||{{{PMULHW mm,mm/m64}}} || || ||
||{{{66 0F E5 /r}}} ||Pentium 4 (SSE2) ||{{{PMULHW xmm1,xmm2/m128}}} || || ||
[각주]
===== PMULLW =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{NP 0F D5 /r}}} ||Pentium MMX ||{{{PMULLW mm,mm/m64}}} || || ||
||{{{66 0F D5 /r}}} ||Pentium 4 (SSE2) ||{{{PMULLW xmm1,xmm2/m128}}} || || ||
[각주]
===== 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]);}}}] || ||
[각주]
==== MMX Comparison 명령어 ====
===== PCMPEQB/PCMPEQW/PCMPEQD =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F 74 /r}}} ||<|3>Pentium MMX ||{{{PCMPEQB mm,mm/m64}}} ||<|3> mm == mm/m64 || ||
||{{{NP 0F 75 /r}}} ||{{{PCMPEQW mm,mm/m64}}} || ||
||{{{NP 0F 76 /r}}} ||{{{PCMPEQD mm,mm/m64}}} || ||
||{{{66 0F 74 /r}}} ||<|3>Pentium 4 (SSE2) ||{{{PCMPEQB xmm1,xmm2/m128}}} ||<|3> xmm1 == xmm2/m128 || ||
||{{{66 0F 75 /r}}} ||{{{PCMPEQW xmm1,xmm2/m128}}} || ||
||{{{66 0F 76 /r}}} ||{{{PCMPEQD xmm1,xmm2/m128}}} || ||
[각주]
===== PCMPGTB/PCMPGTW/PCMPGTD =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F 64 /r}}} ||<|3>Pentium MMX ||{{{PCMPGTB mm,mm/m64}}} ||<|3> mm > mm/m64 || ||
||{{{NP 0F 65 /r}}} ||{{{PCMPGTW mm,mm/m64}}} || ||
||{{{NP 0F 66 /r}}} ||{{{PCMPGTD mm,mm/m64}}} || ||
||{{{66 0F 64 /r}}} ||<|3>Pentium 4 (SSE2) ||{{{PCMPGTB xmm1,xmm2/m128}}} ||<|3> xmm1 > xmm2/m128 || ||
||{{{66 0F 65 /r}}} ||{{{PCMPGTW xmm1,xmm2/m128}}} || ||
||{{{66 0F 66 /r}}} ||{{{PCMPGTD xmm1,xmm2/m128}}} || ||
[각주]
==== MMX Bitwise 명령어 ====
===== 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 || ||
[각주]
===== 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 || ||
[각주]
===== 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 || ||
[각주]
===== 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 || ||
[각주]
==== MMX Shift/Rotate 명령어 ====
===== PSLLW/PSLLD/PSLLQ =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F 71 /6 ib}}} ||<|3>Pentium MMX ||{{{PSLLW mm,imm8}}} ||<|3> mm <<= imm8 ||[*psllw count가 15 이상인 경우 모두 0으로 채운다.] ||
||{{{NP 0F 72 /6 ib}}} ||{{{PSLLD mm,imm8}}} ||[*pslld count가 31 이상인 경우 모두 0으로 채운다.] ||
||{{{NP 0F 73 /6 ib}}} ||{{{PSLLQ mm,imm8}}} ||[*psllq count가 63 이상인 경우 모두 0으로 채운다.] ||
||{{{NP 0F F1 /r}}} ||<|3>Pentium MMX ||{{{PSLLW mm,mm/m64}}} ||<|3> 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}}} ||<|3>Pentium 4 (SSE2) ||{{{PSLLW xmm1,imm8}}} ||<|3> 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}}} ||<|3>Pentium 4 (SSE2) ||{{{PSLLW xmm1,xmm2/m128}}} ||<|3> xmm1 <<= xmm2/m128 ||[*psllw] ||
||{{{66 0F F2 /r}}} ||{{{PSLLD xmm1,xmm2/m128}}} ||[*pslld] ||
||{{{66 0F F3 /r}}} ||{{{PSLLQ xmm1,xmm2/m128}}} ||[*psllq] ||
[각주]
===== PSRLW/PSRLD/PSRLQ =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F 71 /2 ib}}} ||<|3>Pentium MMX ||{{{PSRLW mm,imm8}}} ||<|3> mm >>= imm8 ||[*psrlw count가 15 이상인 경우 모두 0으로 채운다.] ||
||{{{NP 0F 72 /2 ib}}} ||{{{PSRLD mm,imm8}}} ||[*psrld count가 31 이상인 경우 모두 0으로 채운다.] ||
||{{{NP 0F 73 /2 ib}}} ||{{{PSRLQ mm,imm8}}} ||[*psrlq count가 63 이상인 경우 모두 0으로 채운다.] ||
||{{{NP 0F D1 /r}}} ||<|3>Pentium MMX ||{{{PSRLW mm,mm/m64}}} ||<|3> 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}}} ||<|3>Pentium 4 (SSE2) ||{{{PSRLW xmm1,imm8}}} ||<|3> 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}}} ||<|3>Pentium 4 (SSE2) ||{{{PSRLW xmm1,xmm2/m128}}} ||<|3> xmm1 >>= xmm2/m128 ||[*psrlw] ||
||{{{66 0F D2 /r}}} ||{{{PSRLD xmm1,xmm2/m128}}} ||[*psrld] ||
||{{{66 0F D3 /r}}} ||{{{PSRLQ xmm1,xmm2/m128}}} ||[*psrlq] ||
[각주]
===== PSRAW/PSRAD =====
|| Opcode || 추가 시점 || Mnemonic || 형식 || 비고 ||
||{{{NP 0F 71 /4 ib}}} ||<|2>Pentium MMX ||{{{PSRAW mm,imm8}}} ||<|2> mm >>= imm8 ||[*psraw count가 15 이상인 경우 모두 sign bit으로 채운다.] ||
||{{{NP 0F 72 /4 ib}}} ||{{{PSRAD mm,imm8}}} ||[*psrad count가 31 이상인 경우 모두 sign bit으로 채운다.] ||
||{{{NP 0F E1 /r}}} ||<|2>Pentium MMX ||{{{PSRAW mm,mm/m64}}} ||<|2> mm >>= mm/m64 ||[*psraw] ||
||{{{NP 0F E2 /r}}} ||{{{PSRAD mm,mm/m64}}} ||[*psrad] ||
||{{{66 0F 71 /4 ib}}} ||<|2>Pentium 4 (SSE2) ||{{{PSRAW xmm1,imm8}}} ||<|2> xmm1 >>= imm8 ||[*psraw] ||
||{{{66 0F 72 /4 ib}}} ||{{{PSRAD xmm1,imm8}}} ||[*psrad] ||
||{{{66 0F E1 /r}}} ||<|2>Pentium 4 (SSE2) ||{{{PSRAW xmm1,xmm2/m128}}} ||<|2> xmm1 >>= xmm2/m128 ||[*psraw] ||
||{{{66 0F E2 /r}}} ||{{{PSRAD xmm1,xmm2/m128}}} ||[*psrad] ||
[각주]
==== MMX 제어 명령어 ====
===== EMMS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{0F 77}}} ||Pentium MMX ||{{{EMMS}}} ||Set the x87 FPU tag word to empty. ||x87FPUTagWord ← {{{FFFFh}}}; ||
[각주]
=== [[SSE]] 확장 [anchor(sse)] ===
SSE의 초기 버전은 단정밀도(32-bit) 부동소수점만을 지원한다. (Scalar/Packed)
 * {{{NP}}}: No Prefix. 접두사 없음.
==== SSE 메모리 관련 명령어 ====
===== 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 || ||
[각주]
===== MOVSS =====
|| Opcode || 추가 시점 || Mnemonic || 설명 || 비고 ||
||{{{F3 0F 10 /r}}} ||Pentium III (SSE) ||{{{MOVSS xmm1,xmm2/m32}}} || xmm1[0] = xmm2[0]/m32 ||[* Source 피연산자가 {{{m32}}}인 경우 {{{XMM[127:32]}}}는 {{{0}}}으로 비워진다.] ||
||{{{F3 0F 11 /r}}} ||Pentium III (SSE) ||{{{MOVSS xmm2/m32,xmm1}}} || xmm2[0]/m32 = xmm1[0] || ||
[각주]
===== MOVLPS =====
[각주]
===== MOVHLPS =====
[각주]
===== MOVHPS =====
[각주]
===== MOVLHPS =====
[각주]
===== MOVAPS =====
[각주]
==== SSE 변환 명령어 ====
==== SSE Packed Arithmetic 명령어 ====
==== SSE Comparison 명령어 ====
==== SSE Bitwise 명령어 ====
==== SSE Shuffle/Unpack 명령어 ====
==== 기타 SSE 명령어 ====
=== SSE2 확장 [anchor(sse2)] ===
SSE2에서는 배정밀도(64-bit) 부동소수점 및 MMX 명령어 등을 지원한다.
==== SSE2 메모리 관련 명령어 ====
==== SSE2 변환 명령어 ====
==== SSE2 Packed Arithmetic 명령어 ====
==== SSE2 Comparison 명령어 ====
==== SSE2 Bitwise 명령어 ====
==== SSE2 Shuffle/Unpack 명령어 ====
==== 기타 SSE2 명령어 ====
=== SSE3 확장 [anchor(sse3)] ===
SSE3에서는 이전 SSE/SSE2와 달리 벡터 내의 각 항별로 다른 연산을 적용하거나(홀수번째 항은 덧셈, 짝수번째 항은 뺄셈) 한 벡터 내의 여러 항들 사이의 덧셈/뺄셈 연산을 지원해 3D 작업 등을 더 빠르게 수행할 수 있도록 하였다.