i386 instructions
Instruction reference: i386 · x64 · ARM32 (Thumb-2) · ARM64 (AArch64)
All 614 instructions in 1,184 forms that Asmonite assembles for .arch i386 and Dismonite decodes: name, operands, the encoding in bytes and a short description. The search box finds an instruction, a byte sequence (0F B6) or a word of the description. The AVX instructions (VEX, EVEX) are not included: Asmonite and Dismonite do not know them yet.
How to read the table
The operands are in the order of the source text: the destination first, then the source (Intel notation). r8 to r64 is a register of that width, m a memory address, r/m32 a register or 32 bits of memory, imm8 a number in the instruction, rel8 and rel32 a jump distance, xmm and mm vector registers.
Under the description is the operation in pseudo code: dst is the first operand (the destination), src the second (the source), [x] the memory at address x; sext and zext extend with sign and with zeros, >>s shifts with sign, hi:lo is a register pair. Below are the flags the instruction changes and those that are undefined afterwards.
The encoding is the bytes of the instruction, coloured by their role:
| 66 F3 F2 | prefix: chooses the 16-bit form (66) or, with SSE, the kind of instruction (66 = doubles, F3 = one single, F2 = one double) |
| 0F 38 3A | opcode escape (two- and three-byte tables) |
| 8B B8+rd | the opcode; +rb, +rw, +rd, +rq: the number of the register goes into the low three bits of the opcode |
| /r /0…/7 | a ModRM byte follows (with register, memory and address parts). /r: the reg field is a register; /0 to /7: the reg field is part of the opcode |
| ib iw id iq cb cd | then: a number of 1, 2, 4 or 8 bytes (i…) or a jump distance (c…); moffs is an absolute address |
The table is for 32-bit mode (Windows and Linux, 32 bit); the 64-bit instructions are on the page x64 instructions. It is derived from the decoder of Dismonite and made again when the decoder changes; the descriptions are short, longer explanations are in the help (F1) of Asmonite and Dismonite.
| Instruction | Operands | Encoding | Description |
|---|---|---|---|
| aaa | 37 | ASCII adjust after an addition (BCD)if (al & 15) > 9 or AF = 1 then { al = al + 6; ah = ah + 1; AF = CF = 1 } else { AF = CF = 0 }; al = al & 15Flags: AF CF · undefined: OF SF ZF PFArithmetic | |
| aad | imm8 | D5 ib | ASCII adjust before a division (BCD)al = ah * imm8 + al; ah = 0 (imm8 is 10 for BCD)Flags: SF ZF PF · undefined: OF AF CFArithmetic |
| aam | imm8 | D4 ib | ASCII adjust after a multiplication (BCD)ah = al / imm8; al = al % imm8 (imm8 is 10 for BCD)Flags: SF ZF PF · undefined: OF AF CFArithmetic |
| aas | 3F | ASCII adjust after a subtraction (BCD)if (al & 15) > 9 or AF = 1 then { al = al - 6; ah = ah - 1; AF = CF = 1 } else { AF = CF = 0 }; al = al & 15Flags: AF CF · undefined: OF SF ZF PFArithmetic | |
| adc | r/m8, r8 | 10 /r | Addition with carry (CF)dst = dst + src + CFFlags: OF SF ZF AF CF PFArithmetic |
| r/m32, r32 | 11 /r | ||
| r/m16, r16 | 66 11 /r | ||
| r8, r/m8 | 12 /r | ||
| r32, r/m32 | 13 /r | ||
| r16, r/m16 | 66 13 /r | ||
| al, imm8 | 14 ib | ||
| eax, imm32 | 15 id | ||
| ax, imm16 | 66 15 iw | ||
| r/m8, imm8 | 80 /2 ib | ||
| r/m32, imm32 | 81 /2 id | ||
| r/m16, imm16 | 66 81 /2 iw | ||
| r/m8, imm8 | 82 /2 ib | ||
| r/m32, imm8 | 83 /2 ib | ||
| r/m16, imm8 | 66 83 /2 ib | ||
| adcx | r32, r/m32 | 66 0F 38 F6 /r | Addition with carry, changes only CFdst = dst + src + CFFlags: CFArithmetic |
| add | r/m8, r8 | 00 /r | Addition of the source to the destinationdst = dst + srcFlags: OF SF ZF AF CF PFArithmetic |
| r/m32, r32 | 01 /r | ||
| r/m16, r16 | 66 01 /r | ||
| r8, r/m8 | 02 /r | ||
| r32, r/m32 | 03 /r | ||
| r16, r/m16 | 66 03 /r | ||
| al, imm8 | 04 ib | ||
| eax, imm32 | 05 id | ||
| ax, imm16 | 66 05 iw | ||
| r/m8, imm8 | 80 /0 ib | ||
| r/m32, imm32 | 81 /0 id | ||
| r/m16, imm16 | 66 81 /0 iw | ||
| r/m8, imm8 | 82 /0 ib | ||
| r/m32, imm8 | 83 /0 ib | ||
| r/m16, imm8 | 66 83 /0 ib | ||
| addpd | xmm, xmm/m128 | 66 0F 58 /r | Addition of 2 doublesfor every element: dst[i] = dst[i] + src[i] (double)SSE floating point |
| addps | xmm, xmm/m128 | 0F 58 /r | Addition of 4 singlesfor every element: dst[i] = dst[i] + src[i] (single)SSE floating point |
| addsd | xmm, xmm/m64 | F2 0F 58 /r | Addition of one doubledst[0] = dst[0] + src[0] (double); the other elements staySSE floating point |
| addss | xmm, xmm/m32 | F3 0F 58 /r | Addition of one singledst[0] = dst[0] + src[0] (single); the other elements staySSE floating point |
| addsubpd | xmm, xmm/m128 | 66 0F D0 /r | Alternating subtraction and addition (doubles)even elements: dst[i] = dst[i] - src[i]; odd elements: dst[i] = dst[i] + src[i]SSE floating point |
| addsubps | xmm, xmm/m128 | F2 0F D0 /r | Alternating subtraction and addition (singles)even elements: dst[i] = dst[i] - src[i]; odd elements: dst[i] = dst[i] + src[i]SSE floating point |
| adox | r32, r/m32 | F3 0F 38 F6 /r | Addition with the overflow flag, changes only OFdst = dst + src + OFFlags: OFArithmetic |
| aesdec | xmm, xmm/m128 | 66 0F 38 DE /r | One AES decryption rounddst = inverse AES round of dst with the round key srcCryptography |
| aesdeclast | xmm, xmm/m128 | 66 0F 38 DF /r | The last AES decryption rounddst = last inverse AES round of dst with the round key srcCryptography |
| aesenc | xmm, xmm/m128 | 66 0F 38 DC /r | One AES encryption rounddst = AES round of dst with the round key srcCryptography |
| aesenclast | xmm, xmm/m128 | 66 0F 38 DD /r | The last AES encryption rounddst = last AES round of dst with the round key srcCryptography |
| aesimc | xmm, xmm/m128 | 66 0F 38 DB /r | Conversion of an AES round key for decryptiondst = InvMixColumns(src)Cryptography |
| aeskeygenassist | xmm, xmm/m128, imm8 | 66 0F 3A DF /r ib | Helper for AES key generationdst = helper values for the AES key schedule from src (round constant imm8)Cryptography |
| and | r/m8, r8 | 20 /r | Bitwise ANDdst = dst & src; CF = OF = 0Flags: OF SF ZF CF PF · undefined: AFLogic and bits |
| r/m32, r32 | 21 /r | ||
| r/m16, r16 | 66 21 /r | ||
| r8, r/m8 | 22 /r | ||
| r32, r/m32 | 23 /r | ||
| r16, r/m16 | 66 23 /r | ||
| al, imm8 | 24 ib | ||
| eax, imm32 | 25 id | ||
| ax, imm16 | 66 25 iw | ||
| r/m8, imm8 | 80 /4 ib | ||
| r/m32, imm32 | 81 /4 id | ||
| r/m16, imm16 | 66 81 /4 iw | ||
| r/m8, imm8 | 82 /4 ib | ||
| r/m32, imm8 | 83 /4 ib | ||
| r/m16, imm8 | 66 83 /4 ib | ||
| andnpd | xmm, xmm/m128 | 66 0F 55 /r | Bitwise: NOT destination AND sourcedst = ~dst & srcSSE floating point |
| andnps | xmm, xmm/m128 | 0F 55 /r | Bitwise: NOT destination AND sourcedst = ~dst & srcSSE floating point |
| andpd | xmm, xmm/m128 | 66 0F 54 /r | Bitwise ANDdst = dst & srcSSE floating point |
| andps | xmm, xmm/m128 | 0F 54 /r | Bitwise ANDdst = dst & srcSSE floating point |
| arpl | r/m16, r16 | 63 /r | Adjustment of the requested privilege level (RPL) of a segment selectorif dst.RPL < src.RPL then { dst.RPL = src.RPL; ZF = 1 } else ZF = 0Flags: ZFSystem and privileged |
| blendpd | xmm, xmm/m128, imm8 | 66 0F 3A 0D /r ib | Selection of doubles from two registers by a maskfor every element: dst[i] = bit i of imm8 ? src[i] : dst[i]SSE floating point |
| blendps | xmm, xmm/m128, imm8 | 66 0F 3A 0C /r ib | Selection of singles from two registers by a maskfor every element: dst[i] = bit i of imm8 ? src[i] : dst[i]SSE floating point |
| blendvpd | xmm, xmm/m128, xmm0 | 66 0F 38 15 /r | Selection of doubles by the sign bits of xmm0for every element: dst[i] = (sign bit of xmm0[i]) ? src[i] : dst[i]SSE floating point |
| blendvps | xmm, xmm/m128, xmm0 | 66 0F 38 14 /r | Selection of singles by the sign bits of xmm0for every element: dst[i] = (sign bit of xmm0[i]) ? src[i] : dst[i]SSE floating point |
| bound | r32, m | 62 /r | Check of an array index against bounds in memoryraise #BR if index dst < [m] or dst > [m + size]System and privileged |
| r16, m | 66 62 /r | ||
| bsf | r32, r/m32 | 0F BC /r | Search for the lowest set bitdst = index of the lowest 1 bit of src; ZF = (src = 0), dst undefined thenFlags: ZFLogic and bits |
| r16, r/m16 | 66 0F BC /r | ||
| bsr | r32, r/m32 | 0F BD /r | Search for the highest set bitdst = index of the highest 1 bit of src; ZF = (src = 0), dst undefined thenFlags: ZFLogic and bits |
| r16, r/m16 | 66 0F BD /r | ||
| bswap | r32 | 0F C8+rd | Reversal of the byte order (little/big endian)dst = reverse_bytes(dst)Data transfer |
| bt | r/m32, r32 | 0F A3 /r | Copy of one bit to CFCF = bit src of dstFlags: CFLogic and bits |
| r/m16, r16 | 66 0F A3 /r | ||
| r/m32, imm8 | 0F BA /4 ib | ||
| r/m16, imm8 | 66 0F BA /4 ib | ||
| btc | r/m32, imm8 | 0F BA /7 ib | Copy of one bit to CF and inversion of the bitCF = bit src of dst; bit src of dst = not bitFlags: CFLogic and bits |
| r/m16, imm8 | 66 0F BA /7 ib | ||
| r/m32, r32 | 0F BB /r | ||
| r/m16, r16 | 66 0F BB /r | ||
| btr | r/m32, r32 | 0F B3 /r | Copy of one bit to CF and clearing of the bitCF = bit src of dst; bit src of dst = 0Flags: CFLogic and bits |
| r/m16, r16 | 66 0F B3 /r | ||
| r/m32, imm8 | 0F BA /6 ib | ||
| r/m16, imm8 | 66 0F BA /6 ib | ||
| bts | r/m32, r32 | 0F AB /r | Copy of one bit to CF and setting of the bitCF = bit src of dst; bit src of dst = 1Flags: CFLogic and bits |
| r/m16, r16 | 66 0F AB /r | ||
| r/m32, imm8 | 0F BA /5 ib | ||
| r/m16, imm8 | 66 0F BA /5 ib | ||
| call | rel32 | E8 cd | Call of a function (the return address is pushed)push(eip of the next instruction); eip = targetJumps, calls and interrupts |
| rel16 | 66 E8 cw | ||
| r/m32 | FF /2 | ||
| m | FF /3 | ||
| r/m16 | 66 FF /2 | ||
| cbw | 66 98 | Sign extension of al into axax = sext(al)Data transfer | |
| cdq | 99 | Sign extension of eax into edx:eaxedx:eax = sext(eax)Data transfer | |
| clac | 0F 01 CA | Clearing of the AC flag (access protection)EFLAGS.AC = 0Flags: ACFlags | |
| clc | F8 | Clearing of the carry flagCF = 0Flags: CFFlags | |
| cld | FC | Clearing of the direction flag (string instructions count up)DF = 0Flags: DFFlags | |
| clflush | m | 0F AE /7 | Flush of a cache linewrite back and remove the cache line of [m] from all cachesSystem and privileged |
| clflushopt | m | 66 0F AE /7 | Flush of a cache line (faster, loosely ordered)write back and remove the cache line of [m] from all cachesSystem and privileged |
| cli | FA | Disabling of interrupts (IF=0)IF = 0Flags: IFFlags | |
| clts | 0F 06 | Clearing of the task-switched flag in cr0CR0.TS = 0 (privileged)System and privileged | |
| clwb | m | 66 0F AE /6 | Write-back of a cache line without flushing itwrite back the cache line of [m], it may stay in the cacheSystem and privileged |
| cmc | F5 | Inversion of the carry flagCF = not CFFlags: CFFlags | |
| cmova | r32, r/m32 | 0F 47 /r | Copy only if unsigned above (CF=0 and ZF=0)if CF = 0 and ZF = 0 then dst = srcData transfer |
| r16, r/m16 | 66 0F 47 /r | ||
| cmovbe | r32, r/m32 | 0F 46 /r | Copy only if unsigned below or equal (CF=1 or ZF=1)if CF = 1 or ZF = 1 then dst = srcData transfer |
| r16, r/m16 | 66 0F 46 /r | ||
| cmovc | r32, r/m32 | 0F 42 /r | Copy only if carry, unsigned below (CF=1)if CF = 1 then dst = srcData transfer |
| r16, r/m16 | 66 0F 42 /r | ||
| cmovg | r32, r/m32 | 0F 4F /r | Copy only if signed greater (ZF=0 and SF=OF)if ZF = 0 and SF = OF then dst = srcData transfer |
| r16, r/m16 | 66 0F 4F /r | ||
| cmovge | r32, r/m32 | 0F 4D /r | Copy only if signed greater or equal (SF=OF)if SF = OF then dst = srcData transfer |
| r16, r/m16 | 66 0F 4D /r | ||
| cmovl | r32, r/m32 | 0F 4C /r | Copy only if signed less (SF≠OF)if SF != OF then dst = srcData transfer |
| r16, r/m16 | 66 0F 4C /r | ||
| cmovle | r32, r/m32 | 0F 4E /r | Copy only if signed less or equal (ZF=1 or SF≠OF)if ZF = 1 or SF != OF then dst = srcData transfer |
| r16, r/m16 | 66 0F 4E /r | ||
| cmovnc | r32, r/m32 | 0F 43 /r | Copy only if no carry, unsigned above or equal (CF=0)if CF = 0 then dst = srcData transfer |
| r16, r/m16 | 66 0F 43 /r | ||
| cmovno | r32, r/m32 | 0F 41 /r | Copy only if no overflow (OF=0)if OF = 0 then dst = srcData transfer |
| r16, r/m16 | 66 0F 41 /r | ||
| cmovnp | r32, r/m32 | 0F 4B /r | Copy only if parity odd (PF=0)if PF = 0 then dst = srcData transfer |
| r16, r/m16 | 66 0F 4B /r | ||
| cmovns | r32, r/m32 | 0F 49 /r | Copy only if not negative (SF=0)if SF = 0 then dst = srcData transfer |
| r16, r/m16 | 66 0F 49 /r | ||
| cmovnz | r32, r/m32 | 0F 45 /r | Copy only if not equal, result not zero (ZF=0)if ZF = 0 then dst = srcData transfer |
| r16, r/m16 | 66 0F 45 /r | ||
| cmovo | r32, r/m32 | 0F 40 /r | Copy only if overflow (OF=1)if OF = 1 then dst = srcData transfer |
| r16, r/m16 | 66 0F 40 /r | ||
| cmovp | r32, r/m32 | 0F 4A /r | Copy only if parity even (PF=1)if PF = 1 then dst = srcData transfer |
| r16, r/m16 | 66 0F 4A /r | ||
| cmovs | r32, r/m32 | 0F 48 /r | Copy only if negative (SF=1)if SF = 1 then dst = srcData transfer |
| r16, r/m16 | 66 0F 48 /r | ||
| cmovz | r32, r/m32 | 0F 44 /r | Copy only if equal, result zero (ZF=1)if ZF = 1 then dst = srcData transfer |
| r16, r/m16 | 66 0F 44 /r | ||
| cmp | r/m8, r8 | 38 /r | Comparison (destination minus source), only the flags changeflags = dst - src (the result is thrown away)Flags: OF SF ZF AF CF PFCompare and exchange |
| r/m32, r32 | 39 /r | ||
| r/m16, r16 | 66 39 /r | ||
| r8, r/m8 | 3A /r | ||
| r32, r/m32 | 3B /r | ||
| r16, r/m16 | 66 3B /r | ||
| al, imm8 | 3C ib | ||
| eax, imm32 | 3D id | ||
| ax, imm16 | 66 3D iw | ||
| r/m8, imm8 | 80 /7 ib | ||
| r/m32, imm32 | 81 /7 id | ||
| r/m16, imm16 | 66 81 /7 iw | ||
| r/m8, imm8 | 82 /7 ib | ||
| r/m32, imm8 | 83 /7 ib | ||
| r/m16, imm8 | 66 83 /7 ib | ||
| cmpeqpd | xmm, xmm/m128 | 66 0F C2 /r 00 | Comparison of 2 doubles for equal, the result is a maskfor every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0SSE floating point |
| cmpeqps | xmm, xmm/m128 | 0F C2 /r 00 | Comparison of 4 singles for equal, the result is a maskfor every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0SSE floating point |
| cmpeqsd | xmm, xmm/m64 | F2 0F C2 /r 00 | Comparison of one double for equal, the result is a maskfor every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0SSE floating point |
| cmpeqss | xmm, xmm/m32 | F3 0F C2 /r 00 | Comparison of one single for equal, the result is a maskfor every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0SSE floating point |
| cmplepd | xmm, xmm/m128 | 66 0F C2 /r 02 | Comparison of 2 doubles for less or equal, the result is a maskfor every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0SSE floating point |
| cmpleps | xmm, xmm/m128 | 0F C2 /r 02 | Comparison of 4 singles for less or equal, the result is a maskfor every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0SSE floating point |
| cmplesd | xmm, xmm/m64 | F2 0F C2 /r 02 | Comparison of one double for less or equal, the result is a maskfor every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0SSE floating point |
| cmpless | xmm, xmm/m32 | F3 0F C2 /r 02 | Comparison of one single for less or equal, the result is a maskfor every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0SSE floating point |
| cmpltpd | xmm, xmm/m128 | 66 0F C2 /r 01 | Comparison of 2 doubles for less, the result is a maskfor every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0SSE floating point |
| cmpltps | xmm, xmm/m128 | 0F C2 /r 01 | Comparison of 4 singles for less, the result is a maskfor every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0SSE floating point |
| cmpltsd | xmm, xmm/m64 | F2 0F C2 /r 01 | Comparison of one double for less, the result is a maskfor every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0SSE floating point |
| cmpltss | xmm, xmm/m32 | F3 0F C2 /r 01 | Comparison of one single for less, the result is a maskfor every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0SSE floating point |
| cmpneqpd | xmm, xmm/m128 | 66 0F C2 /r 04 | Comparison of 2 doubles for not equal, the result is a maskfor every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0SSE floating point |
| cmpneqps | xmm, xmm/m128 | 0F C2 /r 04 | Comparison of 4 singles for not equal, the result is a maskfor every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0SSE floating point |
| cmpneqsd | xmm, xmm/m64 | F2 0F C2 /r 04 | Comparison of one double for not equal, the result is a maskfor every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0SSE floating point |
| cmpneqss | xmm, xmm/m32 | F3 0F C2 /r 04 | Comparison of one single for not equal, the result is a maskfor every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0SSE floating point |
| cmpnlepd | xmm, xmm/m128 | 66 0F C2 /r 06 | Comparison of 2 doubles for not less or equal, the result is a maskfor every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0SSE floating point |
| cmpnleps | xmm, xmm/m128 | 0F C2 /r 06 | Comparison of 4 singles for not less or equal, the result is a maskfor every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0SSE floating point |
| cmpnlesd | xmm, xmm/m64 | F2 0F C2 /r 06 | Comparison of one double for not less or equal, the result is a maskfor every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0SSE floating point |
| cmpnless | xmm, xmm/m32 | F3 0F C2 /r 06 | Comparison of one single for not less or equal, the result is a maskfor every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0SSE floating point |
| cmpnltpd | xmm, xmm/m128 | 66 0F C2 /r 05 | Comparison of 2 doubles for not less, the result is a maskfor every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0SSE floating point |
| cmpnltps | xmm, xmm/m128 | 0F C2 /r 05 | Comparison of 4 singles for not less, the result is a maskfor every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0SSE floating point |
| cmpnltsd | xmm, xmm/m64 | F2 0F C2 /r 05 | Comparison of one double for not less, the result is a maskfor every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0SSE floating point |
| cmpnltss | xmm, xmm/m32 | F3 0F C2 /r 05 | Comparison of one single for not less, the result is a maskfor every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0SSE floating point |
| cmpordpd | xmm, xmm/m128 | 66 0F C2 /r 07 | Comparison of 2 doubles for ordered (no NaN), the result is a maskfor every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0SSE floating point |
| cmpordps | xmm, xmm/m128 | 0F C2 /r 07 | Comparison of 4 singles for ordered (no NaN), the result is a maskfor every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0SSE floating point |
| cmpordsd | xmm, xmm/m64 | F2 0F C2 /r 07 | Comparison of one double for ordered (no NaN), the result is a maskfor every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0SSE floating point |
| cmpordss | xmm, xmm/m32 | F3 0F C2 /r 07 | Comparison of one single for ordered (no NaN), the result is a maskfor every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0SSE floating point |
| cmppd | xmm, xmm/m128, imm8 | 66 0F C2 /r ib | Comparison of 2 doubles with a condition, the result is a maskfor every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8SSE floating point |
| cmpps | xmm, xmm/m128, imm8 | 0F C2 /r ib | Comparison of 4 singles with a condition, the result is a maskfor every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8SSE floating point |
| cmpsb | A6 | Comparison of [esi] with [edi], esi and edi advanceflags = [esi] - [edi]; esi, edi = +/- size; with repe / repne: repeat while equal / not equal, at most ecx timesFlags: OF SF ZF AF CF PFStrings | |
| cmpsd | A7 | Comparison of one double (xmm) with a condition; without operands: string comparefor every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8SSE floating point | |
| xmm, xmm/m64, imm8 | F2 0F C2 /r ib | ||
| cmpss | xmm, xmm/m32, imm8 | F3 0F C2 /r ib | Comparison of one single with a condition, the result is a maskfor every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8SSE floating point |
| cmpsw | 66 A7 | Comparison of [esi] with [edi], esi and edi advanceflags = [esi] - [edi]; esi, edi = +/- size; with repe / repne: repeat while equal / not equal, at most ecx timesFlags: OF SF ZF AF CF PFStrings | |
| cmpunordpd | xmm, xmm/m128 | 66 0F C2 /r 03 | Comparison of 2 doubles for unordered (NaN), the result is a maskfor every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0SSE floating point |
| cmpunordps | xmm, xmm/m128 | 0F C2 /r 03 | Comparison of 4 singles for unordered (NaN), the result is a maskfor every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0SSE floating point |
| cmpunordsd | xmm, xmm/m64 | F2 0F C2 /r 03 | Comparison of one double for unordered (NaN), the result is a maskfor every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0SSE floating point |
| cmpunordss | xmm, xmm/m32 | F3 0F C2 /r 03 | Comparison of one single for unordered (NaN), the result is a maskfor every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0SSE floating point |
| cmpxchg | r/m8, r8 | 0F B0 /r | Compare and exchange if equal (atomic with lock)if eax == dst then { ZF = 1; dst = src } else { ZF = 0; eax = dst }Flags: OF SF ZF AF CF PFCompare and exchange |
| r/m32, r32 | 0F B1 /r | ||
| r/m16, r16 | 66 0F B1 /r | ||
| cmpxchg8b | m | 0F C7 /1 | Compare and exchange of 8 bytes (edx:eax, ecx:ebx)if edx:eax == [m] then { ZF = 1; [m] = ecx:ebx } else { ZF = 0; edx:eax = [m] }Flags: ZFCompare and exchange |
| comisd | xmm, xmm/m64 | 66 0F 2F /r | Comparison of two doubles, sets ZF, PF, CFZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0Flags: OF SF ZF AF CF PFSSE floating point |
| comiss | xmm, xmm/m32 | 0F 2F /r | Comparison of two singles, sets ZF, PF, CFZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0Flags: OF SF ZF AF CF PFSSE floating point |
| cpuid | 0F A2 | Information about the processoreax, ebx, ecx, edx = information about the processor for the function in eax (and ecx)System and privileged | |
| crc32 | r32, r/m8 | F2 0F 38 F0 /r | Calculation of a CRC-32C checksum (Castagnoli)dst = crc32c(dst, src)Arithmetic |
| r32, r/m32 | F2 0F 38 F1 /r | ||
| cvtdq2pd | xmm, xmm/m64 | F3 0F E6 /r | Conversion of 2 integers (32 bit) to doublesfor every element: dst[i] = convert(src[i]) from int32 to doubleConversions |
| cvtdq2ps | xmm, xmm/m128 | 0F 5B /r | Conversion of 4 integers (32 bit) to singlesfor every element: dst[i] = convert(src[i]) from int32 to singleConversions |
| cvtpd2dq | xmm, xmm/m128 | F2 0F E6 /r | Conversion of 2 doubles to integers (rounded)for every element: dst[i] = convert(src[i]) from double to int32Conversions |
| cvtpd2pi | mm, xmm/m64 | 66 0F 2D /r | Conversion of 2 doubles to integers (mm, rounded)for every element: dst[i] = convert(src[i]) from double to int32Conversions |
| cvtpd2ps | xmm, xmm/m128 | 66 0F 5A /r | Conversion of 2 doubles to singlesfor every element: dst[i] = convert(src[i]) from double to singleConversions |
| cvtpi2pd | xmm, mm/m64 | 66 0F 2A /r | Conversion of 2 integers (mm) to doublesfor every element: dst[i] = convert(src[i]) from int32 to doubleConversions |
| cvtpi2ps | xmm, mm/m64 | 0F 2A /r | Conversion of 2 integers (mm) to singlesfor every element: dst[i] = convert(src[i]) from int32 to singleConversions |
| cvtps2dq | xmm, xmm/m128 | 66 0F 5B /r | Conversion of 4 singles to integers (rounded)for every element: dst[i] = convert(src[i]) from single to int32Conversions |
| cvtps2pd | xmm, xmm/m64 | 0F 5A /r | Conversion of 2 singles to doublesfor every element: dst[i] = convert(src[i]) from single to doubleConversions |
| cvtps2pi | mm, xmm/m64 | 0F 2D /r | Conversion of 2 singles to integers (mm, rounded)for every element: dst[i] = convert(src[i]) from single to int32Conversions |
| cvtsd2si | r32, xmm/m128 | F2 0F 2D /r | Conversion of a double to an integer (rounded)for every element: dst[i] = convert(src[i]) from double to integerConversions |
| cvtsd2ss | xmm, xmm/m128 | F2 0F 5A /r | Conversion of a double to a singlefor every element: dst[i] = convert(src[i]) from double to singleConversions |
| cvtsi2sd | xmm, r/m32 | F2 0F 2A /r | Conversion of an integer to a doublefor every element: dst[i] = convert(src[i]) from integer to doubleConversions |
| cvtsi2ss | xmm, r/m32 | F3 0F 2A /r | Conversion of an integer to a singlefor every element: dst[i] = convert(src[i]) from integer to singleConversions |
| cvtss2sd | xmm, xmm/m32 | F3 0F 5A /r | Conversion of a single to a doublefor every element: dst[i] = convert(src[i]) from single to doubleConversions |
| cvtss2si | r32, xmm/m32 | F3 0F 2D /r | Conversion of a single to an integer (rounded)for every element: dst[i] = convert(src[i]) from single to integerConversions |
| cvttpd2dq | xmm, xmm/m128 | 66 0F E6 /r | Conversion of 2 doubles to integers (truncated)for every element: dst[i] = truncate(src[i]) from double to int32Conversions |
| cvttpd2pi | mm, xmm/m64 | 66 0F 2C /r | Conversion of 2 doubles to integers (mm, truncated)for every element: dst[i] = truncate(src[i]) from double to int32Conversions |
| cvttps2dq | xmm, xmm/m128 | F3 0F 5B /r | Conversion of 4 singles to integers (truncated)for every element: dst[i] = truncate(src[i]) from single to int32Conversions |
| cvttps2pi | mm, xmm/m64 | 0F 2C /r | Conversion of 2 singles to integers (mm, truncated)for every element: dst[i] = truncate(src[i]) from single to int32Conversions |
| cvttsd2si | r32, xmm/m128 | F2 0F 2C /r | Conversion of a double to an integer (truncated)for every element: dst[i] = truncate(src[i]) from double to integerConversions |
| cvttss2si | r32, xmm/m32 | F3 0F 2C /r | Conversion of a single to an integer (truncated)for every element: dst[i] = truncate(src[i]) from single to integerConversions |
| cwd | 66 99 | Sign extension of ax into dx:axdx:ax = sext(ax)Data transfer | |
| cwde | 98 | Sign extension of ax into eaxeax = sext(ax)Data transfer | |
| daa | 27 | Decimal adjust after an addition (packed BCD)if (al & 15) > 9 or AF = 1 then al = al + 6; if al > 99h or CF = 1 then al = al + 60hFlags: SF ZF AF CF PF · undefined: OFArithmetic | |
| das | 2F | Decimal adjust after a subtraction (packed BCD)if (al & 15) > 9 or AF = 1 then al = al - 6; if al > 99h or CF = 1 then al = al - 60hFlags: SF ZF AF CF PF · undefined: OFArithmetic | |
| dec | r/m8 | FE /1 | Decrement by 1 (CF is unchanged)dst = dst - 1Flags: OF SF ZF AF PFArithmetic |
| r/m32 | FF /1 | ||
| r/m16 | 66 FF /1 | ||
| div | ax, r/m8 | F6 /6 | Unsigned division: edx:eax by the operand, quotient to eax, remainder to edxeax = edx:eax / src; edx = edx:eax % src (8 bit: al = ax / src; ah = ax % src); #DE if src = 0 or quotient too big (unsigned)Flags: – · undefined: OF SF ZF AF CF PFArithmetic |
| eax, r/m32 | F7 /6 | ||
| ax, r/m16 | 66 F7 /6 | ||
| divpd | xmm, xmm/m128 | 66 0F 5E /r | Division of 2 doublesfor every element: dst[i] = dst[i] / src[i] (double)SSE floating point |
| divps | xmm, xmm/m128 | 0F 5E /r | Division of 4 singlesfor every element: dst[i] = dst[i] / src[i] (single)SSE floating point |
| divsd | xmm, xmm/m64 | F2 0F 5E /r | Division of one doubledst[0] = dst[0] / src[0] (double); the other elements staySSE floating point |
| divss | xmm, xmm/m32 | F3 0F 5E /r | Division of one singledst[0] = dst[0] / src[0] (single); the other elements staySSE floating point |
| dppd | xmm, xmm/m128, imm8 | 66 0F 3A 41 /r ib | Dot product of doublesdst[i] = sum of dst[j] * src[j] for the elements chosen by imm8 (high bits), written to the elements chosen by imm8 (low bits)SSE floating point |
| dpps | xmm, xmm/m128, imm8 | 66 0F 3A 40 /r ib | Dot product of singlesdst[i] = sum of dst[j] * src[j] for the elements chosen by imm8 (high bits), written to the elements chosen by imm8 (low bits)SSE floating point |
| emms | 0F 77 | End of MMX and freeing of the x87 registersmark all x87 registers as empty (after MMX)System and privileged | |
| endbr32 | F3 0F 1E FB | Marking of a valid branch target (control-flow protection)marks a valid target of an indirect jump (no change)Barriers and others | |
| endbr64 | F3 0F 1E FA | Marking of a valid branch target (control-flow protection)marks a valid target of an indirect jump (no change)Barriers and others | |
| enter | imm16, imm8 | C8 iw ib | Building of a stack frame (rare, usually push/mov)push(ebp); ebp = esp; esp = esp - size (nesting level 0)Stack |
| extractps | r/m32, xmm, imm8 | 66 0F 3A 17 /r ib | Extraction of a single from xmm into a register or memorydst = one single of src, chosen by imm8SSE and MMX data movement |
| f2xm1 | D9 F0 | 2 to the power st0 minus 1st0 = 2 ^ st0 - 1Floating point (x87) | |
| fabs | D9 E1 | Absolute value of st0st0 = abs(st0)Floating point (x87) | |
| fadd | m32 | D8 /0 | Addition (st0 = st0 + operand)st0 = st0 + src (or st(i) = st(i) + st0)Floating point (x87) |
| st0, st(i) | D8 /0 | ||
| m64 | DC /0 | ||
| st(i), st0 | DC /0 | ||
| faddp | st(i), st0 | DE /0 | Addition with popst(i) = st(i) + st0; popFloating point (x87) |
| fbld | m80 | DF /4 | Load of a packed decimal number (BCD)push: st0 = packed decimal srcFloating point (x87) |
| fbstp | m80 | DF /6 | Store of st0 as a packed decimal number and popdst = st0 as packed decimal; popFloating point (x87) |
| fchs | D9 E0 | Sign change of st0st0 = -st0Floating point (x87) | |
| fcmovb | st0, st(i) | DA /0 | Copy of st(i) to st0 if CF=1if CF = 1 then st0 = st(i)Floating point (x87) |
| fcmovbe | st0, st(i) | DA /2 | Copy of st(i) to st0 if CF=1 or ZF=1if CF = 1 or ZF = 1 then st0 = st(i)Floating point (x87) |
| fcmove | st0, st(i) | DA /1 | Copy of st(i) to st0 if ZF=1if ZF = 1 then st0 = st(i)Floating point (x87) |
| fcmovnb | st0, st(i) | DB /0 | Copy of st(i) to st0 if CF=0if CF = 0 then st0 = st(i)Floating point (x87) |
| fcmovnbe | st0, st(i) | DB /2 | Copy of st(i) to st0 if CF=0 and ZF=0if CF = 0 and ZF = 0 then st0 = st(i)Floating point (x87) |
| fcmovne | st0, st(i) | DB /1 | Copy of st(i) to st0 if ZF=0if ZF = 0 then st0 = st(i)Floating point (x87) |
| fcmovnu | st0, st(i) | DB /3 | Copy of st(i) to st0 if PF=0if PF = 0 then st0 = st(i)Floating point (x87) |
| fcmovu | st0, st(i) | DA /3 | Copy of st(i) to st0 if PF=1if PF = 1 then st0 = st(i)Floating point (x87) |
| fcom | st(i)/m32 | D8 /2 | Comparison of st0 with an operand (status word)status word C3 C2 C0 = compare(st0, src)Flags: C0 C2 C3Floating point (x87) |
| m64 | DC /2 | ||
| fcomi | st0, st(i) | DB /6 | Comparison setting ZF, PF, CF directlyZF PF CF = compare(st0, st(i))Flags: ZF CF PFFloating point (x87) |
| fcomip | st0, st(i) | DF /6 | Comparison setting ZF, PF, CF with pop of st0ZF PF CF = compare(st0, st(i)); popFlags: ZF CF PFFloating point (x87) |
| fcomp | st(i)/m32 | D8 /3 | Comparison with pop of st0status word C3 C2 C0 = compare(st0, src); popFlags: C0 C2 C3Floating point (x87) |
| m64 | DC /3 | ||
| fcompp | DE D9 | Comparison of st0 with st1 and pop of bothstatus word C3 C2 C0 = compare(st0, st1); pop twiceFlags: C0 C2 C3Floating point (x87) | |
| fcos | D9 FF | Cosine of st0st0 = cos(st0)Floating point (x87) | |
| fdecstp | D9 F6 | Decrement of the x87 stack pointertop of the x87 stack = top - 1Floating point (x87) | |
| fdiv | m32 | D8 /6 | Divisionst0 = st0 / src (or st(i) = st(i) / st0)Floating point (x87) |
| st0, st(i) | D8 /6 | ||
| m64 | DC /6 | ||
| st(i), st0 | DC /7 | ||
| fdivp | st(i), st0 | DE /7 | Division with popst(i) = st(i) / st0; popFloating point (x87) |
| fdivr | m32 | D8 /7 | Division in reverse orderst0 = src / st0 (or st(i) = st0 / st(i))Floating point (x87) |
| st0, st(i) | D8 /7 | ||
| st(i), st0 | DC /6 | ||
| m64 | DC /7 | ||
| fdivrp | st(i), st0 | DE /6 | Reverse division with popst(i) = st0 / st(i); popFloating point (x87) |
| ffree | st(i) | DD /0 | Freeing of an x87 registermark st(i) as emptyFloating point (x87) |
| fiadd | m32 | DA /0 | Addition of an integer from memoryst0 = st0 + (float) integer srcFloating point (x87) |
| m16 | DE /0 | ||
| ficom | m32 | DA /2 | Comparison of st0 with an integerstatus word C3 C2 C0 = compare(st0, integer src)Flags: C0 C2 C3Floating point (x87) |
| m16 | DE /2 | ||
| ficomp | m32 | DA /3 | Comparison with an integer and pop of st0status word C3 C2 C0 = compare(st0, integer src); popFlags: C0 C2 C3Floating point (x87) |
| m16 | DE /3 | ||
| fidiv | m32 | DA /6 | Division by an integer from memoryst0 = st0 / (float) integer srcFloating point (x87) |
| m16 | DE /6 | ||
| fidivr | m32 | DA /7 | Division of an integer by st0 (reversed)st0 = (float) integer src / st0Floating point (x87) |
| m16 | DE /7 | ||
| fild | m32 | DB /0 | Load of an integer onto the x87 stackpush: st0 = (float) integer srcFloating point (x87) |
| m16 | DF /0 | ||
| m64 | DF /5 | ||
| fimul | m32 | DA /1 | Multiplication by an integer from memoryst0 = st0 * (float) integer srcFloating point (x87) |
| m16 | DE /1 | ||
| fincstp | D9 F7 | Increment of the x87 stack pointertop of the x87 stack = top + 1Floating point (x87) | |
| fist | m32 | DB /2 | Store of st0 as an integer (rounded)dst = (integer) st0, roundedFloating point (x87) |
| m16 | DF /2 | ||
| fistp | m32 | DB /3 | Store of st0 as an integer and popdst = (integer) st0, rounded; popFloating point (x87) |
| m16 | DF /3 | ||
| m64 | DF /7 | ||
| fisttp | m32 | DB /1 | Store of st0 as an integer (truncated) and popdst = (integer) st0, truncated; popFloating point (x87) |
| m64 | DD /1 | ||
| m16 | DF /1 | ||
| fisub | m32 | DA /4 | Subtraction of an integer from memoryst0 = st0 - (float) integer srcFloating point (x87) |
| m16 | DE /4 | ||
| fisubr | m32 | DA /5 | Reverse subtraction of an integer from memoryst0 = (float) integer src - st0Floating point (x87) |
| m16 | DE /5 | ||
| fld | st(i)/m32 | D9 /0 | Load of a value onto the x87 stackpush: st0 = srcFloating point (x87) |
| m80 | DB /5 | ||
| m64 | DD /0 | ||
| fld1 | D9 E8 | Load of the constant 1.0push: st0 = 1.0Floating point (x87) | |
| fldcw | m16 | D9 /5 | Load of the x87 control wordx87 control word = [m16]Floating point (x87) |
| fldenv | m | D9 /4 | Load of the x87 environmentx87 environment = [m]Floating point (x87) |
| fldl2e | D9 EA | Load of log2(e)push: st0 = log2(e)Floating point (x87) | |
| fldl2t | D9 E9 | Load of log2(10)push: st0 = log2(10)Floating point (x87) | |
| fldlg2 | D9 EC | Load of log10(2)push: st0 = log10(2)Floating point (x87) | |
| fldln2 | D9 ED | Load of ln(2)push: st0 = ln(2)Floating point (x87) | |
| fldpi | D9 EB | Load of the constant πpush: st0 = piFloating point (x87) | |
| fldz | D9 EE | Load of the constant 0.0push: st0 = 0.0Floating point (x87) | |
| fmul | m32 | D8 /1 | Multiplicationst0 = st0 * src (or st(i) = st(i) * st0)Floating point (x87) |
| st0, st(i) | D8 /1 | ||
| m64 | DC /1 | ||
| st(i), st0 | DC /1 | ||
| fmulp | st(i), st0 | DE /1 | Multiplication with popst(i) = st(i) * st0; popFloating point (x87) |
| fnclex | DB E2 | Clearing of the x87 exceptionsclear the x87 exception flagsFloating point (x87) | |
| fninit | DB E3 | Reset of the x87 unitreset the x87 unitFloating point (x87) | |
| fnop | D9 D0 | No operation (x87)no operationFloating point (x87) | |
| fnsave | m | DD /6 | Store of the whole x87 state[m] = whole x87 state; then reset the unitFloating point (x87) |
| fnstcw | m16 | D9 /7 | Store of the x87 control word[m16] = x87 control wordFloating point (x87) |
| fnstenv | m | D9 /6 | Store of the x87 environment[m] = x87 environmentFloating point (x87) |
| fnstsw | m16 | DD /7 | Store of the x87 status worddst = x87 status wordFloating point (x87) |
| ax | DF E0 | ||
| fpatan | D9 F3 | Arc tangent of st1/st0st1 = atan(st1 / st0); popFloating point (x87) | |
| fprem | D9 F8 | Remainder of a division (partial)st0 = st0 mod st1 (truncating quotient, partial)Floating point (x87) | |
| fprem1 | D9 F5 | IEEE remainder of a divisionst0 = IEEE remainder of st0 / st1 (partial)Floating point (x87) | |
| fptan | D9 F2 | Tangent of st0st0 = tan(st0); push: st0 = 1.0Floating point (x87) | |
| frndint | D9 FC | Rounding of st0 to a whole numberst0 = round(st0) to an integer valueFloating point (x87) | |
| frstor | m | DD /4 | Restoring of the whole x87 statewhole x87 state = [m]Floating point (x87) |
| fscale | D9 FD | Multiplication of st0 by 2 to the power st1st0 = st0 * 2 ^ trunc(st1)Floating point (x87) | |
| fsin | D9 FE | Sine of st0st0 = sin(st0)Floating point (x87) | |
| fsincos | D9 FB | Sine and cosine of st0st0 = sin(st0); push: st0 = cosFloating point (x87) | |
| fsqrt | D9 FA | Square root of st0st0 = sqrt(st0)Floating point (x87) | |
| fst | m32 | D9 /2 | Store of st0 (without popping)dst = st0Floating point (x87) |
| st(i)/m64 | DD /2 | ||
| fstp | m32 | D9 /3 | Store of st0 and popdst = st0; popFloating point (x87) |
| m80 | DB /7 | ||
| st(i)/m64 | DD /3 | ||
| fsub | m32 | D8 /4 | Subtractionst0 = st0 - src (or st(i) = st(i) - st0)Floating point (x87) |
| st0, st(i) | D8 /4 | ||
| m64 | DC /4 | ||
| st(i), st0 | DC /5 | ||
| fsubp | st(i), st0 | DE /5 | Subtraction with popst(i) = st(i) - st0; popFloating point (x87) |
| fsubr | m32 | D8 /5 | Subtraction in reverse orderst0 = src - st0 (or st(i) = st0 - st(i))Floating point (x87) |
| st0, st(i) | D8 /5 | ||
| st(i), st0 | DC /4 | ||
| m64 | DC /5 | ||
| fsubrp | st(i), st0 | DE /4 | Reverse subtraction with popst(i) = st0 - st(i); popFloating point (x87) |
| ftst | D9 E4 | Comparison of st0 with 0.0status word C3 C2 C0 = compare(st0, 0.0)Flags: C0 C2 C3Floating point (x87) | |
| fucom | st(i) | DD /4 | Unordered comparison (no fault on NaN)status word C3 C2 C0 = compare(st0, src)Flags: C0 C2 C3Floating point (x87) |
| fucomi | st0, st(i) | DB /5 | Unordered comparison, sets ZF, PF, CFZF PF CF = compare(st0, st(i))Flags: ZF CF PFFloating point (x87) |
| fucomip | st0, st(i) | DF /5 | Unordered comparison, sets ZF, PF, CF, with pop of st0ZF PF CF = compare(st0, st(i)); popFlags: ZF CF PFFloating point (x87) |
| fucomp | st(i) | DD /5 | Unordered comparison with pop of st0status word C3 C2 C0 = compare(st0, src); popFlags: C0 C2 C3Floating point (x87) |
| fucompp | DA E9 | Unordered comparison of st0, st1 with pop of bothstatus word C3 C2 C0 = compare(st0, st1); pop twiceFlags: C0 C2 C3Floating point (x87) | |
| fwait | 9B | Wait for the x87 unitwait until the x87 unit is done and report its errorsBarriers and others | |
| fxam | D9 E5 | Examination of the kind of st0 (number, NaN, ...)status word C3 C2 C1 C0 = kind of st0 (number, zero, infinity, NaN, ...)Flags: C0 C1 C2 C3Floating point (x87) | |
| fxch | st(i) | D9 /1 | Exchange of st0 with another registerswap(st0, st(i))Floating point (x87) |
| fxrstor | m | 0F AE /1 | Restoring of the x87, MMX and SSE statex87, MMX and SSE state = [m]System and privileged |
| fxsave | m | 0F AE /0 | Saving of the x87, MMX and SSE state[m] = x87, MMX and SSE state (512 bytes)System and privileged |
| fxtract | D9 F4 | Splitting of st0 into exponent and mantissast0 = exponent of st0; push: st0 = significandFloating point (x87) | |
| fyl2x | D9 F1 | st1 times log2(st0)st1 = st1 * log2(st0); popFloating point (x87) | |
| fyl2xp1 | D9 F9 | st1 times log2(st0 + 1)st1 = st1 * log2(st0 + 1); popFloating point (x87) | |
| getsec | 0F 37 | Security extension instructions (Intel TXT)run the safer-mode function selected by eax (Intel TXT)System and privileged | |
| haddpd | xmm, xmm/m128 | 66 0F 7C /r | Addition of adjacent doubles (horizontal)dst = (dst[0] + dst[1], dst[2] + dst[3], src[0] + src[1], src[2] + src[3])SSE floating point |
| haddps | xmm, xmm/m128 | F2 0F 7C /r | Addition of adjacent singles (horizontal)dst = (dst[0] + dst[1], dst[2] + dst[3], src[0] + src[1], src[2] + src[3])SSE floating point |
| hlt | F4 | Halt of the processor (until the next interrupt)stop until the next interrupt (privileged)System and privileged | |
| hsubpd | xmm, xmm/m128 | 66 0F 7D /r | Subtraction of adjacent doubles (horizontal)dst = (dst[0] - dst[1], dst[2] - dst[3], src[0] - src[1], src[2] - src[3])SSE floating point |
| hsubps | xmm, xmm/m128 | F2 0F 7D /r | Subtraction of adjacent singles (horizontal)dst = (dst[0] - dst[1], dst[2] - dst[3], src[0] - src[1], src[2] - src[3])SSE floating point |
| idiv | ax, r/m8 | F6 /7 | Signed division: edx:eax by the operand, quotient to eax, remainder to edxeax = edx:eax / src; edx = edx:eax % src (8 bit: al = ax / src; ah = ax % src); #DE if src = 0 or quotient too big (signed)Flags: – · undefined: OF SF ZF AF CF PFArithmetic |
| eax, r/m32 | F7 /7 | ||
| ax, r/m16 | 66 F7 /7 | ||
| imul | r32, r/m32, imm32 | 69 /r id | Signed multiplication (one, two or three operands)1 operand: edx:eax = eax * src (signed); 2: dst = dst * src; 3: dst = src * immFlags: OF CF · undefined: SF ZF AF PFArithmetic |
| r16, r/m16, imm16 | 66 69 /r iw | ||
| r32, r/m32, imm8 | 6B /r ib | ||
| r16, r/m16, imm8 | 66 6B /r ib | ||
| r/m8 | F6 /5 | ||
| r/m32 | F7 /5 | ||
| r16 | 66 F7 /5 | ||
| r32, r/m32 | 0F AF /r | ||
| r16, r/m16 | 66 0F AF /r | ||
| in | al, imm8 | E4 ib | Read of a value from an I/O portdst = port[src]Data transfer |
| eax, imm8 | E5 ib | ||
| ax, imm8 | 66 E5 ib | ||
| al, dx | EC | ||
| eax, dx | ED | ||
| ax, dx | 66 ED | ||
| inc | r/m8 | FE /0 | Increment by 1 (CF is unchanged)dst = dst + 1Flags: OF SF ZF AF PFArithmetic |
| r/m32 | FF /0 | ||
| r/m16 | 66 FF /0 | ||
| insb | 6C | Read of a port to [edi], edi advances[edi] = port[dx]; edi = edi +/- sizeStrings | |
| insd | 6D | Read of a port to [edi], edi advances[edi] = port[dx]; edi = edi +/- sizeStrings | |
| insertps | xmm, xmm/m32, imm8 | 66 0F 3A 21 /r ib | Insertion of a single into xmmdst = dst with one single replaced by one of src (and zeroed ones), chosen by imm8SSE and MMX data movement |
| insw | 66 6D | Read of a port to [edi], edi advances[edi] = port[dx]; edi = edi +/- sizeStrings | |
| int | imm8 | CD ib | Raising of a software interruptpush(flags, cs, eip); jump to the handler of vector imm8Flags: IF TFJumps, calls and interrupts |
| int1 | F1 | Raising of debug interrupt 1interrupt 1 (debug exception)Jumps, calls and interrupts | |
| int3 | CC | Breakpoint (interrupt 3, one byte)interrupt 3 (breakpoint)Jumps, calls and interrupts | |
| into | CE | Interrupt 4 if OF=1if OF = 1 then interrupt 4System and privileged | |
| invd | 0F 08 | Invalidation of the caches without write-back (privileged)empty the caches without writing back (privileged)System and privileged | |
| invlpg | m | 0F 01 /7 | Invalidation of a TLB entryremove the translation of the page of [m] from the TLB (privileged)System and privileged |
| iretd | CF | Return from an interrupt (32 bit)eip, cs, flags = pop(); (64 bit and on a change of level: esp, ss = pop())Flags: allJumps, calls and interrupts | |
| iretw | 66 CF | Return from an interrupt (16 bit)eip, cs, flags = pop(); (64 bit and on a change of level: esp, ss = pop())Flags: allJumps, calls and interrupts | |
| ja | rel8 | 77 cb | Jump if unsigned above (CF=0 and ZF=0)if CF = 0 and ZF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 77 cb | ||
| rel32 | 0F 87 cd | ||
| rel16 | 66 0F 87 cw | ||
| jbe | rel8 | 76 cb | Jump if unsigned below or equal (CF=1 or ZF=1)if CF = 1 or ZF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 76 cb | ||
| rel32 | 0F 86 cd | ||
| rel16 | 66 0F 86 cw | ||
| jc | rel8 | 72 cb | Jump if carry, unsigned below (CF=1)if CF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 72 cb | ||
| rel32 | 0F 82 cd | ||
| rel16 | 66 0F 82 cw | ||
| jecxz | rel8 | E3 cb | Jump if ecx is 0if ecx == 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 E3 cb | ||
| jg | rel8 | 7F cb | Jump if signed greater (ZF=0 and SF=OF)if ZF = 0 and SF = OF then eip = targetJumps, calls and interrupts |
| rel8 | 66 7F cb | ||
| rel32 | 0F 8F cd | ||
| rel16 | 66 0F 8F cw | ||
| jge | rel8 | 7D cb | Jump if signed greater or equal (SF=OF)if SF = OF then eip = targetJumps, calls and interrupts |
| rel8 | 66 7D cb | ||
| rel32 | 0F 8D cd | ||
| rel16 | 66 0F 8D cw | ||
| jl | rel8 | 7C cb | Jump if signed less (SF≠OF)if SF != OF then eip = targetJumps, calls and interrupts |
| rel8 | 66 7C cb | ||
| rel32 | 0F 8C cd | ||
| rel16 | 66 0F 8C cw | ||
| jle | rel8 | 7E cb | Jump if signed less or equal (ZF=1 or SF≠OF)if ZF = 1 or SF != OF then eip = targetJumps, calls and interrupts |
| rel8 | 66 7E cb | ||
| rel32 | 0F 8E cd | ||
| rel16 | 66 0F 8E cw | ||
| jmp | rel32 | E9 cd | Jump to an addresseip = targetJumps, calls and interrupts |
| rel16 | 66 E9 cw | ||
| rel8 | EB cb | ||
| rel8 | 66 EB cb | ||
| r/m32 | FF /4 | ||
| m | FF /5 | ||
| r/m16 | 66 FF /4 | ||
| jnc | rel8 | 73 cb | Jump if no carry, unsigned above or equal (CF=0)if CF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 73 cb | ||
| rel32 | 0F 83 cd | ||
| rel16 | 66 0F 83 cw | ||
| jno | rel8 | 71 cb | Jump if no overflow (OF=0)if OF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 71 cb | ||
| rel32 | 0F 81 cd | ||
| rel16 | 66 0F 81 cw | ||
| jnp | rel8 | 7B cb | Jump if parity odd (PF=0)if PF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 7B cb | ||
| rel32 | 0F 8B cd | ||
| rel16 | 66 0F 8B cw | ||
| jns | rel8 | 79 cb | Jump if not negative (SF=0)if SF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 79 cb | ||
| rel32 | 0F 89 cd | ||
| rel16 | 66 0F 89 cw | ||
| jnz | rel8 | 75 cb | Jump if not equal, result not zero (ZF=0)if ZF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 75 cb | ||
| rel32 | 0F 85 cd | ||
| rel16 | 66 0F 85 cw | ||
| jo | rel8 | 70 cb | Jump if overflow (OF=1)if OF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 70 cb | ||
| rel32 | 0F 80 cd | ||
| rel16 | 66 0F 80 cw | ||
| jp | rel8 | 7A cb | Jump if parity even (PF=1)if PF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 7A cb | ||
| rel32 | 0F 8A cd | ||
| rel16 | 66 0F 8A cw | ||
| js | rel8 | 78 cb | Jump if negative (SF=1)if SF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 78 cb | ||
| rel32 | 0F 88 cd | ||
| rel16 | 66 0F 88 cw | ||
| jz | rel8 | 74 cb | Jump if equal, result zero (ZF=1)if ZF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 74 cb | ||
| rel32 | 0F 84 cd | ||
| rel16 | 66 0F 84 cw | ||
| lahf | 9F | Load of the flags into ahah = SF:ZF:0:AF:0:PF:1:CFFlags | |
| lar | r32, r32/m16 | 0F 02 /r | Load of the access rights of a segmentdst = access rights of the segment src; ZF = 1 if it is validFlags: ZFSystem and privileged |
| r16, r32/m16 | 66 0F 02 /r | ||
| lddqu | xmm, m128 | F2 0F F0 /r | Load of 128 bits unaligned (fast across cache lines)dst = src (128 bits; any alignment)SSE and MMX data movement |
| ldmxcsr | m | 0F AE /2 | Load of the SSE control and status registerMXCSR = [m32]SSE and MMX data movement |
| lds | r32, m | C5 /r | Load of a far pointer into ds:registerdst = [m]; ds = [m + 4]Data transfer |
| r16, m | 66 C5 /r | ||
| lea | r32, m | 8D /r | Calculation of an address and storing of the address, without a memory accessdst = address of src (no memory access)Data transfer |
| r16, m | 66 8D /r | ||
| leave | C9 | Tearing down of the stack frame (mov esp, ebp; pop ebp)esp = ebp; ebp = pop()Stack | |
| les | r32, m | C4 /r | Load of a far pointer into es:registerdst = [m]; es = [m + 4]Data transfer |
| r16, m | 66 C4 /r | ||
| lfence | 0F AE /5 | Barrier for loadsall earlier loads are done before later instructionsBarriers and others | |
| lgdt | m | 0F 01 /2 | Load of the global descriptor table registerGDTR = [m] (privileged)System and privileged |
| lidt | m | 0F 01 /3 | Load of the interrupt descriptor table registerIDTR = [m] (privileged)System and privileged |
| lldt | r/m16 | 0F 00 /2 | Load of the local descriptor table registerLDTR = src (privileged)System and privileged |
| lmsw | m | 0F 01 /6 | Load of the machine status word (low bits of cr0)CR0 bits 0 to 15 = src (privileged)System and privileged |
| lodsb | AC | Load of [esi] into al/ax/eax, esi advancesacc = [esi]; esi = esi +/- size (acc is al, ax or eax)Strings | |
| lodsd | AD | Load of [esi] into al/ax/eax, esi advancesacc = [esi]; esi = esi +/- size (acc is al, ax or eax)Strings | |
| lodsw | 66 AD | Load of [esi] into al/ax/eax, esi advancesacc = [esi]; esi = esi +/- size (acc is al, ax or eax)Strings | |
| loop | rel8 | E2 cb | Decrement of ecx and jump while it is not 0ecx = ecx - 1; if ecx != 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 E2 cb | ||
| loope | rel8 | E1 cb | Like loop, but only if ZF=1ecx = ecx - 1; if ecx != 0 and ZF = 1 then eip = targetJumps, calls and interrupts |
| rel8 | 66 E1 cb | ||
| loopne | rel8 | E0 cb | Like loop, but only if ZF=0ecx = ecx - 1; if ecx != 0 and ZF = 0 then eip = targetJumps, calls and interrupts |
| rel8 | 66 E0 cb | ||
| lsl | r32, r32/m16 | 0F 03 /r | Load of the limit of a segmentdst = limit of the segment src; ZF = 1 if it is validFlags: ZFSystem and privileged |
| r16, r32/m16 | 66 0F 03 /r | ||
| ltr | r/m16 | 0F 00 /3 | Load of the task registertask register = src (privileged)System and privileged |
| lzcnt | r32, r/m32 | F3 0F BD /r | Count of the leading zero bitsdst = number of leading 0 bits of src (width if src = 0)Flags: ZF CFArithmetic |
| maskmovdqu | xmm, xmm | 66 0F F7 /r | Store of only the bytes chosen by a mask (xmm)for each byte whose mask bit (the top bit) is 1: [edi + i] = dst[i]SSE and MMX data movement |
| maskmovq | mm, mm | 0F F7 /r | Store of only the bytes chosen by a mask (mm)for each byte whose mask bit (the top bit) is 1: [edi + i] = dst[i]SSE and MMX data movement |
| maxpd | xmm, xmm/m128 | 66 0F 5F /r | Maximum of 2 doublesfor every element: dst[i] = max(dst[i], src[i])SSE floating point |
| maxps | xmm, xmm/m128 | 0F 5F /r | Maximum of 4 singlesfor every element: dst[i] = max(dst[i], src[i])SSE floating point |
| maxsd | xmm, xmm/m64 | F2 0F 5F /r | Maximum of one doubledst[0] = max(dst[0], src[0]); the other elements staySSE floating point |
| maxss | xmm, xmm/m32 | F3 0F 5F /r | Maximum of one singledst[0] = max(dst[0], src[0]); the other elements staySSE floating point |
| mfence | 0F AE /6 | Barrier for all memory accessesall earlier loads and stores are done before later onesBarriers and others | |
| minpd | xmm, xmm/m128 | 66 0F 5D /r | Minimum of 2 doublesfor every element: dst[i] = min(dst[i], src[i])SSE floating point |
| minps | xmm, xmm/m128 | 0F 5D /r | Minimum of 4 singlesfor every element: dst[i] = min(dst[i], src[i])SSE floating point |
| minsd | xmm, xmm/m64 | F2 0F 5D /r | Minimum of one doubledst[0] = min(dst[0], src[0]); the other elements staySSE floating point |
| minss | xmm, xmm/m32 | F3 0F 5D /r | Minimum of one singledst[0] = min(dst[0], src[0]); the other elements staySSE floating point |
| monitor | 0F 01 C8 | Arming of the monitoring of an address for mwaitwatch the address in eax (for mwait)System and privileged | |
| monitorx | 0F 01 FA | Arming of the monitoring of an address for mwaitwatch the address in eax (for mwait)System and privileged | |
| mov | r/m8, r8 | 88 /r | Copy of the source to the destinationdst = srcData transfer |
| r/m32, r32 | 89 /r | ||
| r/m16, r16 | 66 89 /r | ||
| r8, r/m8 | 8A /r | ||
| r32, r/m32 | 8B /r | ||
| r16, r/m16 | 66 8B /r | ||
| r32/m16, Sreg | 8C /r | ||
| r16, Sreg | 66 8C /r | ||
| Sreg, r32/m16 | 8E /r | ||
| r8, imm8 | B0+rb ib | ||
| r32, imm32 | B8+rd id | ||
| r16, imm16 | 66 B8+rw iw | ||
| r/m8, imm8 | C6 /0 ib | ||
| r/m32, imm32 | C7 /0 id | ||
| r/m16, imm16 | 66 C7 /0 iw | ||
| r32, CRn | 0F 20 /r | ||
| r32, DRn | 0F 21 /r | ||
| CRn, r32 | 0F 22 /r | ||
| DRn, r32 | 0F 23 /r | ||
| movapd | xmm, xmm/m128 | 66 0F 28 /r | Copy of 2 double floats (128 bits), memory 16-byte aligneddst = src (128 bits; memory must be 16-byte aligned)SSE and MMX data movement |
| xmm/m128, xmm | 66 0F 29 /r | ||
| movaps | xmm, xmm/m128 | 0F 28 /r | Copy of 4 single floats (128 bits), memory 16-byte aligneddst = src (128 bits; memory must be 16-byte aligned)SSE and MMX data movement |
| xmm/m128, xmm | 0F 29 /r | ||
| movbe | r32, m | 0F 38 F0 /r | Copy with byte reversaldst = reverse_bytes(src)Data transfer |
| r16, m | 66 0F 38 F0 /r | ||
| m, r32 | 0F 38 F1 /r | ||
| m, r16 | 66 0F 38 F1 /r | ||
| movd | mm, r/m32 | 0F 6E /r | Copy of 32 bits between an integer register/memory and xmm/mmdst = src (32 bits; into xmm / mm the upper bits become 0)SSE and MMX data movement |
| xmm, r/m32 | 66 0F 6E /r | ||
| r/m32, mm | 0F 7E /r | ||
| r/m32, xmm | 66 0F 7E /r | ||
| movddup | xmm, xmm/m64 | F2 0F 12 /r | Duplication of the low double into both halvesdst = (src[63:0], src[63:0])SSE and MMX data movement |
| movdq2q | mm, xmm | F2 0F D6 /r | Copy of the low half of xmm to mmdst = src[63:0] (xmm to mm)SSE and MMX data movement |
| movdqa | xmm, xmm/m128 | 66 0F 6F /r | Copy of 128 bits of integers, memory 16-byte aligneddst = src (128 bits; memory must be 16-byte aligned)SSE and MMX data movement |
| xmm/m128, xmm | 66 0F 7F /r | ||
| movdqu | xmm, xmm/m128 | F3 0F 6F /r | Copy of 128 bits of integers, any alignmentdst = src (128 bits; any alignment)SSE and MMX data movement |
| xmm/m128, xmm | F3 0F 7F /r | ||
| movhlps | xmm, xmm | 0F 12 /r | Copy of the high half of the source xmm to the low halfdst[63:0] = src[127:64]SSE and MMX data movement |
| movhpd | xmm, m64 | 66 0F 16 /r | Copy of 1 double to (or from) the high half of xmmload: dst[127:64] = [m64]; store: [m64] = src[127:64]SSE and MMX data movement |
| m64, xmm | 66 0F 17 /r | ||
| movhps | xmm, m64 | 0F 16 /r | Copy of 2 singles to (or from) the high half of xmmload: dst[127:64] = [m64]; store: [m64] = src[127:64]SSE and MMX data movement |
| m64, xmm | 0F 17 /r | ||
| movlhps | xmm, xmm | 0F 16 /r | Copy of the low half of the source xmm to the high halfdst[127:64] = src[63:0]SSE and MMX data movement |
| movlpd | xmm, m64 | 66 0F 12 /r | Copy of 1 double to (or from) the low half of xmmload: dst[63:0] = [m64]; store: [m64] = src[63:0]SSE and MMX data movement |
| m64, xmm | 66 0F 13 /r | ||
| movlps | xmm, m64 | 0F 12 /r | Copy of 2 singles to (or from) the low half of xmmload: dst[63:0] = [m64]; store: [m64] = src[63:0]SSE and MMX data movement |
| m64, xmm | 0F 13 /r | ||
| movmskpd | r32, xmm | 66 0F 50 /r | Gathering of the sign bits of 2 doubles into a registerdst = sign bits of the 2 doubles of src (2 bits)SSE and MMX data movement |
| movmskps | r32, xmm | 0F 50 /r | Gathering of the sign bits of 4 singles into a registerdst = sign bits of the 4 singles of src (4 bits)SSE and MMX data movement |
| movntdq | m128, xmm | 66 0F E7 /r | Store of 128 bits bypassing the cache[dst] = src (past the cache)SSE and MMX data movement |
| movntdqa | xmm, xmm/m128 | 66 0F 38 2A /r | Load of 128 bits from write-combining memorydst = [src] (from write-combining memory)SSE and MMX data movement |
| movnti | m, r32 | 0F C3 /r | Store bypassing the cache (non-temporal)[dst] = src (past the cache)Data transfer |
| movntpd | m128, xmm | 66 0F 2B /r | Store of 128 bits bypassing the cache[dst] = src (past the cache)SSE and MMX data movement |
| movntps | m128, xmm | 0F 2B /r | Store of 128 bits bypassing the cache[dst] = src (past the cache)SSE and MMX data movement |
| movntq | m64, mm | 0F E7 /r | Store of 64 bits (mm) bypassing the cache[dst] = src (past the cache)SSE and MMX data movement |
| movq | mm, mm/m64 | 0F 6F /r | Copy of 64 bits (also between an integer register and xmm/mm)dst = src (64 bits; into xmm the upper half becomes 0)SSE and MMX data movement |
| xmm, xmm/m64 | F3 0F 7E /r | ||
| mm/m64, mm | 0F 7F /r | ||
| xmm/m64, xmm | 66 0F D6 /r | ||
| movq2dq | xmm, mm | F3 0F D6 /r | Copy of mm to the low half of xmmdst = (0, src) (mm to xmm)SSE and MMX data movement |
| movsb | A4 | Copy of one element from [esi] to [edi], esi and edi advance[edi] = [esi]; esi = esi +/- size; edi = edi +/- size (+ if DF = 0, - if DF = 1); with rep: repeat ecx timesStrings | |
| movsd | A5 | Copy of one double float (with xmm; without operands: string instruction)dst[63:0] = src[63:0] (from memory: the rest of dst becomes 0); without operands it is the string instructionSSE and MMX data movement | |
| xmm, xmm/m64 | F2 0F 10 /r | ||
| xmm/m64, xmm | F2 0F 11 /r | ||
| movshdup | xmm, xmm/m128 | F3 0F 16 /r | Duplication of the odd singlesdst = (src[63:32], src[63:32], src[127:96], src[127:96])SSE and MMX data movement |
| movsldup | xmm, xmm/m128 | F3 0F 12 /r | Duplication of the even singlesdst = (src[31:0], src[31:0], src[95:64], src[95:64])SSE and MMX data movement |
| movss | xmm, xmm/m32 | F3 0F 10 /r | Copy of one single floatdst[31:0] = src[31:0] (from memory: the rest of dst becomes 0)SSE and MMX data movement |
| xmm/m32, xmm | F3 0F 11 /r | ||
| movsw | 66 A5 | Copy of one element from [esi] to [edi], esi and edi advance[edi] = [esi]; esi = esi +/- size; edi = edi +/- size (+ if DF = 0, - if DF = 1); with rep: repeat ecx timesStrings | |
| movsx | r32, r/m8 | 0F BE /r | Copy with sign extension to the larger sizedst = sext(src)Data transfer |
| r16, r/m8 | 66 0F BE /r | ||
| r32, r/m16 | 0F BF /r | ||
| r16, r/m16 | 66 0F BF /r | ||
| movupd | xmm, xmm/m128 | 66 0F 10 /r | Copy of 2 double floats (128 bits), any alignmentdst = src (128 bits; any alignment)SSE and MMX data movement |
| xmm/m128, xmm | 66 0F 11 /r | ||
| movups | xmm, xmm/m128 | 0F 10 /r | Copy of 4 single floats (128 bits), any alignmentdst = src (128 bits; any alignment)SSE and MMX data movement |
| xmm/m128, xmm | 0F 11 /r | ||
| movzx | r32, r/m8 | 0F B6 /r | Copy with zero extension to the larger sizedst = zext(src)Data transfer |
| r16, r/m8 | 66 0F B6 /r | ||
| r32, r/m16 | 0F B7 /r | ||
| r16, r/m16 | 66 0F B7 /r | ||
| mpsadbw | xmm, xmm/m128, imm8 | 66 0F 3A 42 /r ib | Sums of absolute byte differences (motion search)dst[i] = sums of absolute byte differences of blocks chosen by imm8SSE and MMX integers |
| mul | al, r/m8 | F6 /4 | Unsigned multiplication, the result is twice as wide (edx:eax)edx:eax = eax * src (8 bit: ax = al * src; 16: dx:ax; 32: edx:eax)Flags: OF CF · undefined: SF ZF AF PFArithmetic |
| eax, r/m32 | F7 /4 | ||
| ax, r/m16 | 66 F7 /4 | ||
| mulpd | xmm, xmm/m128 | 66 0F 59 /r | Multiplication of 2 doublesfor every element: dst[i] = dst[i] * src[i] (double)SSE floating point |
| mulps | xmm, xmm/m128 | 0F 59 /r | Multiplication of 4 singlesfor every element: dst[i] = dst[i] * src[i] (single)SSE floating point |
| mulsd | xmm, xmm/m64 | F2 0F 59 /r | Multiplication of one doubledst[0] = dst[0] * src[0] (double); the other elements staySSE floating point |
| mulss | xmm, xmm/m32 | F3 0F 59 /r | Multiplication of one singledst[0] = dst[0] * src[0] (single); the other elements staySSE floating point |
| mwait | 0F 01 C9 | Wait for a change of the monitored addresswait until the watched address is written or an interrupt comesSystem and privileged | |
| mwaitx | 0F 01 FB | Wait for a change of the monitored addresswait until the watched address is written or an interrupt comesSystem and privileged | |
| neg | r/m8 | F6 /3 | Negation (two's complement)dst = 0 - dst; CF = (dst != 0)Flags: OF SF ZF AF CF PFArithmetic |
| r/m32 | F7 /3 | ||
| r/m16 | 66 F7 /3 | ||
| nop | 90 | No operationno operationBarriers and others | |
| r/m32 | 0F 19 /r | ||
| r/m16 | 66 0F 19 /r | ||
| r/m32 | 0F 1A /r | ||
| r/m16 | 66 0F 1A /r | ||
| r/m32 | 0F 1B /r | ||
| r/m16 | 66 0F 1B /r | ||
| r/m32 | 0F 1C /r | ||
| r/m16 | 66 0F 1C /r | ||
| r/m32 | 0F 1D /r | ||
| r/m16 | 66 0F 1D /r | ||
| r/m32 | 0F 1E /r | ||
| r/m16 | 66 0F 1E /r | ||
| r32 | F3 0F 1E /0 | ||
| r32 | F3 0F 1E /2 | ||
| r32 | F3 0F 1E /3 | ||
| r32 | F3 0F 1E /4 | ||
| r32 | F3 0F 1E /5 | ||
| r32 | F3 0F 1E /6 | ||
| eax | F3 0F 1E F8 | ||
| ebp | F3 0F 1E FD | ||
| ecx | F3 0F 1E F9 | ||
| edi | F3 0F 1E FF | ||
| esi | F3 0F 1E FE | ||
| esp | F3 0F 1E FC | ||
| r/m32 | 0F 1F /r | ||
| r/m16 | 66 0F 1F /r | ||
| not | r/m8 | F6 /2 | Inversion of all bits (one's complement)dst = ~dstLogic and bits |
| r/m32 | F7 /2 | ||
| r/m16 | 66 F7 /2 | ||
| or | r/m8, r8 | 08 /r | Bitwise ORdst = dst OR src; CF = OF = 0Flags: OF SF ZF CF PF · undefined: AFLogic and bits |
| r/m32, r32 | 09 /r | ||
| r/m16, r16 | 66 09 /r | ||
| r8, r/m8 | 0A /r | ||
| r32, r/m32 | 0B /r | ||
| r16, r/m16 | 66 0B /r | ||
| al, imm8 | 0C ib | ||
| eax, imm32 | 0D id | ||
| ax, imm16 | 66 0D iw | ||
| r/m8, imm8 | 80 /1 ib | ||
| r/m32, imm32 | 81 /1 id | ||
| r/m16, imm16 | 66 81 /1 iw | ||
| r/m8, imm8 | 82 /1 ib | ||
| r/m32, imm8 | 83 /1 ib | ||
| r/m16, imm8 | 66 83 /1 ib | ||
| orpd | xmm, xmm/m128 | 66 0F 56 /r | Bitwise ORdst = dst OR srcSSE floating point |
| orps | xmm, xmm/m128 | 0F 56 /r | Bitwise ORdst = dst OR srcSSE floating point |
| out | imm8, al | E6 ib | Write of a value to an I/O portport[dst] = srcData transfer |
| imm8, eax | E7 ib | ||
| imm8, ax | 66 E7 ib | ||
| dx, al | EE | ||
| dx, eax | EF | ||
| dx, ax | 66 EF | ||
| outsb | 6E | Write of [esi] to a port, esi advancesport[dx] = [esi]; esi = esi +/- sizeStrings | |
| outsd | 6F | Write of [esi] to a port, esi advancesport[dx] = [esi]; esi = esi +/- sizeStrings | |
| outsw | 66 6F | Write of [esi] to a port, esi advancesport[dx] = [esi]; esi = esi +/- sizeStrings | |
| pabsb | mm, mm/m64 | 0F 38 1C /r | Absolute value of bytesfor every 8 bit element: dst[i] = abs(src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 1C /r | ||
| pabsd | mm, mm/m64 | 0F 38 1E /r | Absolute value of 32-bit elementsfor every 32 bit element: dst[i] = abs(src[i])SSE and MMX integers |
| xmm, xmm/m64 | 66 0F 38 1E /r | ||
| pabsw | mm, mm/m64 | 0F 38 1D /r | Absolute value of 16-bit elementsfor every 16 bit element: dst[i] = abs(src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 1D /r | ||
| packssdw | mm, mm/m64 | 0F 6B /r | Packing of 32 to 16 bit signed (saturating)dst = (sat16_s(dst[i]) ..., sat16_s(src[i]) ...) (32 to 16 bit, signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 6B /r | ||
| packsswb | mm, mm/m64 | 0F 63 /r | Packing of 16 to 8 bit signed (saturating)dst = (sat8_s(dst[i]) ..., sat8_s(src[i]) ...) (16 to 8 bit, signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 63 /r | ||
| packusdw | xmm, xmm/m128 | 66 0F 38 2B /r | Packing of 32 to 16 bit unsigned (saturating)dst = (sat16_u(dst[i]) ..., sat16_u(src[i]) ...) (32 to 16 bit, unsigned)SSE and MMX integers |
| packuswb | mm, mm/m64 | 0F 67 /r | Packing of 16 to 8 bit unsigned (saturating)dst = (sat8_u(dst[i]) ..., sat8_u(src[i]) ...) (16 to 8 bit, unsigned)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 67 /r | ||
| paddb | mm, mm/m64 | 0F FC /r | Addition of bytesfor every 8 bit element: dst[i] = dst[i] + src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F FC /r | ||
| paddd | mm, mm/m64 | 0F FE /r | Addition of 32-bit elementsfor every 32 bit element: dst[i] = dst[i] + src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F FE /r | ||
| paddq | mm, mm/m64 | 0F D4 /r | Addition of 64-bit elementsfor every 64 bit element: dst[i] = dst[i] + src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F D4 /r | ||
| paddsb | mm, mm/m64 | 0F EC /r | Addition of bytes (signed, saturating)for every 8 bit element: dst[i] = sat_s(dst[i] + src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F EC /r | ||
| paddsw | mm, mm/m64 | 0F ED /r | Addition of 16-bit elements (signed, saturating)for every 16 bit element: dst[i] = sat_s(dst[i] + src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F ED /r | ||
| paddusb | mm, mm/m64 | 0F DC /r | Addition of bytes (unsigned, saturating)for every 8 bit element: dst[i] = sat_u(dst[i] + src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F DC /r | ||
| paddusw | mm, mm/m64 | 0F DD /r | Addition of 16-bit elements (unsigned, saturating)for every 16 bit element: dst[i] = sat_u(dst[i] + src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F DD /r | ||
| paddw | mm, mm/m64 | 0F FD /r | Addition of 16-bit elementsfor every 16 bit element: dst[i] = dst[i] + src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F FD /r | ||
| palignr | mm, mm/m64, imm8 | 0F 3A 0F /r ib | Concatenation of two registers and shift by a number of bytesdst = low part of (dst:src >> (imm8 * 8 bits))SSE and MMX integers |
| xmm, xmm/m128, imm8 | 66 0F 3A 0F /r ib | ||
| pand | mm, mm/m64 | 0F DB /r | Bitwise ANDdst = dst & srcSSE and MMX integers |
| xmm, xmm/m128 | 66 0F DB /r | ||
| pandn | mm, mm/m64 | 0F DF /r | Bitwise: NOT destination AND sourcedst = ~dst & srcSSE and MMX integers |
| xmm, xmm/m128 | 66 0F DF /r | ||
| pause | F3 90 | Hint in spin loops (saves power, helps hyper-threading)hint: this is a wait loop (no change)Barriers and others | |
| pavgb | mm, mm/m64 | 0F E0 /r | Average of bytes (rounded)dst[i] = (dst[i] + src[i] + 1) >> 1 (unsigned)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F E0 /r | ||
| pavgw | mm, mm/m64 | 0F E3 /r | Average of 16-bit elements (rounded)dst[i] = (dst[i] + src[i] + 1) >> 1 (unsigned)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F E3 /r | ||
| pblendvb | xmm, xmm/m128, xmm0 | 66 0F 38 10 /r | Selection of bytes by the sign bits of xmm0for every element: dst[i] = (sign bit of xmm0[i]) ? src[i] : dst[i]SSE and MMX integers |
| pblendw | xmm, xmm/m128, imm8 | 66 0F 3A 0E /r ib | Selection of 16-bit elements by a maskfor every element: dst[i] = bit i of imm8 ? src[i] : dst[i]SSE and MMX integers |
| pclmulqdq | xmm, xmm/m128, imm8 | 66 0F 3A 44 /r ib | Carry-less multiplication (Galois field, for CRC and GCM)dst = carry-less product of one quadword of dst and one of src (chosen by imm8)Cryptography |
| pcmpeqb | mm, mm/m64 | 0F 74 /r | Comparison for equal (bytes), the result is a maskfor every 8 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 74 /r | ||
| pcmpeqd | mm, mm/m64 | 0F 76 /r | Comparison for equal (32-bit elements), the result is a maskfor every 32 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 76 /r | ||
| pcmpeqq | xmm, xmm/m128 | 66 0F 38 29 /r | Comparison for equal (64-bit elements), the result is a maskfor every 64 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0SSE and MMX integers |
| pcmpeqw | mm, mm/m64 | 0F 75 /r | Comparison for equal (16-bit elements), the result is a maskfor every 16 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 75 /r | ||
| pcmpestri | xmm, xmm/m128, imm8 | 66 0F 3A 61 /r ib | Comparison of strings (explicit lengths), the result is an indexECX = index of the match of the strings dst, src (lengths in eax, edx; mode imm8)Flags: OF SF ZF AF CF PFSSE and MMX integers |
| pcmpestrm | xmm, xmm/m128, imm8 | 66 0F 3A 60 /r ib | Comparison of strings (explicit lengths), the result is a maskxmm0 = mask of the matches of the strings dst, src (lengths in eax, edx; mode imm8)Flags: OF SF ZF AF CF PFSSE and MMX integers |
| pcmpgtb | mm, mm/m64 | 0F 64 /r | Comparison for greater, signed (bytes), the result is a maskfor every 8 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 64 /r | ||
| pcmpgtd | mm, mm/m64 | 0F 66 /r | Comparison for greater, signed (32-bit elements), the result is a maskfor every 32 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 66 /r | ||
| pcmpgtq | xmm, xmm/m128 | 66 0F 38 37 /r | Comparison for greater, signed (64-bit elements), the result is a maskfor every 64 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)SSE and MMX integers |
| pcmpgtw | mm, mm/m64 | 0F 65 /r | Comparison for greater, signed (16-bit elements), the result is a maskfor every 16 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 65 /r | ||
| pcmpistri | xmm, xmm/m128, imm8 | 66 0F 3A 63 /r ib | Comparison of strings (0 terminated), the result is an indexECX = index of the match of the 0-terminated strings dst, src (mode imm8)Flags: OF SF ZF AF CF PFSSE and MMX integers |
| pcmpistrm | xmm, xmm/m128, imm8 | 66 0F 3A 62 /r ib | Comparison of strings (0 terminated), the result is a maskxmm0 = mask of the matches of the 0-terminated strings dst, src (mode imm8)Flags: OF SF ZF AF CF PFSSE and MMX integers |
| pextrb | r32/m8, xmm, imm8 | 66 0F 3A 14 /r ib | Extraction of an element from xmm into a registerdst = element number imm8 of srcSSE and MMX data movement |
| pextrd | r/m32, xmm, imm8 | 66 0F 3A 16 /r ib | Extraction of an element from xmm into a registerdst = element number imm8 of srcSSE and MMX data movement |
| pextrw | r32, mm, imm8 | 0F C5 /r ib | Extraction of an element from xmm into a registerdst = element number imm8 of srcSSE and MMX data movement |
| r32, xmm, imm8 | 66 0F C5 /r ib | ||
| r32/m16, xmm, imm8 | 66 0F 3A 15 /r ib | ||
| phaddd | mm, mm/m64 | 0F 38 02 /r | Addition of adjacent 32-bit elements (horizontal)dst = (dst[0] + dst[1], dst[2] + dst[3], ..., src[0] + src[1], ...)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 02 /r | ||
| phaddsw | mm, mm/m64 | 0F 38 03 /r | Addition of adjacent 16-bit elements (horizontal), saturatingdst = (dst[0] + dst[1], dst[2] + dst[3], ..., src[0] + src[1], ...) (saturating)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 03 /r | ||
| phaddw | mm, mm/m64 | 0F 38 01 /r | Addition of adjacent 16-bit elements (horizontal)dst = (dst[0] + dst[1], dst[2] + dst[3], ..., src[0] + src[1], ...)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 01 /r | ||
| phminposuw | xmm, xmm/m128 | 66 0F 38 41 /r | Search for the smallest 16-bit element and its positiondst = (smallest unsigned word of src, its index, 0 ...)SSE and MMX integers |
| phsubd | mm, mm/m64 | 0F 38 06 /r | Subtraction of adjacent 32-bit elements (horizontal)dst = (dst[0] - dst[1], dst[2] - dst[3], ..., src[0] - src[1], ...)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 06 /r | ||
| phsubsw | mm, mm/m64 | 0F 38 07 /r | Subtraction of adjacent 16-bit elements (horizontal), saturatingdst = (dst[0] - dst[1], dst[2] - dst[3], ..., src[0] - src[1], ...) (saturating)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 07 /r | ||
| phsubw | mm, mm/m64 | 0F 38 05 /r | Subtraction of adjacent 16-bit elements (horizontal)dst = (dst[0] - dst[1], dst[2] - dst[3], ..., src[0] - src[1], ...)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 05 /r | ||
| pinsrb | xmm, r32/m8, imm8 | 66 0F 3A 20 /r ib | Insertion of an element from a register into xmmdst = dst with element number imm8 replaced by srcSSE and MMX data movement |
| pinsrd | xmm, r/m32, imm8 | 66 0F 3A 22 /r ib | Insertion of an element from a register into xmmdst = dst with element number imm8 replaced by srcSSE and MMX data movement |
| pinsrw | mm, r32/m16, imm8 | 0F C4 /r ib | Insertion of an element from a register into xmmdst = dst with element number imm8 replaced by srcSSE and MMX data movement |
| xmm, r32/m16, imm8 | 66 0F C4 /r ib | ||
| pmaddubsw | mm, mm/m64 | 0F 38 04 /r | Multiplication of byte pairs and addition (saturating)dst[i] = sat16(dst_u8[2i] * src_s8[2i] + dst_u8[2i+1] * src_s8[2i+1])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 04 /r | ||
| pmaddwd | mm, mm/m64 | 0F F5 /r | Multiplication of 16-bit pairs and addition to 32 bitdst[i] = dst_s16[2i] * src_s16[2i] + dst_s16[2i+1] * src_s16[2i+1] (32 bit)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F F5 /r | ||
| pmaxsb | xmm, xmm/m128 | 66 0F 38 3C /r | Maximum of bytes (signed)for every 8 bit element: dst[i] = max(dst[i], src[i]) (signed)SSE and MMX integers |
| pmaxsd | xmm, xmm/m64 | 66 0F 38 3D /r | Maximum of 32-bit elements (signed)for every 32 bit element: dst[i] = max(dst[i], src[i]) (signed)SSE and MMX integers |
| pmaxsw | mm, mm/m64 | 0F EE /r | Maximum of 16-bit elements (signed)for every 16 bit element: dst[i] = max(dst[i], src[i]) (signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F EE /r | ||
| pmaxub | mm, mm/m64 | 0F DE /r | Maximum of bytes (unsigned)for every 8 bit element: dst[i] = max(dst[i], src[i]) (unsigned)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F DE /r | ||
| pmaxud | xmm, xmm/m128 | 66 0F 38 3F /r | Maximum of 32-bit elements (unsigned)for every 32 bit element: dst[i] = max(dst[i], src[i]) (unsigned)SSE and MMX integers |
| pmaxuw | xmm, xmm/m128 | 66 0F 38 3E /r | Maximum of 16-bit elements (unsigned)for every 16 bit element: dst[i] = max(dst[i], src[i]) (unsigned)SSE and MMX integers |
| pminsb | xmm, xmm/m128 | 66 0F 38 38 /r | Minimum of bytes (signed)for every 8 bit element: dst[i] = min(dst[i], src[i]) (signed)SSE and MMX integers |
| pminsd | xmm, xmm/m64 | 66 0F 38 39 /r | Minimum of 32-bit elements (signed)for every 32 bit element: dst[i] = min(dst[i], src[i]) (signed)SSE and MMX integers |
| pminsw | mm, mm/m64 | 0F EA /r | Minimum of 16-bit elements (signed)for every 16 bit element: dst[i] = min(dst[i], src[i]) (signed)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F EA /r | ||
| pminub | mm, mm/m64 | 0F DA /r | Minimum of bytes (unsigned)for every 8 bit element: dst[i] = min(dst[i], src[i]) (unsigned)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F DA /r | ||
| pminud | xmm, xmm/m128 | 66 0F 38 3B /r | Minimum of 32-bit elements (unsigned)for every 32 bit element: dst[i] = min(dst[i], src[i]) (unsigned)SSE and MMX integers |
| pminuw | xmm, xmm/m128 | 66 0F 38 3A /r | Minimum of 16-bit elements (unsigned)for every 16 bit element: dst[i] = min(dst[i], src[i]) (unsigned)SSE and MMX integers |
| pmovmskb | r32, mm | 0F D7 /r | Gathering of the sign bits of the bytes into a registerdst = the top bits of all bytes of srcSSE and MMX data movement |
| r32, xmm | 66 0F D7 /r | ||
| pmovsxbd | xmm, xmm/m32 | 66 0F 38 21 /r | Extension of bytes to 32 bit (sign-extending)for every element: dst[i] = sext(src[i]) to the wider sizeSSE and MMX integers |
| pmovsxbq | xmm, xmm/m16 | 66 0F 38 22 /r | Extension of bytes to 64 bit (sign-extending)for every element: dst[i] = sext(src[i]) to the wider sizeSSE and MMX integers |
| pmovsxbw | xmm, xmm/m64 | 66 0F 38 20 /r | Extension of bytes to 16 bit (sign-extending)for every element: dst[i] = sext(src[i]) to the wider sizeSSE and MMX integers |
| pmovsxdq | xmm, xmm/m64 | 66 0F 38 25 /r | Extension of 32-bit elements to 64 bit (sign-extending)for every element: dst[i] = sext(src[i]) to the wider sizeSSE and MMX integers |
| pmovsxwd | xmm, xmm/m64 | 66 0F 38 23 /r | Extension of 16-bit elements to 32 bit (sign-extending)for every element: dst[i] = sext(src[i]) to the wider sizeSSE and MMX integers |
| pmovsxwq | xmm, xmm/m32 | 66 0F 38 24 /r | Extension of 16-bit elements to 64 bit (sign-extending)for every element: dst[i] = sext(src[i]) to the wider sizeSSE and MMX integers |
| pmovzxbd | xmm, xmm/m32 | 66 0F 38 31 /r | Extension of bytes to 32 bit (zero-extending)for every element: dst[i] = zext(src[i]) to the wider sizeSSE and MMX integers |
| pmovzxbq | xmm, xmm/m16 | 66 0F 38 32 /r | Extension of bytes to 64 bit (zero-extending)for every element: dst[i] = zext(src[i]) to the wider sizeSSE and MMX integers |
| pmovzxbw | xmm, xmm/m64 | 66 0F 38 30 /r | Extension of bytes to 16 bit (zero-extending)for every element: dst[i] = zext(src[i]) to the wider sizeSSE and MMX integers |
| pmovzxdq | xmm, xmm/m64 | 66 0F 38 35 /r | Extension of 32-bit elements to 64 bit (zero-extending)for every element: dst[i] = zext(src[i]) to the wider sizeSSE and MMX integers |
| pmovzxwd | xmm, xmm/m64 | 66 0F 38 33 /r | Extension of 16-bit elements to 32 bit (zero-extending)for every element: dst[i] = zext(src[i]) to the wider sizeSSE and MMX integers |
| pmovzxwq | xmm, xmm/m32 | 66 0F 38 34 /r | Extension of 16-bit elements to 64 bit (zero-extending)for every element: dst[i] = zext(src[i]) to the wider sizeSSE and MMX integers |
| pmuldq | xmm, xmm/m128 | 66 0F 38 28 /r | Multiplication of signed 32 bit to 64 bitdst[i] = dst_s32[2i] * src_s32[2i] (64 bit results)SSE and MMX integers |
| pmulhrsw | mm, mm/m64 | 0F 38 0B /r | Multiplication of signed 16 bit, roundeddst[i] = (dst[i] * src[i] >> 14 + 1) >> 1 (signed 16 bit, rounded)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 0B /r | ||
| pmulhuw | mm, mm/m64 | 0F E4 /r | Multiplication of unsigned 16 bit, the high half is keptdst[i] = (dst[i] * src[i]) >> 16 (unsigned 16 bit)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F E4 /r | ||
| pmulhw | mm, mm/m64 | 0F E5 /r | Multiplication of signed 16 bit, the high half is keptdst[i] = (dst[i] * src[i]) >> 16 (signed 16 bit)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F E5 /r | ||
| pmulld | xmm, xmm/m128 | 66 0F 38 40 /r | Multiplication of 32 bit, the low half is keptdst[i] = low 32 bits of dst[i] * src[i]SSE and MMX integers |
| pmullw | mm, mm/m64 | 0F D5 /r | Multiplication of 16 bit, the low half is keptdst[i] = low 16 bits of dst[i] * src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F D5 /r | ||
| pmuludq | mm, mm/m64 | 0F F4 /r | Multiplication of unsigned 32 bit to 64 bitdst[i] = dst_u32[2i] * src_u32[2i] (64 bit results)SSE and MMX integers |
| xmm, xmm/m128 | 66 0F F4 /r | ||
| pop | es | 07 | Pop of a value from the stackdst = [esp]; esp = esp + 4 (16 bit: 2 bytes)Stack |
| ss | 17 | ||
| ds | 1F | ||
| r32 | 58+rd | ||
| r16 | 66 58+rw | ||
| r/m32 | 8F /0 | ||
| r/m16 | 66 8F /0 | ||
| fs | 0F A1 | ||
| gs | 0F A9 | ||
| popad | 61 | Pop of all 32-bit registers from the stackedi, esi, ebp = pop(); (esp is skipped); ebx, edx, ecx, eax = pop()Stack | |
| popaw | 66 61 | Pop of all 16-bit registers from the stackdi, si, bp = pop(); (sp is skipped); bx, dx, cx, ax = pop()Stack | |
| popcnt | r32, r/m32 | F3 0F B8 /r | Count of the set bitsdst = number of 1 bits in srcFlags: OF SF ZF AF CF PFArithmetic |
| popfd | 9D | Pop of the flags register (32 bit) from the stackeflags = pop() (privileged bits stay)Flags: allStack | |
| popfw | 66 9D | Pop of the flags register from the stackflags = pop() (privileged bits stay)Flags: allStack | |
| por | mm, mm/m64 | 0F EB /r | Bitwise ORdst = dst OR srcSSE and MMX integers |
| xmm, xmm/m128 | 66 0F EB /r | ||
| prefetch | m | 0F 0D /0 | Prefetch of a cache line (w: for writing)load the cache line of [m] into the cache (a hint, no change of the program)System and privileged |
| m | 0F 0D /2 | ||
| m | 0F 0D /3 | ||
| m | 0F 0D /4 | ||
| m | 0F 0D /5 | ||
| m | 0F 0D /6 | ||
| m | 0F 0D /7 | ||
| prefetchnta | m | 0F 18 /0 | Prefetch, trying not to pollute the cacheload the cache line of [m] into the cache (a hint, no change of the program)System and privileged |
| prefetcht0 | m | 0F 18 /1 | Prefetch into all cache levelsload the cache line of [m] into the cache (a hint, no change of the program)System and privileged |
| prefetcht1 | m | 0F 18 /2 | Prefetch into cache level 2 and higherload the cache line of [m] into the cache (a hint, no change of the program)System and privileged |
| prefetcht2 | m | 0F 18 /3 | Prefetch into cache level 3load the cache line of [m] into the cache (a hint, no change of the program)System and privileged |
| prefetchw | m | 0F 0D /1 | Prefetch of a cache line (w: for writing)load the cache line of [m] into the cache (a hint, no change of the program)System and privileged |
| psadbw | mm, mm/m64 | 0F F6 /r | Sum of absolute byte differencesdst[i] = sum of abs(dst_u8[j] - src_u8[j]) over 8 bytesSSE and MMX integers |
| xmm, xmm/m128 | 66 0F F6 /r | ||
| pshufb | mm, mm/m64 | 0F 38 00 /r | Shuffle of bytes by a table in the source registerdst[i] = (src[i] has top bit 1) ? 0 : dst[src[i] & 15]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 00 /r | ||
| pshufd | xmm, xmm/m128, imm8 | 66 0F 70 /r ib | Shuffle of the 32-bit elements as tolddst = (src[sel0], src[sel1], src[sel2], src[sel3]); sel = bit pairs of imm8SSE and MMX integers |
| pshufhw | xmm, xmm/m128, imm8 | F3 0F 70 /r ib | Shuffle of the upper four 16-bit elementsdst[63:0] = src[63:0]; the upper four words are chosen from src[127:64] by imm8SSE and MMX integers |
| pshuflw | xmm, xmm/m128, imm8 | F2 0F 70 /r ib | Shuffle of the lower four 16-bit elementsdst[127:64] = src[127:64]; the lower four words are chosen from src[63:0] by imm8SSE and MMX integers |
| pshufw | mm, mm/m64, imm8 | 0F 70 /r ib | Shuffle of four 16-bit elements (mm)dst = four words chosen from src by imm8 (mm)SSE and MMX integers |
| psignb | mm, mm/m64 | 0F 38 08 /r | Application of the sign of the source to bytesfor every 8 bit element: dst[i] = src[i] < 0 ? -dst[i] : (src[i] == 0 ? 0 : dst[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 08 /r | ||
| psignd | mm, mm/m64 | 0F 38 0A /r | Application of the sign of the source to 32-bit elementsfor every 32 bit element: dst[i] = src[i] < 0 ? -dst[i] : (src[i] == 0 ? 0 : dst[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 0A /r | ||
| psignw | mm, mm/m64 | 0F 38 09 /r | Application of the sign of the source to 16-bit elementsfor every 16 bit element: dst[i] = src[i] < 0 ? -dst[i] : (src[i] == 0 ? 0 : dst[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F 38 09 /r | ||
| pslld | mm, imm8 | 0F 72 /6 ib | Shift of 32-bit elements leftfor every 32 bit element: dst[i] = dst[i] << count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 72 /6 ib | ||
| mm, mm/m64 | 0F F2 /r | ||
| xmm, xmm/m128 | 66 0F F2 /r | ||
| pslldq | xmm, imm8 | 66 0F 73 /7 ib | Shift of the whole register left by bytesdst = dst << (imm8 * 8 bits) (the whole register, zeros come in)SSE and MMX integers |
| psllq | mm, imm8 | 0F 73 /6 ib | Shift of 64-bit elements leftfor every 64 bit element: dst[i] = dst[i] << count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 73 /6 ib | ||
| mm, mm/m64 | 0F F3 /r | ||
| xmm, xmm/m128 | 66 0F F3 /r | ||
| psllw | mm, imm8 | 0F 71 /6 ib | Shift of 16-bit elements leftfor every 16 bit element: dst[i] = dst[i] << count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 71 /6 ib | ||
| mm, mm/m64 | 0F F1 /r | ||
| xmm, xmm/m128 | 66 0F F1 /r | ||
| psrad | mm, imm8 | 0F 72 /4 ib | Shift of 32-bit elements right (arithmetic)for every 32 bit element: dst[i] = dst[i] >>s count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 72 /4 ib | ||
| mm, mm/m64 | 0F E2 /r | ||
| xmm, xmm/m128 | 66 0F E2 /r | ||
| psraw | mm, imm8 | 0F 71 /4 ib | Shift of 16-bit elements right (arithmetic)for every 16 bit element: dst[i] = dst[i] >>s count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 71 /4 ib | ||
| mm, mm/m64 | 0F E1 /r | ||
| xmm, xmm/m128 | 66 0F E1 /r | ||
| psrld | mm, imm8 | 0F 72 /2 ib | Shift of 32-bit elements right (logical)for every 32 bit element: dst[i] = dst[i] >> count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 72 /2 ib | ||
| mm, mm/m64 | 0F D2 /r | ||
| xmm, xmm/m128 | 66 0F D2 /r | ||
| psrldq | xmm, imm8 | 66 0F 73 /3 ib | Shift of the whole register right by bytesdst = dst >> (imm8 * 8 bits) (the whole register, zeros come in)SSE and MMX integers |
| psrlq | mm, imm8 | 0F 73 /2 ib | Shift of 64-bit elements right (logical)for every 64 bit element: dst[i] = dst[i] >> count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 73 /2 ib | ||
| mm, mm/m64 | 0F D3 /r | ||
| xmm, xmm/m128 | 66 0F D3 /r | ||
| psrlw | mm, imm8 | 0F 71 /2 ib | Shift of 16-bit elements right (logical)for every 16 bit element: dst[i] = dst[i] >> count (count = src or imm8)SSE and MMX integers |
| xmm, imm8 | 66 0F 71 /2 ib | ||
| mm, mm/m64 | 0F D1 /r | ||
| xmm, xmm/m128 | 66 0F D1 /r | ||
| psubb | mm, mm/m64 | 0F F8 /r | Subtraction of bytesfor every 8 bit element: dst[i] = dst[i] - src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F F8 /r | ||
| psubd | mm, mm/m64 | 0F FA /r | Subtraction of 32-bit elementsfor every 32 bit element: dst[i] = dst[i] - src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F FA /r | ||
| psubq | mm, mm/m64 | 0F FB /r | Subtraction of 64-bit elementsfor every 64 bit element: dst[i] = dst[i] - src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F FB /r | ||
| psubsb | mm, mm/m64 | 0F E8 /r | Subtraction of bytes (signed, saturating)for every 8 bit element: dst[i] = sat_s(dst[i] - src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F E8 /r | ||
| psubsw | mm, mm/m64 | 0F E9 /r | Subtraction of 16-bit elements (signed, saturating)for every 16 bit element: dst[i] = sat_s(dst[i] - src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F E9 /r | ||
| psubusb | mm, mm/m64 | 0F D8 /r | Subtraction of bytes (unsigned, saturating)for every 8 bit element: dst[i] = sat_u(dst[i] - src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F D8 /r | ||
| psubusw | mm, mm/m64 | 0F D9 /r | Subtraction of 16-bit elements (unsigned, saturating)for every 16 bit element: dst[i] = sat_u(dst[i] - src[i])SSE and MMX integers |
| xmm, xmm/m128 | 66 0F D9 /r | ||
| psubw | mm, mm/m64 | 0F F9 /r | Subtraction of 16-bit elementsfor every 16 bit element: dst[i] = dst[i] - src[i]SSE and MMX integers |
| xmm, xmm/m128 | 66 0F F9 /r | ||
| ptest | xmm, xmm/m128 | 66 0F 38 17 /r | Bit test (sets ZF and CF)ZF = ((dst & src) == 0); CF = ((~dst & src) == 0); OF SF AF PF = 0Flags: OF SF ZF AF CF PFSSE and MMX integers |
| punpckhbw | mm, mm/m64 | 0F 68 /r | Interleave of the high bytes of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elementsSSE and MMX integers |
| xmm, xmm/m128 | 66 0F 68 /r | ||
| punpckhdq | mm, mm/m64 | 0F 6A /r | Interleave of the high 32-bit elements of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elementsSSE and MMX integers |
| xmm, xmm/m128 | 66 0F 6A /r | ||
| punpckhqdq | xmm, xmm/m128 | 66 0F 6D /r | Interleave of the high 64-bit elements of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elementsSSE and MMX integers |
| punpckhwd | mm, mm/m64 | 0F 69 /r | Interleave of the high 16-bit elements of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elementsSSE and MMX integers |
| xmm, xmm/m128 | 66 0F 69 /r | ||
| punpcklbw | mm, mm/m64 | 0F 60 /r | Interleave of the low bytes of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elementsSSE and MMX integers |
| xmm, xmm/m128 | 66 0F 60 /r | ||
| punpckldq | mm, mm/m64 | 0F 62 /r | Interleave of the low 32-bit elements of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elementsSSE and MMX integers |
| xmm, xmm/m128 | 66 0F 62 /r | ||
| punpcklqdq | xmm, xmm/m128 | 66 0F 6C /r | Interleave of the low 64-bit elements of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elementsSSE and MMX integers |
| punpcklwd | mm, mm/m64 | 0F 61 /r | Interleave of the low 16-bit elements of two registersdst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elementsSSE and MMX integers |
| xmm, xmm/m128 | 66 0F 61 /r | ||
| push | es | 06 | Push of a value onto the stackesp = esp - 4; [esp] = src (16 bit: 2 bytes)Stack |
| cs | 0E | ||
| ss | 16 | ||
| ds | 1E | ||
| r32 | 50+rd | ||
| r16 | 66 50+rw | ||
| imm32 | 68 id | ||
| imm16 | 66 68 iw | ||
| imm8 | 6A ib | ||
| r/m32 | FF /6 | ||
| r/m16 | 66 FF /6 | ||
| fs | 0F A0 | ||
| gs | 0F A8 | ||
| pushad | 60 | Push of all 32-bit registers onto the stacktmp = esp; push(eax, ecx, edx, ebx, tmp, ebp, esi, edi)Stack | |
| pushaw | 66 60 | Push of all 16-bit registers onto the stacktmp = sp; push(ax, cx, dx, bx, tmp, bp, si, di)Stack | |
| pushfd | 9C | Push of the flags register (32 bit) onto the stackpush(eflags)Stack | |
| pushfw | 66 9C | Push of the flags register onto the stackpush(flags)Stack | |
| pxor | mm, mm/m64 | 0F EF /r | Bitwise exclusive OR (pxor x, x clears)dst = dst ^ srcSSE and MMX integers |
| xmm, xmm/m128 | 66 0F EF /r | ||
| rcl | r/m8, imm8 | C0 /2 ib | Rotation to the left through the carry flagrotate_left(CF:dst, count) as one value of width + 1 bitsFlags: OF CFShift and rotate |
| r/m32, imm8 | C1 /2 ib | ||
| r/m16, imm8 | 66 C1 /2 ib | ||
| r/m8, 1 | D0 /2 | ||
| r/m32, 1 | D1 /2 | ||
| r/m16, 1 | 66 D1 /2 | ||
| r/m8, cl | D2 /2 | ||
| r/m32, cl | D3 /2 | ||
| r/m16, cl | 66 D3 /2 | ||
| rcpps | xmm, xmm/m128 | 0F 53 /r | Reciprocal (approximate) of 4 singlesfor every element: dst[i] = 1 / src[i] (approximate)SSE floating point |
| rcpss | xmm, xmm/m32 | F3 0F 53 /r | Reciprocal (approximate) of one singledst[0] = 1 / src[0] (approximate); the other elements staySSE floating point |
| rcr | r/m8, imm8 | C0 /3 ib | Rotation to the right through the carry flagrotate_right(CF:dst, count) as one value of width + 1 bitsFlags: OF CFShift and rotate |
| r/m32, imm8 | C1 /3 ib | ||
| r/m16, imm8 | 66 C1 /3 ib | ||
| r/m8, 1 | D0 /3 | ||
| r/m32, 1 | D1 /3 | ||
| r/m16, 1 | 66 D1 /3 | ||
| r/m8, cl | D2 /3 | ||
| r/m32, cl | D3 /3 | ||
| r/m16, cl | 66 D3 /3 | ||
| rdfsbase | r32 | F3 0F AE /0 | Read of the base address of fs/gsdst = base address of fsSystem and privileged |
| rdgsbase | r32 | F3 0F AE /1 | Read of the base address of fs/gsdst = base address of gsSystem and privileged |
| rdmsr | 0F 32 | Read of a model-specific register (privileged)edx:eax = model-specific register number ecx (privileged)System and privileged | |
| rdpid | r64 | F3 0F C7 /7 | Read of the processor iddst = id of the processorSystem and privileged |
| rdpmc | 0F 33 | Read of a performance counteredx:eax = performance counter number ecxSystem and privileged | |
| rdrand | r32 | 0F C7 /6 | Read of a random number from the processordst = random number from the processor; CF = 1 if it is validFlags: OF SF ZF AF CF PFSystem and privileged |
| r16 | 66 0F C7 /6 | ||
| rdseed | r32 | 0F C7 /7 | Read of a seed for random number generatorsdst = seed value for random number generators; CF = 1 if it is validFlags: OF SF ZF AF CF PFSystem and privileged |
| r16 | 66 0F C7 /7 | ||
| rdsspd | r32 | F3 0F 1E /1 | Read of the shadow stack pointerdst = shadow stack pointerSystem and privileged |
| rdtsc | 0F 31 | Read of the time stamp counter (clock cycles)edx:eax = time stamp counterSystem and privileged | |
| rdtscp | 0F 01 F9 | Read of the time stamp counter and the processor idedx:eax = time stamp counter; ecx = processor idSystem and privileged | |
| ret | imm16 | C2 iw | Return from the function (the address is popped)eip = pop(); with imm16: esp = esp + imm16 afterwardsJumps, calls and interrupts |
| C3 | |||
| retf | imm16 | CA iw | Return from a far functioneip = pop(); cs = pop()Jumps, calls and interrupts |
| CB | |||
| rol | r/m8, imm8 | C0 /0 ib | Rotation to the leftdst = rotate_left(dst, count); CF = lowest bit of the resultFlags: OF CFShift and rotate |
| r/m32, imm8 | C1 /0 ib | ||
| r/m16, imm8 | 66 C1 /0 ib | ||
| r/m8, 1 | D0 /0 | ||
| r/m32, 1 | D1 /0 | ||
| r/m16, 1 | 66 D1 /0 | ||
| r/m8, cl | D2 /0 | ||
| r/m32, cl | D3 /0 | ||
| r/m16, cl | 66 D3 /0 | ||
| ror | r/m8, imm8 | C0 /1 ib | Rotation to the rightdst = rotate_right(dst, count); CF = highest bit of the resultFlags: OF CFShift and rotate |
| r/m32, imm8 | C1 /1 ib | ||
| r/m16, imm8 | 66 C1 /1 ib | ||
| r/m8, 1 | D0 /1 | ||
| r/m32, 1 | D1 /1 | ||
| r/m16, 1 | 66 D1 /1 | ||
| r/m8, cl | D2 /1 | ||
| r/m32, cl | D3 /1 | ||
| r/m16, cl | 66 D3 /1 | ||
| roundpd | xmm, xmm/m128, imm8 | 66 0F 3A 09 /r ib | Rounding of 2 doubles to whole numbersdst[i] = round(src[i]) with the rounding mode of imm8SSE floating point |
| roundps | xmm, xmm/m128, imm8 | 66 0F 3A 08 /r ib | Rounding of 4 singles to whole numbersdst[i] = round(src[i]) with the rounding mode of imm8SSE floating point |
| roundsd | xmm, xmm/m64, imm8 | 66 0F 3A 0B /r ib | Rounding of one double to a whole numberdst[i] = round(src[i]) with the rounding mode of imm8SSE floating point |
| roundss | xmm, xmm/m32, imm8 | 66 0F 3A 0A /r ib | Rounding of one single to a whole numberdst[i] = round(src[i]) with the rounding mode of imm8SSE floating point |
| rsm | 0F AA | Leaving of system management mode (SMM)leave system management mode, restore the saved stateFlags: allSystem and privileged | |
| rsqrtps | xmm, xmm/m128 | 0F 52 /r | Reciprocal square root (approximate) of 4 singlesfor every element: dst[i] = 1 / sqrt(src[i]) (approximate)SSE floating point |
| rsqrtss | xmm, xmm/m32 | F3 0F 52 /r | Reciprocal square root (approximate) of one singledst[0] = 1 / sqrt(src[0]) (approximate); the other elements staySSE floating point |
| sahf | 9E | Store of ah into the flagsSF ZF AF PF CF = bits of ahFlags: SF ZF AF CF PFFlags | |
| salc | D6 | Setting of al from CF (undocumented)al = CF ? 255 : 0Arithmetic | |
| sar | r/m8, imm8 | C0 /7 ib | Shift right signed (the sign bit stays)dst = dst >>s count (sign bit comes in); CF = last bit shifted outFlags: OF SF ZF CF PF · undefined: AFShift and rotate |
| r/m32, imm8 | C1 /7 ib | ||
| r/m16, imm8 | 66 C1 /7 ib | ||
| r/m8, 1 | D0 /7 | ||
| r/m32, 1 | D1 /7 | ||
| r/m16, 1 | 66 D1 /7 | ||
| r/m8, cl | D2 /7 | ||
| r/m32, cl | D3 /7 | ||
| r/m16, cl | 66 D3 /7 | ||
| sbb | r/m8, r8 | 18 /r | Subtraction with borrow (CF)dst = dst - src - CFFlags: OF SF ZF AF CF PFArithmetic |
| r/m32, r32 | 19 /r | ||
| r/m16, r16 | 66 19 /r | ||
| r8, r/m8 | 1A /r | ||
| r32, r/m32 | 1B /r | ||
| r16, r/m16 | 66 1B /r | ||
| al, imm8 | 1C ib | ||
| eax, imm32 | 1D id | ||
| ax, imm16 | 66 1D iw | ||
| r/m8, imm8 | 80 /3 ib | ||
| r/m32, imm32 | 81 /3 id | ||
| r/m16, imm16 | 66 81 /3 iw | ||
| r/m8, imm8 | 82 /3 ib | ||
| r/m32, imm8 | 83 /3 ib | ||
| r/m16, imm8 | 66 83 /3 ib | ||
| scasb | AE | Comparison of al/ax/eax with [edi], edi advancesflags = acc - [edi]; edi = +/- size; with repe / repne: repeat, at most ecx timesFlags: OF SF ZF AF CF PFStrings | |
| scasd | AF | Comparison of al/ax/eax with [edi], edi advancesflags = acc - [edi]; edi = +/- size; with repe / repne: repeat, at most ecx timesFlags: OF SF ZF AF CF PFStrings | |
| scasw | 66 AF | Comparison of al/ax/eax with [edi], edi advancesflags = acc - [edi]; edi = +/- size; with repe / repne: repeat, at most ecx timesFlags: OF SF ZF AF CF PFStrings | |
| seta | r/m8 | 0F 97 /r | Setting of the byte to 1 if unsigned above (CF=0 and ZF=0), else to 0dst = (CF = 0 and ZF = 0) ? 1 : 0Data transfer |
| setbe | r/m8 | 0F 96 /r | Setting of the byte to 1 if unsigned below or equal (CF=1 or ZF=1), else to 0dst = (CF = 1 or ZF = 1) ? 1 : 0Data transfer |
| setc | r/m8 | 0F 92 /r | Setting of the byte to 1 if carry, unsigned below (CF=1), else to 0dst = (CF = 1) ? 1 : 0Data transfer |
| setg | r/m8 | 0F 9F /r | Setting of the byte to 1 if signed greater (ZF=0 and SF=OF), else to 0dst = (ZF = 0 and SF = OF) ? 1 : 0Data transfer |
| setge | r/m8 | 0F 9D /r | Setting of the byte to 1 if signed greater or equal (SF=OF), else to 0dst = (SF = OF) ? 1 : 0Data transfer |
| setl | r/m8 | 0F 9C /r | Setting of the byte to 1 if signed less (SF≠OF), else to 0dst = (SF != OF) ? 1 : 0Data transfer |
| setle | r/m8 | 0F 9E /r | Setting of the byte to 1 if signed less or equal (ZF=1 or SF≠OF), else to 0dst = (ZF = 1 or SF != OF) ? 1 : 0Data transfer |
| setnc | r/m8 | 0F 93 /r | Setting of the byte to 1 if no carry, unsigned above or equal (CF=0), else to 0dst = (CF = 0) ? 1 : 0Data transfer |
| setno | r/m8 | 0F 91 /r | Setting of the byte to 1 if no overflow (OF=0), else to 0dst = (OF = 0) ? 1 : 0Data transfer |
| setnp | r/m8 | 0F 9B /r | Setting of the byte to 1 if parity odd (PF=0), else to 0dst = (PF = 0) ? 1 : 0Data transfer |
| setns | r/m8 | 0F 99 /r | Setting of the byte to 1 if not negative (SF=0), else to 0dst = (SF = 0) ? 1 : 0Data transfer |
| setnz | r/m8 | 0F 95 /r | Setting of the byte to 1 if not equal, result not zero (ZF=0), else to 0dst = (ZF = 0) ? 1 : 0Data transfer |
| seto | r/m8 | 0F 90 /r | Setting of the byte to 1 if overflow (OF=1), else to 0dst = (OF = 1) ? 1 : 0Data transfer |
| setp | r/m8 | 0F 9A /r | Setting of the byte to 1 if parity even (PF=1), else to 0dst = (PF = 1) ? 1 : 0Data transfer |
| sets | r/m8 | 0F 98 /r | Setting of the byte to 1 if negative (SF=1), else to 0dst = (SF = 1) ? 1 : 0Data transfer |
| setz | r/m8 | 0F 94 /r | Setting of the byte to 1 if equal, result zero (ZF=1), else to 0dst = (ZF = 1) ? 1 : 0Data transfer |
| sfence | 0F AE /7 | Barrier for storesall earlier stores are done before later storesBarriers and others | |
| sgdt | m | 0F 01 /0 | Store of the global descriptor table register[m] = GDTRSystem and privileged |
| shl | r/m8, imm8 | C0 /4 ib | Shift left (times 2 per place), filled with 0dst = dst << count (count masked to 5 / 6 bits); CF = last bit shifted outFlags: OF SF ZF CF PF · undefined: AFShift and rotate |
| r/m8, imm8 | C0 /6 ib | ||
| r/m32, imm8 | C1 /4 ib | ||
| r/m32, imm8 | C1 /6 ib | ||
| r/m16, imm8 | 66 C1 /4 ib | ||
| r/m16, imm8 | 66 C1 /6 ib | ||
| r/m8, 1 | D0 /4 | ||
| r/m8, 1 | D0 /6 | ||
| r/m32, 1 | D1 /4 | ||
| r/m32, 1 | D1 /6 | ||
| r/m16, 1 | 66 D1 /4 | ||
| r/m16, 1 | 66 D1 /6 | ||
| r/m8, cl | D2 /4 | ||
| r/m8, cl | D2 /6 | ||
| r/m32, cl | D3 /4 | ||
| r/m32, cl | D3 /6 | ||
| r/m16, cl | 66 D3 /4 | ||
| r/m16, cl | 66 D3 /6 | ||
| shld | r/m32, r32, imm8 | 0F A4 /r ib | Shift left, filled from a second registerdst = (dst << count) OR (src >> (width - count))Flags: OF SF ZF CF PF · undefined: AFShift and rotate |
| r/m16, r16, imm8 | 66 0F A4 /r ib | ||
| r/m32, r32, cl | 0F A5 /r | ||
| r/m16, r16, cl | 66 0F A5 /r | ||
| shr | r/m8, imm8 | C0 /5 ib | Shift right unsigned, filled with 0dst = dst >> count (zeros come in); CF = last bit shifted outFlags: OF SF ZF CF PF · undefined: AFShift and rotate |
| r/m32, imm8 | C1 /5 ib | ||
| r/m16, imm8 | 66 C1 /5 ib | ||
| r/m8, 1 | D0 /5 | ||
| r/m32, 1 | D1 /5 | ||
| r/m16, 1 | 66 D1 /5 | ||
| r/m8, cl | D2 /5 | ||
| r/m32, cl | D3 /5 | ||
| r/m16, cl | 66 D3 /5 | ||
| shrd | r/m32, r32, imm8 | 0F AC /r ib | Shift right, filled from a second registerdst = (dst >> count) OR (src << (width - count))Flags: OF SF ZF CF PF · undefined: AFShift and rotate |
| r/m16, r16, imm8 | 66 0F AC /r ib | ||
| r/m32, r32, cl | 0F AD /r | ||
| r/m16, r16, cl | 66 0F AD /r | ||
| shufpd | xmm, xmm/m128, imm8 | 66 0F C6 /r ib | Shuffle of doubles from two registers as tolddst = (dst[sel0], src[sel1]); sel = bits of imm8SSE floating point |
| shufps | xmm, xmm/m128, imm8 | 0F C6 /r ib | Shuffle of singles from two registers as tolddst = (dst[sel0], dst[sel1], src[sel2], src[sel3]); sel = bit pairs of imm8SSE floating point |
| sidt | m | 0F 01 /1 | Store of the interrupt descriptor table register[m] = IDTRSystem and privileged |
| sldt | r32/m16 | 0F 00 /0 | Store of the local descriptor table registerdst = LDTRSystem and privileged |
| r16 | 66 0F 00 /0 | ||
| smsw | m | 0F 01 /4 | Store of the machine status worddst = CR0 bits 0 to 15System and privileged |
| sqrtpd | xmm, xmm/m128 | 66 0F 51 /r | Square root of 2 doublesfor every element: dst[i] = sqrt(src[i])SSE floating point |
| sqrtps | xmm, xmm/m128 | 0F 51 /r | Square root of 4 singlesfor every element: dst[i] = sqrt(src[i])SSE floating point |
| sqrtsd | xmm, xmm/m64 | F2 0F 51 /r | Square root of one doubledst[0] = sqrt(src[0]); the other elements staySSE floating point |
| sqrtss | xmm, xmm/m32 | F3 0F 51 /r | Square root of one singledst[0] = sqrt(src[0]); the other elements staySSE floating point |
| stac | 0F 01 CB | Setting of the AC flag (access protection)EFLAGS.AC = 1Flags: ACFlags | |
| stc | F9 | Setting of the carry flagCF = 1Flags: CFFlags | |
| std | FD | Setting of the direction flag (string instructions count down)DF = 1Flags: DFFlags | |
| sti | FB | Enabling of interrupts (IF=1)IF = 1 (effective after the next instruction)Flags: IFFlags | |
| stmxcsr | m | 0F AE /3 | Store of the SSE control and status register[m32] = MXCSRSSE and MMX data movement |
| stosb | AA | Store of al/ax/eax to [edi], edi advances[edi] = acc; edi = edi +/- size (acc is al, ax or eax)Strings | |
| stosd | AB | Store of al/ax/eax to [edi], edi advances[edi] = acc; edi = edi +/- size (acc is al, ax or eax)Strings | |
| stosw | 66 AB | Store of al/ax/eax to [edi], edi advances[edi] = acc; edi = edi +/- size (acc is al, ax or eax)Strings | |
| str | r32/m16 | 0F 00 /1 | Store of the task registerdst = task registerSystem and privileged |
| r16 | 66 0F 00 /1 | ||
| sub | r/m8, r8 | 28 /r | Subtraction of the source from the destinationdst = dst - srcFlags: OF SF ZF AF CF PFArithmetic |
| r/m32, r32 | 29 /r | ||
| r/m16, r16 | 66 29 /r | ||
| r8, r/m8 | 2A /r | ||
| r32, r/m32 | 2B /r | ||
| r16, r/m16 | 66 2B /r | ||
| al, imm8 | 2C ib | ||
| eax, imm32 | 2D id | ||
| ax, imm16 | 66 2D iw | ||
| r/m8, imm8 | 80 /5 ib | ||
| r/m32, imm32 | 81 /5 id | ||
| r/m16, imm16 | 66 81 /5 iw | ||
| r/m8, imm8 | 82 /5 ib | ||
| r/m32, imm8 | 83 /5 ib | ||
| r/m16, imm8 | 66 83 /5 ib | ||
| subpd | xmm, xmm/m128 | 66 0F 5C /r | Subtraction of 2 doublesfor every element: dst[i] = dst[i] - src[i] (double)SSE floating point |
| subps | xmm, xmm/m128 | 0F 5C /r | Subtraction of 4 singlesfor every element: dst[i] = dst[i] - src[i] (single)SSE floating point |
| subsd | xmm, xmm/m64 | F2 0F 5C /r | Subtraction of one doubledst[0] = dst[0] - src[0] (double); the other elements staySSE floating point |
| subss | xmm, xmm/m32 | F3 0F 5C /r | Subtraction of one singledst[0] = dst[0] - src[0] (single); the other elements staySSE floating point |
| swapgs | 0F 01 F8 | Swap of the gs base with the kernel valueswap(gs base, kernel gs base) (privileged)System and privileged | |
| syscall | 0F 05 | Call of the operating system (64 bit, fast)ecx = eip of the next instruction; r11 = flags; eip = LSTAR; flags = flags & ~SFMASK; ring 0Flags: RFJumps, calls and interrupts | |
| sysenter | 0F 34 | Call of the operating system (32 bit, fast)enter ring 0 at the address in IA32_SYSENTER_EIPFlags: IF VMJumps, calls and interrupts | |
| sysexit | 0F 35 | Return from a system call (32 bit, fast)back to ring 3: eip = edx, esp = ecxJumps, calls and interrupts | |
| sysretd | 0F 07 | Return from a system call (fast)eip = ecx; flags = r11; back to ring 3Jumps, calls and interrupts | |
| test | r/m8, r8 | 84 /r | Bitwise test (AND), only the flags changeflags = dst & src (the result is thrown away); CF = OF = 0Flags: OF SF ZF CF PF · undefined: AFCompare and exchange |
| r/m32, r32 | 85 /r | ||
| r/m16, r16 | 66 85 /r | ||
| al, imm8 | A8 ib | ||
| eax, imm32 | A9 id | ||
| ax, imm16 | 66 A9 iw | ||
| r/m8, imm8 | F6 /0 ib | ||
| r/m8, imm8 | F6 /1 ib | ||
| r/m32, imm32 | F7 /0 id | ||
| r/m32, imm32 | F7 /1 id | ||
| r/m16, imm16 | 66 F7 /0 iw | ||
| r/m16, imm16 | 66 F7 /1 iw | ||
| tzcnt | r32, r/m32 | F3 0F BC /r | Count of the trailing zero bitsdst = number of trailing 0 bits of src (width if src = 0)Flags: ZF CFArithmetic |
| ucomisd | xmm, xmm/m64 | 66 0F 2E /r | Like comisd, no exception for quiet NaNZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0Flags: OF SF ZF AF CF PFSSE floating point |
| ucomiss | xmm, xmm/m32 | 0F 2E /r | Like comiss, no exception for quiet NaNZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0Flags: OF SF ZF AF CF PFSSE floating point |
| ud2 | 0F 0B | Deliberately invalid instruction (raises an exception)raises #UD (invalid instruction)Jumps, calls and interrupts | |
| unpckhpd | xmm, xmm/m128 | 66 0F 15 /r | Interleave of the high doubles of two registersdst = (dst[1], src[1])SSE floating point |
| unpckhps | xmm, xmm/m128 | 0F 15 /r | Interleave of the high singles of two registersdst = (dst[2], src[2], dst[3], src[3])SSE floating point |
| unpcklpd | xmm, xmm/m128 | 66 0F 14 /r | Interleave of the low doubles of two registersdst = (dst[0], src[0])SSE floating point |
| unpcklps | xmm, xmm/m128 | 0F 14 /r | Interleave of the low singles of two registersdst = (dst[0], src[0], dst[1], src[1])SSE floating point |
| verr | r/m16 | 0F 00 /4 | Check of a segment for readabilityZF = 1 if the segment src can be readFlags: ZFSystem and privileged |
| verw | r/m16 | 0F 00 /5 | Check of a segment for writabilityZF = 1 if the segment src can be writtenFlags: ZFSystem and privileged |
| wbinvd | 0F 09 | Write-back and invalidation of the caches (privileged)write back and empty the caches (privileged)System and privileged | |
| wrfsbase | r32 | F3 0F AE /2 | Write of the base address of fs/gsbase address of fs = srcSystem and privileged |
| wrgsbase | r32 | F3 0F AE /3 | Write of the base address of fs/gsbase address of gs = srcSystem and privileged |
| wrmsr | 0F 30 | Write of a model-specific register (privileged)model-specific register number ecx = edx:eax (privileged)System and privileged | |
| xadd | r/m8, r8 | 0F C0 /r | Exchange and add (atomic with lock)tmp = dst + src; src = dst; dst = tmpFlags: OF SF ZF AF CF PFCompare and exchange |
| r/m32, r32 | 0F C1 /r | ||
| r/m16, r16 | 66 0F C1 /r | ||
| xchg | r/m8, r8 | 86 /r | Exchange of the two operands (with memory: atomic)tmp = dst; dst = src; src = tmpData transfer |
| r/m32, r32 | 87 /r | ||
| r/m16, r16 | 66 87 /r | ||
| r32, eax | 90+rd | ||
| r16, ax | 66 90+rw | ||
| xgetbv | 0F 01 D0 | Read of an extended control register (XCR)edx:eax = extended control register number ecxSystem and privileged | |
| xlatb | D7 | Load of al from the table at [ebx + al]al = [ebx + zext(al)]Data transfer | |
| xor | r/m8, r8 | 30 /r | Bitwise exclusive OR (xor eax, eax sets to 0)dst = dst ^ src; CF = OF = 0Flags: OF SF ZF CF PF · undefined: AFLogic and bits |
| r/m32, r32 | 31 /r | ||
| r/m16, r16 | 66 31 /r | ||
| r8, r/m8 | 32 /r | ||
| r32, r/m32 | 33 /r | ||
| r16, r/m16 | 66 33 /r | ||
| al, imm8 | 34 ib | ||
| eax, imm32 | 35 id | ||
| ax, imm16 | 66 35 iw | ||
| r/m8, imm8 | 80 /6 ib | ||
| r/m32, imm32 | 81 /6 id | ||
| r/m16, imm16 | 66 81 /6 iw | ||
| r/m8, imm8 | 82 /6 ib | ||
| r/m32, imm8 | 83 /6 ib | ||
| r/m16, imm8 | 66 83 /6 ib | ||
| xorpd | xmm, xmm/m128 | 66 0F 57 /r | Bitwise exclusive OR (xorps x, x clears)dst = dst ^ srcSSE floating point |
| xorps | xmm, xmm/m128 | 0F 57 /r | Bitwise exclusive OR (xorps x, x clears)dst = dst ^ srcSSE floating point |
| xrstor | m | 0F AE /5 | Restoring of the extended processor statethe state components selected by edx:eax = [m]System and privileged |
| xsave | m | 0F AE /4 | Saving of the extended processor state (SSE, AVX ...)[m] = the state components selected by edx:eaxSystem and privileged |
| xsavec | m | 0F C7 /4 | Saving of the extended processor state (SSE, AVX ...)[m] = the state components selected by edx:eaxSystem and privileged |
| xsaveopt | m | 0F AE /6 | Saving of the extended processor state (SSE, AVX ...)[m] = the state components selected by edx:eaxSystem and privileged |
| xsetbv | 0F 01 D1 | Write of an extended control register (XCR)extended control register number ecx = edx:eax (privileged)System and privileged |