i8086 Encoding Rundown
┌──────ModR/M-i8086─────┬────┬────┬────┬────┬────┬────┬────┬────┐
│byte mode │%al │%cl │%dl │%bl │%ah │%ch │%dh │%bh │
│word mode │%ax │%cx │%dx │%bx │%sp │%bp │%si │%di │
│segment mode │%es │%cs │%ss │%ds │%fs │%gs │ │ │
│Reg │0 │1 │2 │3 │4 │5 │6 │7 │
├───────────────┬───┬───┼────────────────────────┴─────────┴────┤
│Address │Mod│R/M│Value of ModR/M Byte (in Octal) │
├───────────────┼───┼───┼────────────────────────┬─────────┬────┤
│(%bx,%si) │ 0 │ 0 │\000│\010│\020│\030│\040│\050│\060│\070│
│(%bx,%di) │ │ 1 │\001│\011│\021│\031│\041│\051│\061│\071│
│(%bp,%si) │ │ 2 │\002│\012│\022│\032│\042│\052│\062│\072│
│(%bp,%di) │ │ 3 │\003│\013│\023│\033│\043│\053│\063│\073│
│(%si) │ │ 4 │\004│\014│\024│\034│\044│\054│\064│\074│
│(%di) │ │ 5 │\005│\015│\025│\035│\045│\055│\065│\075│
│abs16 │ │ 6 │\006│\016│\026│\036│\046│\056│\066│\076│
│(%bx) │ │ 7 │\007│\017│\027│\037│\047│\057│\067│\077│
├───────────────┼───┼───┼────┼────┼────┼────┼────┼────┼────┼────┤
│disp8(%bx,%si) │ 1 │ 0 │\100│\110│\120│\130│\140│\150│\160│\170│
│disp8(%bx,%di) │ │ 1 │\101│\111│\121│\131│\141│\151│\161│\171│
│disp8(%bp,%si) │ │ 2 │\102│\112│\122│\132│\142│\152│\162│\172│
│disp8(%bp,%di) │ │ 3 │\103│\113│\123│\133│\143│\153│\163│\173│
│disp8(%si) │ │ 4 │\104│\114│\124│\134│\144│\154│\164│\174│
│disp8(%di) │ │ 5 │\105│\115│\125│\135│\145│\155│\165│\175│
│disp8(%bp) │ │ 6 │\106│\116│\126│\136│\146│\156│\166│\176│
│disp8(%bx) │ │ 7 │\107│\117│\127│\137│\147│\157│\167│\177│
├───────────────┼───┼───┼────┼────┼────┼────┼────┼────┼────┼────┤
│disp16(%bx,%si)│ 2 │ 0 │\200│\210│\220│\230│\240│\250│\260│\270│
│disp16(%bx,%di)│ │ 1 │\201│\211│\221│\231│\241│\251│\261│\271│
│disp16(%bp,%si)│ │ 2 │\202│\212│\222│\232│\242│\252│\262│\272│
│disp16(%bp,%di)│ │ 3 │\203│\213│\223│\233│\243│\253│\263│\273│
│disp16(%si) │ │ 4 │\204│\214│\224│\234│\244│\254│\264│\274│
│disp16(%di) │ │ 5 │\205│\215│\225│\235│\245│\255│\265│\275│
│disp16(%bp) │ │ 6 │\206│\216│\226│\236│\246│\256│\266│\276│
│disp16(%bx) │ │ 7 │\207│\217│\227│\237│\247│\257│\267│\277│
├───────────────┼───┼───┼────┼────┼────┼────┼────┼────┼────┼────┤
│%al/%ax/%st(0) │ 3 │ 0 │\300│\310│\320│\330│\340│\350│\360│\370│
│%cl/%cx/%st(1) │ │ 1 │\301│\311│\321│\331│\341│\351│\361│\371│
│%dl/%dx/%st(2) │ │ 2 │\302│\312│\322│\332│\342│\352│\362│\372│
│%bl/%bx/%st(3) │ │ 3 │\303│\313│\323│\333│\343│\353│\363│\373│
│%ah/%sp/%st(4) │ │ 4 │\304│\314│\324│\334│\344│\354│\364│\374│
│%ch/%bp/%st(5) │ │ 5 │\305│\315│\325│\335│\345│\355│\365│\375│
│%dh/%si/%st(6) │ │ 6 │\306│\316│\326│\336│\346│\356│\366│\376│
│%bh/%di/%st(7) │ │ 7 │\307│\317│\327│\337│\347│\357│\367│\377│
└───────────────┴───┴───┴────┴────┴────┴────┴────┴────┴────┴────┘
$: immediate
u8: unsigned 8-bit integer
i8: sign-extended 8-bit integer
Gb: modrm.reg selects byte register
Eb: modrm.rm selects byte register or memory
Gw: modrm.reg selects word register
Ew: modrm.rm selects word register or memory
etc.
\000 add Gb,Eb Add
\001 add Gw,Ew Add
\002 add Eb,Gb Add
\003 add Ew,Gw Add
\004 add $u8,%al Add
\005 add $i16,%ax Add
\006 push %es Push Word, Doubleword or Quadword Onto the Stack
\007 pop %es Pop a Value from the Stack
\010 or Gb,Eb Logical Inclusive OR
\011 or Gw,Ew Logical Inclusive OR
\012 or Eb,Gb Logical Inclusive OR
\013 or Ew,Gw Logical Inclusive OR
\014 or $u8,%al Logical Inclusive OR
\015 or $i16,%ax Logical Inclusive OR
\016 push %cs Push Word, Doubleword or Quadword Onto the Stack
\017 pop %cs Pop a Value from the Stack
\020 adc Gb,Eb Add with Carry
\021 adc Gw,Ew Add with Carry
\022 adc Eb,Gb Add with Carry
\023 adc Ew,Gw Add with Carry
\024 adc $u8,%al Add with Carry
\025 adc $i16,%ax Add with Carry
\026 push %ss Push Word, Doubleword or Quadword Onto the Stack
\027 pop %ss Pop a Value from the Stack
\030 sbb Gb,Eb Integer Subtraction with Borrow
\031 sbb Gw,Ew Integer Subtraction with Borrow
\032 sbb Eb,Gb Integer Subtraction with Borrow
\033 sbb Ew,Gw Integer Subtraction with Borrow
\034 sbb $u8,%al Integer Subtraction with Borrow
\035 sbb $i16,%ax Integer Subtraction with Borrow
\036 push %ds Push Word, Doubleword or Quadword Onto the Stack
\037 pop %ds Pop a Value from the Stack
\040 and Gb,Eb Logical AND
\041 and Gw,Ew Logical AND
\042 and Eb,Gb Logical AND
\043 and Ew,Gw Logical AND
\044 and $u8,%al Logical AND
\045 and $i16,%ax Logical AND
\046 es %es ES segment override prefix
\047 daa %al Decimal Adjust AL after Addition
\050 sub Gb,Eb Subtract
\051 sub Gw,Ew Subtract
\052 sub Eb,Gb Subtract
\053 sub Ew,Gw Subtract
\054 sub $u8,%al Subtract
\055 sub $i16,%ax Subtract
\056 cs %cs CS segment override prefix
\057 das %al Decimal Adjust AL after Subtraction
\060 xor Gb,Eb Logical Exclusive OR
\061 xor Gw,Ew Logical Exclusive OR
\062 xor Eb,Gb Logical Exclusive OR
\063 xor Ew,Gw Logical Exclusive OR
\064 xor $u8,%al Logical Exclusive OR
\065 xor $i16,%ax Logical Exclusive OR
\066 ss %ss SS segment override prefix
\067 aaa %ah,%al ASCII Adjust After Addition
\070 cmp Gb,Eb Compare Two Operands
\071 cmp Gw,Ew Compare Two Operands
\072 cmp Eb,Gb Compare Two Operands
\073 cmp Ew,Gw Compare Two Operands
\074 cmp $u8,%al Compare Two Operands
\075 cmp $i16,%ax Compare Two Operands
\076 ds %ds DS segment override prefix
\077 aas %ah,%al ASCII Adjust AL After Subtraction
\100 inc %ax Increment by 1
\101 inc %cx Increment by 1
\102 inc %dx Increment by 1
\103 inc %bx Increment by 1
\104 inc %sp Increment by 1
\105 inc %bp Increment by 1
\106 inc %si Increment by 1
\107 inc %di Increment by 1
\110 dec %ax Decrement by 1
\111 dec %cx Decrement by 1
\112 dec %dx Decrement by 1
\113 dec %bx Decrement by 1
\114 dec %sp Decrement by 1
\115 dec %bp Decrement by 1
\116 dec %si Decrement by 1
\117 dec %di Decrement by 1
\120 push %ax Push Word, Doubleword or Quadword Onto the Stack
\120 push %cx Push Word, Doubleword or Quadword Onto the Stack
\120 push %dx Push Word, Doubleword or Quadword Onto the Stack
\120 push %bx Push Word, Doubleword or Quadword Onto the Stack
\120 push %sp Push Word, Doubleword or Quadword Onto the Stack
\120 push %bp Push Word, Doubleword or Quadword Onto the Stack
\120 push %si Push Word, Doubleword or Quadword Onto the Stack
\120 push %di Push Word, Doubleword or Quadword Onto the Stack
\130 pop %ax Pop a Value from the Stack
\130 pop %cx Pop a Value from the Stack
\130 pop %dx Pop a Value from the Stack
\130 pop %bx Pop a Value from the Stack
\130 pop %sp Pop a Value from the Stack
\130 pop %bp Pop a Value from the Stack
\130 pop %si Pop a Value from the Stack
\130 pop %di Pop a Value from the Stack
\146 osz Operand-size override prefix
\147 asz Address-size override prefix
\150 push Ivs Push Word, Doubleword or Quadword Onto the Stack
\151 imul $i16,Ew,Gw Signed Multiply
\152 push $i8 Push Word, Doubleword or Quadword Onto the Stack
\153 imul $i8,Ew,Gw Signed Multiply
\154 insb %dx,Yb Input from Port to String
\155 insw %dx,Ywo Input from Port to String
\156 outsb Xb,%dx Output String to Port
\157 outsw Xwo,%dx Output String to Port
\160 jo Jbs Jump short if overflow (OF=1)
\161 jno Jbs Jump short if not overflow (OF=0)
\162 jb Jbs Jump short if below/not above or equal/carry (CF=1)
\163 jae Jbs Jump short if not below/above or equal/not carry (CF=0)
\164 je Jbs Jump short if zero/equal (ZF=1)
\165 jne Jbs Jump short if not zero/not equal (ZF=0)
\166 jbe Jbs Jump short if below or equal/not above (CF=1 OR ZF=1)
\167 ja Jbs Jump short if not below or equal/above (CF=0 AND ZF=0)
\170 js Jbs Jump short if sign (SF=1)
\171 jns Jbs Jump short if not sign (SF=0)
\172 jp Jbs Jump short if parity/parity even (PF=1)
\173 jnp Jbs Jump short if not parity/parity odd (PF=0)
\174 jl Jbs Jump short if less/not greater (SF!=OF)
\175 jge Jbs Jump short if not less/greater or equal (SF=OF)
\176 jle Jbs Jump short if less or equal/not greater ((ZF=1) OR (SF!=OF))
\177 jg Jbs Jump short if not less nor equal/greater ((ZF=0) AND (SF=OF))
\200 \.0. add $u8,Eb Add
\200 \.1. or $u8,Eb Logical Inclusive OR
\200 \.2. adc $u8,Eb Add with Carry
\200 \.3. sbb $u8,Eb Integer Subtraction with Borrow
\200 \.4. and $u8,Eb Logical AND
\200 \.5. sub $u8,Eb Subtract
\200 \.6. xor $u8,Eb Logical Exclusive OR
\200 \.7. cmp $u8,Eb Compare Two Operands
\201 \.0. add $i16,Ew Add
\201 \.1. or $i16,Ew Logical Inclusive OR
\201 \.2. adc $i16,Ew Add with Carry
\201 \.3. sbb $i16,Ew Integer Subtraction with Borrow
\201 \.4. and $i16,Ew Logical AND
\201 \.5. sub $i16,Ew Subtract
\201 \.6. xor $i16,Ew Logical Exclusive OR
\201 \.7. cmp $i16,Ew Compare Two Operands
\203 \.0. add $i8,Ew Add
\203 \.2. adc $i8,Ew Add with Carry
\203 \.3. sbb $i8,Ew Integer Subtraction with Borrow
\203 \.5. sub $i8,Ew Subtract
\203 \.7. cmp $i8,Ew Compare Two Operands
\204 test Gb,Eb Logical Compare
\205 test Gw,Ew Logical Compare
\206 xchg Eb,Gb Exchange Register/Memory with Register
\207 xchg Ew,Gw Exchange Register/Memory with Register
\210 mov Gb,Eb Move
\211 mov Gw,Ew Move
\212 mov Eb,Gb Move
\213 mov Ew,Gw Move
\214 mov Sw,Mw Move
\215 lea M,Gw Load Effective Address
\216 mov Ew,Sw Move
\217 \.0. pop Ev Pop a Value from the Stack
\220 xchg %ax,Zvqp Exchange Register/Memory with Register
\220 nop No Operation
\230 cbtw %al,%ax Convert Byte to Word
\231 cwtd %ax,%dx Convert Word to Doubleword
\232 lcall Ap Call Procedure
\233 fwait Check pending unmasked floating-point exceptions
\233 fwait Prefix |
\234 pushf Fwo Push FLAGS Register onto the Stack
\235 popf Fwo Pop Stack into FLAGS Register
\236 sahf %ah Store AH into Flags
\237 lahf %ah Load Status Flags into AH Register
\240 mov Ob,%al Move
\241 mov Ovqp,%ax Move
\242 mov %al,Ob Move
\243 mov %ax,Ovqp Move
\244 movsb Xb,Yb Move Data from String to String
\245 movsw Xwo,Ywo Move Data from String to String
\246 cmpsb Xb,Yb Compare String Operands
\247 cmpsw Xwo,Ywo Compare String Operands
\250 test $u8,%al Logical Compare
\251 test $i16,%ax Logical Compare
\252 stosb %al,Yb Store String
\253 stosw %ax,Ywo Store String
\254 lodsb Xb,%al Load String
\255 lodsw Xwo,%ax Load String
\256 scasb %al,Yb Scan String
\257 scasw %ax,Ywo Scan String
\260 mov $u8,Zb Move
\270 mov Ivqp,Zvqp Move
\300 \.0. rol $u8,Eb Rotate
\300 \.1. ror $u8,Eb Rotate
\300 \.2. rcl $u8,Eb Rotate
\300 \.3. rcr $u8,Eb Rotate
\300 \.4. shl $u8,Eb Shift
\300 \.5. shr $u8,Eb Shift
\300 \.7. sar $u8,Eb Shift
\301 \.0. rol $u8,Ew Rotate
\301 \.1. ror $u8,Ew Rotate
\301 \.2. rcl $u8,Ew Rotate
\301 \.3. rcr $u8,Ew Rotate
\301 \.4. shl $u8,Ew Shift
\301 \.5. shr $u8,Ew Shift
\301 \.7. sar $u8,Ew Shift
\302 retn Iw Return from procedure
\303 retn Return from procedure
\304 les Mp,Gv,%es Load Far Pointer
\305 lds Mp,Gv,%ds Load Far Pointer
\306 \.0. mov $u8,Eb Move
\307 \.0. mov $i16,Ew Move
\310 enter $u8,Iw,%bp Make Stack Frame for Procedure Parameters
\311 leave %bp High Level Procedure Exit
\312 retf Iw Return from procedure
\313 retf Return from procedure
\314 int3 Call to Interrupt Procedure
\315 int Fv,$u8 Call to Interrupt Procedure
\316 into Fv Call to Interrupt Procedure
\317 iret Fwo Interrupt Return
\317 iretd Fdo Interrupt Return
\320 \.0. rol $1,Eb Rotate
\320 \.1. ror $1,Eb Rotate
\320 \.2. rcl $1,Eb Rotate
\320 \.3. rcr $1,Eb Rotate
\320 \.4. shl $1,Eb Shift
\320 \.5. shr $1,Eb Shift
\320 \.7. sar $1,Eb Shift
\321 \.0. rol $1,Ew Rotate
\321 \.1. ror $1,Ew Rotate
\321 \.2. rcl $1,Ew Rotate
\321 \.3. rcr $1,Ew Rotate
\321 \.4. shl $1,Ew Shift
\321 \.5. shr $1,Ew Shift
\321 \.7. sar $1,Ew Shift
\322 \.0. rol %cl,Eb Rotate
\322 \.1. ror %cl,Eb Rotate
\322 \.2. rcl %cl,Eb Rotate
\322 \.3. rcr %cl,Eb Rotate
\322 \.4. shl %cl,Eb Shift
\322 \.5. shr %cl,Eb Shift
\322 \.7. sar %cl,Eb Shift
\323 \.0. rol %cl,Ew Rotate
\323 \.1. ror %cl,Ew Rotate
\323 \.2. rcl %cl,Ew Rotate
\323 \.3. rcr %cl,Ew Rotate
\323 \.4. shl %cl,Ew Shift
\323 \.5. shr %cl,Ew Shift
\323 \.7. sar %cl,Ew Shift
\324 aam %ah,%al ASCII Adjust AX After Multiply
\324 amx $u8,%ah,%al Adjust AX After Multiply
\325 aad %ah,%al ASCII Adjust AX Before Division
\325 adx $u8,%ah,%al Adjust AX Before Division
\326 salc %al Set AL If Carry
\327 xlat BBb,%al Table Look-up Translation
\330 \.0. fadd Msr,%st Add
\330 \.1. fmul Msr,%st Multiply
\330 \.2. fcom ESsr,%st Compare Real
\330 \.2. fcom %st(1),%st Compare Real
\330 \.3. fcomp ESsr,%st Compare Real and Pop
\330 \.3. fcomp %st(1),%st Compare Real and Pop
\330 \.4. fsub Msr,%st Subtract
\330 \.5. fsubr Msr,%st Reverse Subtract
\330 \.6. fdiv Msr,%st Divide
\330 \.7. fdivr Msr,%st Reverse Divide
\331 \.0. fld ESsr,%st Load Floating Point Value
\331 \.1. fxch EST,%st Exchange Register Contents
\331 \.1. fxch %st(1),%st Exchange Register Contents
\331 \.2. fst %st,Msr Store Floating Point Value
\331 \.2. fnop No Operation
\331 \.3. fstp %st,Msr Store Floating Point Value and Pop
\331 \.4. fldenv Me Load x87 FPU Environment
\331 \.4. fchs %st Change Sign
\331 \.4. fabs %st Absolute Value
\331 \.4. ftst %st Test
\331 \.4. fxam %st Examine
\331 \.5. fldcw Mw Load x87 FPU Control Word
\331 \.5. fld1 %st Load Constant +1.0
\331 \.5. fldl2t %st Load Constant log_210
\331 \.5. fldl2e %st Load Constant log_2e
\331 \.5. fldpi %st Load Constant π
\331 \.5. fldlg2 %st Load Constant log_102
\331 \.5. fldln2 %st Load Constant log_e2
\331 \.5. fldz %st Load Constant +0.0
\331 \.6. fnstenv Me Store x87 FPU Environment
\331 \.6. fstenv Me Store x87 FPU Environment
\331 \.6. f2xm1 %st Compute 2^x-1
\331 \.6. fyl2x %st,%st(1) Compute y × log_2x and Pop
\331 \.6. fptan %st Partial Tangent
\331 \.6. fpatan %st,%st(1) Partial Arctangent and Pop
\331 \.6. fxtract %st Extract Exponent and Significand
\331 \.6. fprem1 %st(1),%st IEEE Partial Remainder
\331 \.6. fdecstp Decrement Stack-Top Pointer
\331 \.6. fincstp Increment Stack-Top Pointer
\331 \.7. fnstcw Mw Store x87 FPU Control Word
\331 \.7. fstcw Mw Store x87 FPU Control Word
\331 \.7. fprem %st(1),%st Partial Remainder (for compatibility with i8087 and i287)
\331 \.7. fyl2xp1 %st,%st(1) Compute y × log_2(x+1) and Pop
\331 \.7. fsqrt %st Square Root
\331 \.7. fsincos %st Sine and Cosine
\331 \.7. frndint %st Round to Integer
\331 \.7. fscale %st(1),%st Scale
\331 \.7. fsin %st Sine
\331 \.7. fcos %st Cosine
\332 \.0. fiadd Mdi,%st Add
\332 \.0. fcmovb EST,%st FP Conditional Move - below (CF=1)
\332 \.1. fimul Mdi,%st Multiply
\332 \.1. fcmove EST,%st FP Conditional Move - equal (ZF=1)
\332 \.2. ficom Mdi,%st Compare Integer
\332 \.2. fcmovbe EST,%st FP Conditional Move - below or equal (CF=1 or ZF=1)
\332 \.3. ficomp Mdi,%st Compare Integer and Pop
\332 \.3. fcmovu EST,%st FP Conditional Move - unordered (PF=1)
\332 \.4. fisub Mdi,%st Subtract
\332 \.5. fisubr Mdi,%st Reverse Subtract
\332 \.6. fidiv Mdi,%st Divide
\332 \.7. fidivr Mdi,%st Reverse Divide
\333 \.0. fild Mdi,%st Load Integer
\333 \.0. fcmovnb EST,%st FP Conditional Move - not below (CF=0)
\333 \.1. fcmovne EST,%st FP Conditional Move - not equal (ZF=0)
\333 \.2. fist %st,Mdi Store Integer
\333 \.2. fcmovnbe EST,%st FP Conditional Move - below or equal (CF=0 and ZF=0)
\333 \.3. fistp %st,Mdi Store Integer and Pop
\333 \.3. fcmovnu EST,%st FP Conditional Move - not unordered (PF=0)
\333 \.4. fndisi nop Treated as Integer NOP
\333 \.4. fnclex Clear Exceptions
\333 \.4. fclex Clear Exceptions
\333 \.4. fninit Initialize Floating-Point Unit
\333 \.4. finit Initialize Floating-Point Unit
\333 \.4. fnsetpm Set Protected Mode
\333 \.4. fsetpm Set Protected Mode
\333 \.5. fld Mer,%st Load Floating Point Value
\333 \.5. fucomi EST,%st Unordered Compare Floating Point Values and Set EFLAGS
\333 \.6. fcomi EST,%st Compare Floating Point Values and Set EFLAGS
\333 \.7. fstp %st,Mer Store Floating Point Value and Pop
\334 \.0. fadd Mdr,%st Add
\334 \.0. fadd %st,EST Add
\334 \.1. fmul Mdr,%st Multiply
\334 \.1. fmul %st,EST Multiply
\334 \.2. fcom Mdr,%st Compare Real
\334 \.3. fcomp Mdr,%st Compare Real and Pop
\334 \.4. fsub Mdr,%st Subtract
\334 \.4. fsubr %st,EST Reverse Subtract
\334 \.5. fsubr Mdr,%st Reverse Subtract
\334 \.5. fsub %st,EST Subtract
\334 \.6. fdiv Mdr,%st Divide
\334 \.6. fdivr %st,EST Reverse Divide
\334 \.7. fdivr Mdr,%st Reverse Divide
\334 \.7. fdiv %st,EST Divide and Pop
\335 \.0. fld Mdr,%st Load Floating Point Value
\335 \.0. ffree EST Free Floating-Point Register
\335 \.2. fst %st,Mdr Store Floating Point Value
\335 \.2. fst EST,%st Store Floating Point Value
\335 \.3. fstp %st,Mdr Store Floating Point Value and Pop
\335 \.3. fstp EST,%st Store Floating Point Value and Pop
\335 \.4. frstor ST2,%st(1),%st Restore x87 FPU State
\335 \.6. fnsave %st(1),%st,Mst Store x87 FPU State
\335 \.6. fsave %st(1),%st,Mst Store x87 FPU State
\335 \.7. fnstsw Mw Store x87 FPU Status Word
\335 \.7. fstsw Mw Store x87 FPU Status Word
\336 \.0. fiadd Mwi,%st Add
\336 \.0. faddp %st,EST Add and Pop
\336 \.0. faddp %st,%st(1) Add and Pop
\336 \.1. fimul Mwi,%st Multiply
\336 \.1. fmulp %st,EST Multiply and Pop
\336 \.1. fmulp %st,%st(1) Multiply and Pop
\336 \.2. ficom Mwi,%st Compare Integer
\336 \.3. ficomp Mwi,%st Compare Integer and Pop
\336 \.3. fcompp %st(1),%st Compare Real and Pop Twice
\336 \.4. fisub Mwi,%st Subtract
\336 \.4. fsubrp %st,EST Reverse Subtract and Pop
\336 \.4. fsubrp %st,%st(1) Reverse Subtract and Pop
\336 \.5. fisubr Mwi,%st Reverse Subtract
\336 \.5. fsubp %st,EST Subtract and Pop
\336 \.5. fsubp %st,%st(1) Subtract and Pop
\336 \.6. fidiv Mwi,%st Divide
\336 \.6. fdivrp %st,EST Reverse Divide and Pop
\336 \.6. fdivrp %st,%st(1) Reverse Divide and Pop
\336 \.7. fidivr Mwi,%st Reverse Divide
\336 \.7. fdivp %st,EST Divide and Pop
\336 \.7. fdivp %st,%st(1) Divide and Pop
\337 \.0. fild Mwi,%st Load Integer
\337 \.0. ffreep EST Free Floating-Point Register and Pop
\337 \.2. fist %st,Mwi Store Integer
\337 \.3. fistp %st,Mwi Store Integer and Pop
\337 \.4. fbld Mbcd,%st Load Binary Coded Decimal
\337 \.4. fnstsw %ax Store x87 FPU Status Word
\337 \.4. fstsw %ax Store x87 FPU Status Word
\337 \.5. fild Mqi,%st Load Integer
\337 \.5. fucomip EST,%st Unordered Compare Floating Point Values and Set EFLAGS and Pop
\337 \.6. fbstp %st,Mbcd Store BCD Integer and Pop
\337 \.6. fcomip EST,%st Compare Floating Point Values and Set EFLAGS and Pop
\337 \.7. fistp %st,Mqi Store Integer and Pop
\340 loopnz Jbs,%cx Decrement count; Jump short if count!=0 and ZF=0
\341 loope Jbs,%cx Decrement count; Jump short if count!=0 and ZF=1
\342 loop Jbs,%cx Decrement count; Jump short if count!=0
\343 jcxz %cx,Jbs Jump short if eCX register is 0
\344 inb $u8,%al Input from Port
\345 inw $u8,%ax Input from Port
\346 outb %al,$u8 Output to Port
\347 outw %ax,$u8 Output to Port
\350 call Jvds Call Procedure
\351 jmp Jvds Jump
\352 ljmp Ap Jump
\353 jmp Jbs Jump
\354 inb %dx,%al Input from Port
\355 inw %dx,%ax Input from Port
\356 outb %al,%dx Output to Port
\357 outw %ax,%dx Output to Port
\360 lock Assert LOCK# Signal Prefix
\362 repnz %cx Repeat String Operation Prefix
\363 rep %cx Repeat String Operation Prefix
\364 hlt Halt
\365 cmc Complement Carry Flag
\366 \.0. test $u8,Eb Logical Compare
\366 \.2. not Eb One's Complement Negation
\366 \.3. neg Eb Two's Complement Negation
\366 \.4. mul Eb,%al,%ax Unsigned Multiply
\366 \.5. imul Eb,%al,%ax Signed Multiply
\366 \.6. div %ax,%ah,%al Unsigned Divide
\366 \.7. idiv %ax,%ah,%al Signed Divide
\367 \.0. test $i16,Ew Logical Compare
\367 \.2. not Ew One's Complement Negation
\367 \.3. neg Ew Two's Complement Negation
\367 \.4. mul Ew,%ax,%dx Unsigned Multiply
\367 \.5. imul Ew,%ax,%dx Signed Multiply
\367 \.6. div Ew,%ax,%dx Unsigned Divide
\367 \.7. idiv Ew,%ax,%dx Signed Divide
\370 clc Clear Carry Flag
\371 stc Set Carry Flag
\372 cli Clear Interrupt Flag
\373 sti Set Interrupt Flag
\374 cld Clear Direction Flag
\375 std Set Direction Flag
\376 \.0. inc Eb Increment by 1
\376 \.1. dec Eb Decrement by 1
\377 \.0. inc Ew Increment by 1
\377 \.1. dec Ew Decrement by 1
\377 \.2. call Ev Call Procedure
\377 \.3. lcall Mptp Call Procedure
\377 \.4. jmp Ev Jump
\377 \.5. ljmp Mptp Jump
\377 \.6. push Ev Push Word, Doubleword or Quadword Onto the Stack