radare2/libr/asm/d/x86

aaa=ascii adjust after addition
aad=ascii adjust ax before division
aam=ascii adjust ax after multiply
aas=ascii adjust al after subtraction
adc=add with carry
add=adds src and dst, stores result on dst
addpd=add packed double-fp values
addps=add packed single-fp values
addsd=add scalar double-fp values
addss=add scalar single-fp values
addsubpd=packed double-fp add/subtract
addsubps=packed single-fp add/subtract
aesdeclast=perform the last round of an AES decryption flow
aesdec=perform one round of an AES decryption flow
aesenclast=perform the last round of an AES encryption flow
aesenc=perform one round of an AES encryption flow
aesimc=assist in aes Inverse Mix Columns
aeskeygenassist=assist in AES round key generation
and=binary and operation between src and dst, stores result on dst
andnpd=bitwise logical and not of packed double-fp values
andnps=bitwise logical and not of packed single-fp values
andpd=bitwise logical and of packed double-fp values
andps=bitwise logical and of packed single-fp values
arpl=adjust rpl field of segment selector
blendpd=blend packed double-fp values
blendps=blend packed single-fp values
blendvpd=variable blend packed double-fp values
blendvps=variable blend packed single-fp values
bound=check array index against bounds
bsf=bit scan forward
bsr=bit scan reverse
bswap=byte swap
bt=bit test
btc=bit test and complement
btr=bit test and reset
bts=bit test and set
call=calls a subroutine, push eip into the stack (esp)
callf=call procedure
cbw=convert byte to word
cdqe=sign extend eax into rax
cdq=sign extends eax into edx (convert doubleword to quadword)
clc=clear carry flag
cld=clear direction flag
clflush=flush cache line
cli=clear interrupt flag
clts=clear task-switched flag in cr0
cmc=complement carry flag
cmova=conditional move - above/not below nor equal (cf=0 and zf=0)
cmovae=conditional move - above or equal/not below/not carry (cf=0)
cmovb=conditional move - below/not above nor equal/carry (cf=1)
cmovbe=conditional move - below or equal/not above (cf=1 or zf=1)
cmovc=conditional move - carry/below/not above or equal (cf=1)
cmove=conditional move - equal/zero (zf=1)
cmovg=conditional move - greater/not less nor equal (zf=0 and sf=of)
cmovge=conditional move - greater or equal/not less (sf=of)
cmovl=conditional move - less/not greater nor equal (sf!=of)
cmovle=conditional move - less or equal/not greater (zf=1 or sf!=of)
cmovna=conditional move - not above/below or equal (cf=1 or zf=1)
cmovnae=conditional move - not above nor equal/below/carry (cf=1)
cmovnb=conditional move - not below/above or equal/not carry (cf=0)
cmovnbe=conditional move - not below nor equal/above (cf=0 and zf=0)
cmovnc=conditional move - not carry/above or equal/not below (cf=0)
cmovne=conditional move - not equal/not zero (zf=0)
cmovng=conditional move - not greater/less or equal (zf=1 or sf!=of)
cmovnge=conditional move - not greater nor equal/less (sf!=of)
cmovnl=conditional move - not less/greater or equal (sf=of)
cmovnle=conditional move - not less nor equal/greater (zf=0 and sf=of)
cmovno=conditional move - not overflow (of=0)
cmovnp=conditional move - not parity/parity odd (pf=0)
cmovns=conditional move - not sign (sf=0)
cmovnz=conditional move - not zero/not equal (zf=0)
cmovo=conditional move - overflow (of=1)
cmovp=conditional move - parity/parity even (pf=1)
cmovpe=conditional move - parity even/parity (pf=1)
cmovpo=conditional move - parity odd/not parity (pf=0)
cmovs=conditional move - sign (sf=1)
cmovz=conditional move - zero/equal (zf=1)
cmp=compare two operands
cmppd=compare packed double-fp values
cmpps=compare packed single-fp values
cmpsb=cmp DS:[esi], (byte)ES:[edi] (esi++, edi++)
cmps=compare string operands
cmpsd=cmp DS:[esi], (dword)ES:[edi] (esi+=4, edi+=4)/compare scalar double-fp values
cmpsq=cmp DS:[rsi], (qword)ES:[rdi] (rsi+=8, rdi+=8)
cmpss=compare scalar single-fp values
cmpsw=cmp DS:[esi], (word)ES:[edi] (esi+=2, edi+=2)
cmpxchg16b=compare and exchange bytes
cmpxchg8b=compare and exchange bytes
cmpxchg=compare and exchange
comisd=compare scalar ordered double-fp values and set eflags
comiss=compare scalar ordered single-fp values and set eflags
cpuid=cpu identification
cqo=sign extends rax into rdx (convert quadword to double-quadword)
crc32=accumulate crc32 value
cs=cs segment override prefix
cvtdq2pd=convert packed dw integers to double-fp values
cvtdq2ps=convert packed dw integers to single-fp values
cvtpd2dq=convert packed double-fp values to dw integers
cvtpd2pi=convert packed double-fp values to dw integers
cvtpd2ps=convert packed double-fp values to single-fp values
cvtpi2pd=convert packed dw integers to double-fp values
cvtpi2ps=convert packed dw integers to single-fp values
cvtps2dq=convert packed single-fp values to dw integers
cvtps2pd=convert packed single-fp values to double-fp values
cvtps2pi=convert packed single-fp values to dw integers
cvtsd2si=convert scalar double-fp value to dw integer
cvtsd2ss=convert scalar double-fp value to scalar single-fp value
cvtsi2sd=convert dw integer to scalar double-fp value
cvtsi2ss=convert dw integer to scalar single-fp value
cvtss2sd=convert scalar single-fp value to scalar double-fp value
cvtss2si=convert scalar single-fp value to dw integer
cvttpd2dq=convert with trunc. packed double-fp values to dw integers
cvttpd2pi=convert with trunc. packed double-fp values to dw integers
cvttps2dq=convert with trunc. packed single-fp values to dw integers
cvttps2pi=convert with trunc. packed single-fp values to dw integers
cvttsd2si=conv. with trunc. scalar double-fp value to signed dw int
cvttss2si=convert with trunc. scalar single-fp value to dw integer
cwd=convert word to doubleword
cwde=convert word to doubleword
daa=decimal adjust al after addition
das=decimal adjust al after subtraction
dec=decrement by 1
divpd=divide packed double-fp values
divps=divide packed single-fp values
divsd=divide scalar double-fp values
divss=divide scalar single-fp values
div=unsigned divide
dppd=dot product of packed double-fp values
dpps=dot product of packed single-fp values
ds=ds segment override prefix
emms=empty mmx technology state
enter=alias for push ebp; mov ebp, esp
es=es segment override prefix
extractps=extract packed single-fp value
f2xm1=compute pow(2,x) - 1
fabs=absolute value
fadd=floating point add
faddp=floating point add and pop
fbld=load binary coded decimal
fbstp=store binary coded decimal integer and pop
fchs=change sign
fclex=clear exceptions
fcmovbe=fp conditional move - below or equal (cf=1 or zf=1)
fcmovb=fp conditional move - below (cf=1)
fcmove=fp conditional move - equal (zf=1)
fcmovnbe=fp conditional move - not below or equal (cf=0 and zf=0)
fcmovnb=fp conditional move - not below (cf=0)
fcmovne=fp conditional move - not equal (zf=0)
fcmovnu=fp conditional move - not unordered (pf=0)
fcmovu=fp conditional move - unordered (pf=1)
fcom=floating point compare
fcomi=compare floating point values and set eflags
fcomip=compare floating point values and set eflags and pop
fcomp=floating point compare and pop
fcompp=floating point compare and pop twice
fcos=floating point cosine
fdecstp=decrement floating point stack pointer
fdisi=disable npx (numeric coprocessor extension) interrupt
fdiv=floating point divide
fdivp=floting point divide and pop
fdivr=floating point divide reversed
fdivrp=floating point reverse divide and pop
feni=enable npx (numeric coprocessor extension) interrupt
ffree=free floating-point register
ffreep=free floating-point register and pop (undocumented)
fiadd=integer add
ficom=integer compare
ficomp=integer compare and pop
fidiv=integer divide
fidivr=integer divide reserved
fild=load integer
fimul=integer multiply
fincstp=increment floating-point stack pointer
finit=initialize fpu (floating-point unit)
fistp=store integer and pop
fist=store integer
fisttp=store integer with truncation and pop
fisub=integer substract
fisubr=integer susbtract reversed
fld1=load constant onto stack +1.0f
fldcw=load x87 fpu control word
fldenv=load x87 fpu environment
fldl2e=load constant onto stack: logarithm base 2 (e)
fldl2t=load constant onto stack: logarithm base 2 (10)
fldlg2=load constant onto stack: logarithm base 10 (2)
fldln2=load constant onto stack: natural logarithm (2)
fld=load floating point value
fldpi=load constant onto stack: pi (3.141592...)
fldz=load constant onto stack 0.0f
fmul=floating point multiply
fmulp=floating point multiply and pop
fnclex=clear exceptions
fndisi=disable npx (numeric coprocessor extension) interrupts (8087 only, otherwise, FNOP)
fneni=enable npx (numeric coprocessor extension) interrupts (8087 only, otherwise, FNOP)
fninit=initialize fpu (floating-point unit)
fnop=no operation
fnsave=store x87 fpu state
fnsetpm=set protected mode (8087 only, otherwise FNOP)
fnstcw=store x87 fpu control word
fnstenv=store x87 fpu environment
fnstsw=store x87 fpu status word
fpatan=partial arctangent and pop
fprem1=ieee partial remainder
fprem=partial remainder (for compatibility with i8087 and i287)
fptan=partial tangent
frndint=round to integer
frstor=restore x87 fpu state
fsave=store x87 fpu state
fscale=scale
fsetpm=set protected mode
fs=fs segment override prefix
fsincos=sine and cosine
fsin=sine
fsqrt=square root
fstcw=store x87 fpu control word
fstenv=store x87 fpu environment
fstp=store floating point value and pop
fstpnce=store floating point value and pop (undocumented)
fst=store floating point value
fstsw=store x87 fpu status word
fsub=floating point subtract
fsubp=subtract and pop
fsubrp=reverse subtract and pop
fsubr=reverse subtract
ftst=test
fucomip=unordered compare floating point values and set eflags and pop
fucomi=unordered compare floating point values and set eflags
fucompp=unordered compare floating point values and pop twice
fucomp=unordered compare floating point values and pop
fucom=unordered compare floating point values
fwait=check pending unmasked floating-point exceptions
fxam=examine
fxch=exchange register contents
fxrstor=restore x87 fpu, mmx, xmm, and mxcsr state
fxsave=save x87 fpu, mmx, xmm, and mxcsr state
fxtract=extract exponent and significand
fyl2x=compute y times log2(x) and pop
fyl2xp1=compute y times log2(x+1) and pop
getsec=getsec leaf functions
gs=gs segment override prefix
haddpd=packed double-fp horizontal add
haddps=packed single-fp horizontal add
hint_nop=hintable nop
hlt=stop process until external interrupt received
hsubpd=packed double-fp horizontal subtract
hsubps=packed single-fp horizontal subtract
icebp=Single byte single-step exception / Invoke ICE
idiv=signed divide
imul=signed multiply
inc=increment by 1
in=input from port
insb=input from port to string
insd=input from port to string
insw=input from port to string
ins=input from port to string
int1=call to interrupt procedure
int3=int 3, software breakpoint
int=call to interrupt procedure
into=call to interrupt if overflow
invd=invalidate internal caches
invept=invalidate translations derived from ept
invlpg=invalidate tlb entry
invvpid=invalidate translations based on vpid
iretd=interrupt return
iretq=interrupt return (64 bit)
iret=return from interrupt
ja=jump short if above (cf=0 and zf=0)
jae=jump short if above or equal (cf=0)
jb=jump short if below/not above nor equal/carry (cf=1)
jbe=jump short if below or equal/not above (cf=1 or zf=1)
jc=jump short if carry (cf=1)
jcxz=jump short if ecx register is 0
je=jump short if equal (zf=1)
jecxz=jump short if ecx is 0
jg=jump short if greater (zf=0 and sf=of)
jge=jump short if greater or equal (sf=of)
jl=jump short if less/not greater (sf!=of)
jle=jump short if less or equal/not greater (zf=1 or sf!=of)
jmp=jump
jmpe=jump to ia-64 instruction set
jmpf=jump
jna=jump short if not above/equal (cf=1 or zf=1)
jnae=jump short if not above nor equal/below (cf=1)
jnb=jump short if not below/above or equal/not carry (cf=0)
jnbe=jump short if not below or equal/above (cf=0 and zf=0)
jnc=jump short if not carry (cf=0)
jne=jump short if not equal/not zero (zf=0)
jng=jump short if not greater/less or equal (zf=1 or sf!=of)
jnge=jump short if not greater/less (sf!=of)
jnl=jump short if not less/greater or equal (sf=of)
jnle=jump short if not less nor equal/greater (zf=0 and sf=of)
jno=jump short if not overflow (of=0)
jnp=jump short if not parity/parity odd (pf=0)
jns=jump short if not sign (sf=0)
jnz=jump short if not zero/not equal (zf=0)
jo=jump short if overflow (of=1)
jp=jump short if parity/parity even (pf=1)
jpe=jump short if parity even/parity (pf=1)
jpo=jump short if parity odd/not parity (pf=0)
jrcxz=jump short if rcx register is 0
js=jump short if sign (sf=1)
jz=jump short if zero/equal (zf=1)
lahf=load status flags into ah register
lar=load acces right byte
lddqu=load unaligned integer 128 bits
ldmxcsr=load mxcsr register
lds=load far pointer
lea=load effective address
leave=one byte alias for mov esp, ebp ; pop ebp
les=load far pointer
lfence=load fence
lfs=load far pointer
lgdt=load global descriptor table register
lgs=load far pointer
lidt=load interrupt descriptor table register
lldt=load local descriptor table register
lmsw=load machine status word
loadalld=loads All Registers from memory address es:edi
loadall=load all of the cpu registers
lock=instruction prefix to setup the LOCK pin
lodsb=Load string byte
lodsd=Load string doubleword
lods=load string
lodsq=Load string quadword
lodsw=Load string word
loop=decrement count; jump short if ecx!=0
loope=decrement count; jump short if ecx!=0 and zf=1
loopne=decrement count; jump short if ecx!=0 and zf=0
loopnz=decrement count; jump short if ecx!=0 and zf=0
loopz=decrement count; jump short if ecx!=0 and zf=1
lsl=load segment limit
lss=load far pointer
ltr=load task register
maskmovdqu=store selected bytes of double quadword
maskmovq=store selected bytes of quadword
maxpd=return maximum packed double-fp values
maxps=return maximum packed single-fp values
maxsd=return maximum scalar double-fp value
maxss=return maximum scalar single-fp value
mfence=memory fence
minpd=return minimum packed double-fp values
minps=return minimum packed single-fp values
minsd=return minimum scalar double-fp value
minss=return minimum scalar single-fp value
monitor=set up monitor address
movabs=absolute data moves
movapd=move aligned packed double-fp values
movaps=move aligned packed single-fp values
movbe=move data after swapping bytes
movddup=move one double-fp and duplicate
movd=move doubleword
movdq2q=move quadword from xmm to mmx technology register
movdqa=move aligned double quadword
movdqu=move unaligned double quadword
movhlps=move packed single-fp values high to low
movhpd=move high packed double-fp value
movhps=move high packed single-fp values
movlhps=move packed single-fp values low to high
movlpd=move low packed double-fp value
movlps=move low packed single-fp values
mov=moves data from src to dst
movmskpd=extract packed double-fp sign mask
movmskps=extract packed single-fp sign mask
movntdqa=load double quadword non-temporal aligned hint
movntdq=store double quadword using non-temporal hint
movnti=store doubleword using non-temporal hint
movntpd=store packed double-fp values using non-temporal hint
movntps=store packed single-fp values using non-temporal hint
movntq=store of quadword using non-temporal hint
movq2dq=move quadword from mmx technology to xmm register
movq=move quadword
movsb=ES:[edi] = (byte)DS:[esi] (esi++, edi++)
movsd=ES:[edi] = (dword)DS:[esi] (esi+=4, edi+=4)/move scalar double-fp value
movshdup=move packed single-fp high and duplicate
movsldup=move packed single-fp low and duplicate
movs=move data from string to string
movss=move scalar single-fp values
movsw=ES:[edi] = (word)DS:[esi] (esi+=2, edi+=2)
movsq=ES:[rdi] = (qword)DS:[rsi] (rsi+=8, rdi+=8)
movsxd=move with sign-extension
movsx=move with sign-extension
movupd=move unaligned packed double-fp values
movups=move unaligned packed single-fp values
movzx=move dst register size padding with zeroes
mpsadbw=compute multiple packed sums of absolute difference
mulpd=multiply packed double-fp values
mulps=multiply packed single-fp values
mulsd=multiply scalar double-fp values
mulss=multiply scalar single-fp value
mul=unsigned multiply
mwait=monitor wait
neg=two's complement negation
nop=no operation
not=one's complement negation
or=logical inclusive or
orpd=bitwise logical or of double-fp values
orps=bitwise logical or of single-fp values
out=output to port
outsb=Output string byte to port
outsd=Output string doubleword to port
outs=output string to port
outsw=Output string word to port
pabsb=packed absolute value
pabsd=packed absolute value
pabsw=packed absolute value
packssdw=pack with signed saturation
packsswb=pack with signed saturation
packusdw=pack with unsigned saturation
packuswb=pack with unsigned saturation
paddb=add packed integers
paddd=add packed integers
paddq=add packed quadword integers
paddsb=add packed signed integers with signed saturation
paddsw=add packed signed integers with signed saturation
paddusb=add packed unsigned integers with unsigned saturation
paddusw=add packed unsigned integers with unsigned saturation
paddw=add packed integers
palignr=packed align right
pand=logical and
pandn=logical and not
pause=spin loop hint
pavgb=average packed integers
pavgw=average packed integers
pblendvb=variable blend packed bytes
pblendw=blend packed words
pclmulqdq=performs a carry-less multiplication of two 64-bit polynomials over the finite field GF(2).
pcmpeqb=compare packed data for equal
pcmpeqd=compare packed data for equal
pcmpeqq=compare packed qword data for equal
pcmpeqw=compare packed data for equal
pcmpestri=packed compare explicit length strings, return index
pcmpestrm=packed compare explicit length strings, return mask
pcmpgtb=compare packed signed integers for greater than
pcmpgtd=compare packed signed integers for greater than
pcmpgtw=compare packed signed integers for greater than
pcmpistri=packed compare implicit length strings, return index
pcmpistrm=packed compare implicit length strings, return mask
pextrb=extract a byte from an XMM register and insert the value into a general-purpose register or memory
pextrd=extract a dword from an XMM register and insert the value into a general-purpose register or memory
pextrq=extract a qword from an XMM register and insert the value into a general-purpose register or memory
pextrw=extract a word from an XMM register and insert the value into a general-purpose register or memory
phaddd=packed horizontal add
phaddsw=packed horizontal add and saturate
phaddw=packed horizontal add
phminposuw=packed horizontal word minimum
phsubd=packed horizontal subtract
phsubsw=packed horizontal subtract and saturate
phsubw=packed horizontal subtract
pinsrb=insert a byte value from a register or memory into an XMM register
pinsrd=insert a dword value from a register or memory into an XMM register
pinsrq=insert a qword value from a register or memory into an XMM register
pinsrw=insert a word value from a register or memory into an XMM register
pmaddubsw=multiply and add packed signed and unsigned bytes
pmaddwd=multiply and add packed integers
pmaxsb=maximum of packed signed byte integers
pmaxsd=maximum of packed signed dword integers
pmaxsw=maximum of packed signed word integers
pmaxub=maximum of packed unsigned byte integers
pmaxud=maximum of packed unsigned dword integers
pmaxuw=maximum of packed unsigned word integers
pminsb=minimum of packed signed byte integers
pminsd=minimum of packed signed dword integers
pminsw=minimum of packed signed word integers
pminub=minimum of packed unsigned byte integers
pminud=minimum of packed unsigned dword integers
pminuw=minimum of packed unsigned word integers
pmovmskb=move byte mask
pmovsxbd=sign extend the lower 8-bit integer of each packed dword element into packed signed dword integers
pmovsxbq=sign extend the lower 8-bit integer of each packed qword element into packed signed qword integers
pmovsxbw=sign extend the lower 8-bit integer of each packed word element into packed signed word integers
pmovsxdq=sign extend the lower 32-bit integer of each packed qword element into packed signed qword integers
pmovsxwd=sign extend the lower 16-bit integer of each packed dword element into packed signed dword integers
pmovsxwq=sign extend the lower 16-bit integer of each packed qword element into packed signed qword integers
pmovzxbd=zero extend the lower 8-bit integer of each packed dword element into packed signed dword integers
pmovzxbq=zero extend the lower 8-bit integer of each packed qword element into packed signed qword integers
pmovzxbw=zero extend the lower 8-bit integer of each packed word element into packed signed word integers
pmovzxdq=zero extend the lower 32-bit integer of each packed qword element into packed signed qword integers
pmovzxwd=zero extend the lower 16-bit integer of each packed dword element into packed signed dword integers
pmovzxwq=zero extend the lower 16-bit integer of each packed qword element into packed signed qword integers
pmulhrsw=packed multiply high with round and scale
pmulhuw=multiply packed unsigned integers and store high result
pmulhw=multiply packed signed integers and store high result
pmulld=multiply packed signed dword integers and store low result
pmullw=multiply packed signed integers and store low result
pmuludq=multiply packed unsigned dw integers
popad=pop all general-purpose registers
popal=pop all general-purpose registers 
popa=pop all general-purpose registers
popcnt=bit population count
popfd=pop stack into eflags register
popf=pop stack into flags register
popfq=pop stack into rflags register
pop=pops last element of stack and stores the result in argument
por=bitwise logical or
prefetchnta=prefetch data into caches
prefetcht0=prefetch data into caches
prefetcht1=prefetch data into caches
prefetcht2=prefetch data into caches
prefetchw=prefetch data into caches
psadbw=compute sum of absolute differences
pshufb=packed shuffle bytes
pshufd=shuffle packed doublewords
pshufhw=shuffle packed high words
pshuflw=shuffle packed low words
pshufw=shuffle packed words
psignb=packed sign
psignw=packed sign
pslldq=shift double quadword left logical
pslld=shift packed data left logical
psllq=shift packed data left logical
psllw=shift packed data left logical
psrad=shift packed data right arithmetic
psraw=shift packed data right arithmetic
psrldq=shift double quadword right logical
psrld=shift packed data right logical
psrlq=shift packed data right logical
psrlw=shift packed data right logical
psubb=subtract packed integers
psubd=subtract packed integers
psubq=subtract packed quadword integers
psubsb=subtract packed signed integers with signed saturation
psubsw=subtract packed signed integers with signed saturation
psubusb=subtract packed unsigned integers with unsigned saturation
psubusw=subtract packed unsigned integers with unsigned saturation
psubw=subtract packed integers
ptest=logical compare
punpckhbw=unpack high data
punpckhdq=unpack high data
punpckhqdq=unpack high data
punpckhwd=unpack high data
punpcklbw=unpack low data
punpckldq=unpack low data
punpcklqdq=unpack low data
punpcklwd=unpack low data
pushad=push all general-purpose registers
pushal=push all general-purpose registers 
pusha=push all general-purpose registers
pushfd=push eflags register onto the stack
pushf=push flags register onto the stack
pushfq=push rflags register onto the stack
push=push word, doubleword or quadword onto the stack
pxor=logical exclusive or
rcl=rotate bits left (with CF)
rcpps=compute reciprocals of packed single-fp values
rcpss=compute reciprocal of scalar single-fp values
rcr=rotate bits right (with CF)
rdmsr=read from model specific register
rdpmc=read performance-monitoring counters
rdrand=read random number
rdtscp=read time-stamp counter and processor id
rdtsc=read time-stamp counter
repe=repeat string
repne=repeat string operation prefix
repnz=repeat string operation prefix
rep=repeats next instruction ECX times
repz=repeat string operation prefix
retf=return from procedure
retn=return from procedure
ret=return from subroutine. pop 4 bytes from esp and jump there.
rex=access to new 8-bit registers
rex.b=extension of r/m field, base field, or opcode reg field
rex.rb=rex.r and rex.b combination
rex.r=extension of modr/m reg field
rex.rxb=rex.r, rex.x and rex.b combination
rex.rx=rex.r and rex.x combination
rex.w=64 bit operand size
rex.wb=rex.w and rex.b combination
rex.wrb=rex.w, rex.r and rex.b combination
rex.wr=rex.w and rex.r combination
rex.wrxb=rex.w, rex.r, rex.x and rex.b combination
rex.wrx=rex.w, rex.r and rex.x combination
rex.wxb=rex.w, rex.x and rex.b combination
rex.wx=rex.w and rex.x combination
rex.xb=rex.x and rex.b combination
rex.x=extension of sib index field
rol=rotate bits left
ror=rotate bits right
roundpd=round packed double-fp values
roundps=round packed single-fp values
roundsd=round scalar double-fp values
roundss=round scalar single-fp values
rsm=resume from system management mode
rsqrtps=compute recipr. of square roots of packed single-fp values
rsqrtss=compute recipr. of square root of scalar single-fp value
rtdsc=read time-stamp counter into edx:eax
sahf=store ah into flags
sal=arithmetic left shift
salc=set al if carry
sar=arithmetic right shift
sbb=integer subtraction with borrow
scasb=cmp al, ES:[edi++]
scasd=cmp eax, ES:[edi+=4]
scasq=cmp rax, ES:[rdi+=8]
scas=scan string
scasw=cmp ax, ES:[edi+=2]
seta=set byte on condition - above/not below nor equal (cf=0 and zf=0)
setae=set byte on condition - above or equal/not below/not carry (cf=0)
setb=set byte on condition - below/not above nor equal/carry (cf=1)
setbe=set byte on condition - below or equal/not above (cf=1 or zf=1)
setc=set byte on condition - carry/below/not above nor equal (cf=1)
sete=set byte on condition - equal/zero (zf=1)
setg=set byte on condition - greater/not less nor equal (zf=0 and sf=of)
setge=set byte on condition - greater or equal/not less (sf=of)
setl=set byte on condition - less/not greater nor equal (sf!=of)
setle=set byte on condition - less or equal/not greater (zf=1 or sf!=of)
setna=set byte on condition - not above/below or equal (cf=1 or zf=1)
setnae=set byte on condition - not above nor equal/below/carry (cf=1)
setnb=set byte on condition - not below/above or equal/not carry (cf=0)
setnbe=set byte on condition - not below nor equal/above (cf=0 and zf=0)
setnc=set byte on condition - not carry/above or equal/not below (cf=0)
setne=set byte on condition - not equal/not zero (zf=0)
setng=set byte on condition - not greater/less or equal (zf=1 or sf!=of)
setnge=set byte on condition - not greater nor equal/less (sf!=of)
setnl=set byte on condition - not less/greater or equal (sf=of)
setnle=set byte on condition - not less nor equal/greater (zf=0 and sf=of)
setno=set byte on condition - not overflow (of=0)
setnp=set byte on condition - not parity/parity odd (pf=0)
setns=set byte on condition - not sign (sf=0)
setnz=set byte on condition - not zero/not equal (zf=0)
seto=set byte on condition - overflow (of=1)
setp=set byte on condition - parity/parity even (pf=1)
setpe=set byte on condition - parity even/parity (pf=1)
setpo=set byte on condition - parity odd/not parity (pf=0)
sets=set byte on condition - sign (sf=1)
setz=set byte on condition - zero/equal (zf=1)
sfence=store fence
sgdt=store global descriptor table register
shld=double precision shift left
shl=logic left shift (0 padding)
shrd=double precision shift right
shr=logic right shift (0 padding)
shufpd=shuffle packed double-fp values
shufps=shuffle packed single-fp values
sidt=store interrupt descriptor table register
sldt=store local descriptor table register.
smsw=store machine status word
sqrtpd=compute square roots of packed double-fp values
sqrtps=compute square roots of packed single-fp values
sqrtsd=compute square root of scalar double-fp value
sqrtss=compute square root of scalar single-fp value
ss=ss segment override prefix
stc=set carry flag
std=set direction flag
sti=set interrupt flag
stmxcsr=store mxcsr register state
stosb=store string byte
stosd=store string dword
stosq=store string quadword
stosw=store string word
stos=store string
str=store task register
subpd=subtract packed double-fp values
subps=subtract packed single-fp values
subsd=subtract scalar double-fp values
subss=subtract scalar single-fp values
sub=substract src and dst, stores result on dst
swapgs=swap gs base register
syscall=fast system call
sysenter=fast system call
sysexit=fast return from fast system call
sysret=return from fast system call
test=set eflags after comparing two registers (AF, CF, OF, PF, SF, ZF)
ucomisd=unordered compare scalar double-fp values and set eflags
ucomiss=unordered compare scalar single-fp values and set eflags
ud1=undefined instruction
ud2=undefined instruction
unpckhpd=unpack and interleave high packed double-fp values
unpckhps=unpack and interleave high packed single-fp values
unpcklpd=unpack and interleave low packed double-fp values
unpcklps=unpack and interleave low packed single-fp values
verr=verify a segment for reading
verw=verify a segment for writing
vmcall=call to vm monitor
vmclear=clear virtual-machine control structure
vmlaunch=launch virtual machine
vmptrld=load pointer to virtual-machine control structure
vmptrst=store pointer to virtual-machine control structure
vmread=read field from virtual-machine control structure
vmresume=resume virtual machine
vmwrite=write field to virtual-machine control structure
vmxoff=leave vmx operation
vmxon=enter vmx operation
wait=stop process execution until TEST pin activated
wbinvd=write back and invalidate cache
wrmsr=write to model specific register
xadd=exchange and add
xchg=exchange register/memory with register
xgetbv=get value of extended control register
xlatb=table look-up translation
xlat=table look-up translation
xor=logical exclusive or
xorpd=bitwise logical xor for double-fp values
xorps=bitwise logical xor for single-fp values
xrstor=restore processor extended states
xsave=save processor extended states
xsetbv=set extended control register