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
aesdec=perform one round of an AES decryption flow
aesdeclast=perform the last round of an AES decryption flow
aesenc=perform one round of an AES encryption flow
aesenclast=perform the last 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
cdq=sign extends eax into edx (convert doubleword to quadword)
cdqe=sign extend eax into rax (added with x86-64)
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
cmovb=conditional move - below/not above or equal/carry (cf=1)
cmovbe=conditional move - below or equal/not above (cf=1 and zf=1)
cmove=conditional move - if equal (zf=1)
cmovl=conditional move - less/not greater (sf!=of)
cmovle=conditional move - less or equal/not greater ((zf=1) or (sf!=of))
cmovnb=conditional move - not below/above or equal/not carry (cf=0)
cmovnbe=conditional move - not below or equal/above (cf=0 and zf=0)
cmovne=conditional move - if not equal (zf=0)
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
cmovns=conditional move - not sign (sf=0)
cmovnz=conditional move - not zero/not equal (zf=1)
cmovo=conditional move - overflow (of=1)
cmovp=conditional move - parity/parity even (pf=1)
cmovs=conditional move - sign (sf=1)
cmovz=conditional move - zero/equal (zf=0)
cmp=compare two operands
cmppd=compare packed double-fp values
cmpps=compare packed single-fp values
cmps=compare string operands
cmpsb=cmp DS:[SI], ES:[edi] (esi++, edi++)
cmpsd=compare scalar double-fp values
cmpsq=compare string quadword (added with x86-64)
cmpss=compare scalar single-fp values
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
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
div=unsigned divide
divpd=divide packed double-fp values
divps=divide packed single-fp values
divsd=divide scalar double-fp values
divss=divide scalar single-fp values
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
fcmovb=fp conditional move - below (cf=1)
fcmovbe=fp conditional move - below or equal (cf=1 or zf=1)
fcmove=fp conditional move - equal (zf=1)
fcmovnb=fp conditional move - not below (cf=0)
fcmovnbe=fp conditional move - below or equal (cf=0 and zf=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
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)
fist=store integer
fistp=store integer and pop
fisttp=store integer with truncation and pop
fisub=integer substract
fisubr=integer susbtract reversed
fld1=load constant onto stack +1.0f
fld=load floating point value
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)
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
fs=fs segment override prefix
fsave=store x87 fpu state
fscale=scale
fsetpm=set protected mode
fsin=sine
fsincos=sine and cosine
fsqrt=square root
fst=store floating point value
fstcw=store x87 fpu control word
fstenv=store x87 fpu environment
fstp=store floating point value and pop
fstsw=store x87 fpu status word
fsub=floating point subtract
fsubp=subtract and pop
fsubr=reverse subtract
fsubrp=reverse subtract and pop
ftst=test
fucom=unordered compare floating point values
fucomi=unordered compare floating point values and set eflags
fucomip=unordered compare floating point values and set eflags and pop
fucomp=unordered compare floating point values and pop
fucompp=unordered compare floating point values and pop twice
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
in=input from port
inc=increment by 1
ins=input from port to string
insb=input from port to string
int1=call to interrupt procedure
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
iret=return from interrupt
iretd=interrupt return
iretq=interrupt return (64 bit)
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 or equal/carry (cf=1)
jbe=jump short if below or equal/not above (cf=1 and zf=1)
jcxz=jump short if ecx register is 0
je=jump short if equal (zf=1)
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
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)
jne=jump short if not equal (zf=0)
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
jns=jump short if not sign (sf=0)
jnz=jump short if not zero/not equal (zf=1)
jo=jump short if overflow (of=1)
jp=jump short if parity/parity even (pf=1)
jrcxz=jump short if rcx register is 0
js=jump short if sign (sf=1)
jz=jump short if zero/equal (zf=0)
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
loadall=load all of the cpu registers
loadalld=loads All Registers from memory address es:edi
lock=instruction prefix to setup the LOCK pin
lods=load string
lodsb=Load string byte
lodsw=Load string word
lodsq=Load string quadword (added with x86-64)
loop=decrement count; jump short if ecx!=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
mov=moves data from src to dst
movabs=absolute data moves
movapd=move aligned packed double-fp values
movaps=move aligned packed single-fp values
movbe=move data after swapping bytes
movd=move doubleword
movddup=move one double-fp and duplicate
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
movmskpd=extract packed double-fp sign mask
movmskps=extract packed single-fp sign mask
movntdq=store double quadword using non-temporal hint
movntdqa=load double quadword non-temporal aligned 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 doubleword/quadword
movs=move data from string to string
movsb=move byte sting
movsd=move scalar double-fp value
movshdup=move packed single-fp high and duplicate
movsldup=move packed single-fp low and duplicate
movss=move scalar single-fp values
movsw=ES:[edi] = (word)DS:[esi] (esi+=2, edi+=2)
movsx=move with sign-extension
movsxd=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
mul=unsigned multiply
mulpd=multiply packed double-fp values
mulps=multiply packed single-fp values
mulsd=multiply scalar double-fp values
mulss=multiply scalar single-fp value
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
outs=output string 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
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
pop=pops last element of stack and stores the result in argument
popa=pop all general-purpose registers
popad=pop all general-purpose registers
popcnt=bit population count
popf=pop stack into flags register
popfd=pop stack into eflags register
popfq=pop stack into rflags register
por=bitwise logical or
prefetchnta=prefetch data into caches
prefetcht0=prefetch data into caches
prefetcht1=prefetch data into caches
prefetcht2=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
pslld=shift packed data left logical
pslldq=shift double quadword 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
psrld=shift packed data right logical
psrldq=shift double quadword 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
push=push word, doubleword or quadword onto the stack
pusha=push all general-purpose registers
pushad=push all general-purpose registers
pushf=push flags register onto the stack
pushfd=push eflags register onto the stack
pushfq=push rflags register 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
rdtsc=read time-stamp counter
rdtscp=read time-stamp counter and processor id
rep=repeats next instruction ECX times
repe=repeat string
repnz=repeat string operation prefix
repz=repeat string operation prefix
ret=return from subroutine. pop 4 bytes from esp and jump there.
retf=return from procedure
retn=return from procedure
rex.b=extension of r/m field, base field, or opcode reg field
rex.r=extension of modr/m reg field
rex.rb=rex.r and rex.b combination
rex.rx=rex.r and rex.x combination
rex.rxb=rex.r, rex.x and rex.b combination
rex.w=64 bit operand size
rex.wb=rex.w and rex.b combination
rex.wr=rex.w and rex.r combination
rex.wrb=rex.w, rex.r and rex.b combination
rex.wrx=rex.w, rex.r and rex.x combination
rex.wrxb=rex.w, rex.r, rex.x and rex.b combination
rex.wx=rex.w and rex.x combination
rex.wxb=rex.w, rex.x and rex.b combination
rex.x=extension of sib index field
rex.xb=rex.x and rex.b combination
rex=access to new 8-bit registers
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
scas=scan string
scasb=cmp al, ES:[edi++]
scasw=cmp ax, ES:[edi+=2]
setb=set byte on condition - below/not above or equal/carry (cf=1)
setbe=set byte on condition - below or equal/not above (cf=1 and zf=1)
sete=set byte if equal (zf=1)
setl=set byte on condition - less/not greater (sf!=of)
setle=set byte on condition - less or equal/not greater ((zf=1) or (sf!=of))
setnb=set byte on condition - not below/above or equal/not carry (cf=0)
setnbe=set byte on condition - not below or equal/above (cf=0 and zf=0)
setne=set byte on condition - not zero/not equal (zf=0)
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
setns=set byte on condition - not sign (sf=0)
setnz=set byte on condition - not zero/not equal (zf=1)
seto=set byte on condition - overflow (of=1)
setp=set byte on condition - parity/parity even (pf=1)
sets=set byte on condition - sign (sf=1)
setz=set byte on condition - zero/equal (zf=0)
sfence=store fence
sgdt=store global descriptor table register
shl=logic left shift (0 padding)
shld=double precision shift left
shr=logic right shift (0 padding)
shrd=double precision shift right
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
stos=store string
stosb=store string
stosq=store string quadword (added with x86_64)
str=store task register
sub=substract src and dst, stores result on dst
subpd=subtract packed double-fp values
subps=subtract packed single-fp values
subsd=subtract scalar double-fp values
subss=subtract scalar single-fp values
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
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