mirror of
https://github.com/radareorg/radare2.git
synced 2025-03-05 21:13:27 +00:00
* Import r1's rsc adict into libr/asm/d from
This commit is contained in:
pancake
parent
ba387e0014
commit
e097de1f7a
5
TODO
5
TODO
@ -7,6 +7,11 @@
|
||||
|
||||
====[[ 0.9 ]]====
|
||||
|
||||
* Add flags to end of section? section_end..text ...
|
||||
* Refactor get_sym() and so on...
|
||||
* Add libr/asm/d API support
|
||||
- and a command.. dunny which one
|
||||
* Add rasc2 api
|
||||
* Tracing support for the debugger
|
||||
- "e cmd.trace=dr=;.dr*;pd 2@eip"
|
||||
- dca sym.main imp.printf
|
||||
|
||||
8
libr/asm/d/Makefile
Normal file
8
libr/asm/d/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
FILES=x86 arm ppc
|
||||
SDB=../../db/sdb/src/sdb
|
||||
|
||||
all:
|
||||
for a in ${FILES} ; do ${SDB} $${a}.sdb = < $$a ; done
|
||||
|
||||
clean:
|
||||
rm -f *.sdb
|
||||
13
libr/asm/d/arm
Normal file
13
libr/asm/d/arm
Normal file
@ -0,0 +1,13 @@
|
||||
b=branches the program counter to dst (pc aka r15)
|
||||
bl=branches and link, similar to call in i386, set lr(r14) = pc, changes pc (r15) )
|
||||
bx=branches and exchanges cpu mode to 16 bits (thumb mode)
|
||||
bxj=branches and exchanges cpu mode to Jazzele (jumps to a bytecode vector)
|
||||
beq=branches if equal (see 'b')
|
||||
bne=branches if not equal (see 'b')
|
||||
cmp=compares two registers
|
||||
str=stores (TODO)
|
||||
ldr=load to register(TODO)
|
||||
ldf=armfpu: load float value pointed by reg+(offset): ldf f0, [r0,#off]
|
||||
stf=armfpu: store float value pointed by reg+(offset): ldf [r0,#off]
|
||||
flt=armfpu: convert int to float: flt
|
||||
wfs=armfpu: write fp status register. wfs r0
|
||||
23
libr/asm/d/ppc
Normal file
23
libr/asm/d/ppc
Normal file
@ -0,0 +1,23 @@
|
||||
# PPC
|
||||
# r0 = call arg, return value
|
||||
# r1 = stack pointer
|
||||
# r2 = rtoc (register table of contents) (like a5 68k reg, not used, global to func (if i dont call a func))
|
||||
# r3-r10 - general purpose registers
|
||||
bgt=Branch if greater or equal (PPC: bgt CRn, addr, ARM: bgt addr)
|
||||
sc=Syscall - see svc for supervisor call on powerpc
|
||||
dbnz=Decrement counter and branch if not zero
|
||||
dbz=Decrement counter and branch if zero
|
||||
li=powerpc: load integer into register; li r3, 1
|
||||
mtctr=powerpc: preload count register (???)
|
||||
addic=powerpc: add integer to register with carry: addic r3, r3, 1
|
||||
lwz=load word and zero (32b); lwzu r3,4(r4) ; r4 = r4 + 4 ; r3 = *(r4)
|
||||
lhz=load half word and zero (16b)
|
||||
lbz=load byte and zero (8b)
|
||||
lbzu=powerpc: lbzu r8,1(r4) ; r8 = *(++p2)
|
||||
cmpw=compare word; cmpw CR0, r0, r1 (signed)
|
||||
cmplw=compare logical word; cmplwi CR0, r0, 33(unsigned)
|
||||
cmplwi=compare logical word against int; cmplwi CR0, r0, 33(unsigned)
|
||||
bctr=Branch to counter register
|
||||
bcctr=Conditional branch to counter register
|
||||
svc=The svc instruction generates a supervisor call interrupt and places
|
||||
|
||||
914
libr/asm/d/x86
Normal file
914
libr/asm/d/x86
Normal file
@ -0,0 +1,914 @@
|
||||
add=add
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
or=logical inclusive or
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
adc=add with carry
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
sbb=integer subtraction with borrow
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
and=logical and
|
||||
es=es segment override prefix
|
||||
daa=decimal adjust al after addition
|
||||
sub=subtract
|
||||
cs=cs segment override prefix
|
||||
das=decimal adjust al after subtraction
|
||||
xor=logical exclusive or
|
||||
ss=ss segment override prefix
|
||||
aaa=ascii adjust after addition
|
||||
cmp=compare two operands
|
||||
ds=ds segment override prefix
|
||||
aas=ascii adjust al after subtraction
|
||||
inc=increment by 1
|
||||
rex=access to new 8-bit registers
|
||||
rex.b=extension of r/m field, base field, or opcode reg field
|
||||
rex.x=extension of sib index field
|
||||
rex.xb=rex.x and rex.b combination
|
||||
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
|
||||
dec=decrement by 1
|
||||
rex.w=64 bit operand size
|
||||
rex.wb=rex.w and rex.b combination
|
||||
rex.wx=rex.w and rex.x combination
|
||||
rex.wxb=rex.w, rex.x 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
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
pusha=push all general-purpose registers
|
||||
pushad=push all general-purpose registers
|
||||
popa=pop all general-purpose registers
|
||||
popad=pop all general-purpose registers
|
||||
bound=check array index against bounds
|
||||
arpl=adjust rpl field of segment selector
|
||||
movsxd=move with sign-extension
|
||||
fs=fs segment override prefix
|
||||
gs=gs segment override prefix
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
imul=signed multiply
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
imul=signed multiply
|
||||
ins=input from port to string
|
||||
ins=input from port to string
|
||||
ins=input from port to string
|
||||
outs=output string to port
|
||||
outs=output string to port
|
||||
outs=output string to port
|
||||
jo=jump short if overflow (of=1)
|
||||
jno=jump short if not overflow (of=0)
|
||||
jb=jump short if below/not above or equal/carry (cf=1)
|
||||
jnb=jump short if not below/above or equal/not carry (cf=0)
|
||||
jz=jump short if zero/equal (zf=0)
|
||||
jnz=jump short if not zero/not equal (zf=1)
|
||||
jbe=jump short if below or equal/not above (cf=1 and zf=1)
|
||||
jnbe=jump short if not below or equal/above (cf=0 and zf=0)
|
||||
js=jump short if sign (sf=1)
|
||||
jns=jump short if not sign (sf=0)
|
||||
jp=jump short if parity/parity even (pf=1)
|
||||
jnp=jump short if not parity/parity odd
|
||||
jl=jump short if less/not greater (sf!=of)
|
||||
jnl=jump short if not less/greater or equal (sf=of)
|
||||
jle=jump short if less or equal/not greater ((zf=1) or (sf!=of))
|
||||
jnle=jump short if not less nor equal/greater ((zf=0) and (sf=of))
|
||||
add=add
|
||||
or=logical inclusive or
|
||||
adc=add with carry
|
||||
sbb=integer subtraction with borrow
|
||||
and=logical and
|
||||
sub=subtract
|
||||
xor=logical exclusive or
|
||||
cmp=compare two operands
|
||||
add=add
|
||||
or=logical inclusive or
|
||||
adc=add with carry
|
||||
sbb=integer subtraction with borrow
|
||||
and=logical and
|
||||
sub=subtract
|
||||
xor=logical exclusive or
|
||||
cmp=compare two operands
|
||||
add=add
|
||||
or=logical inclusive or
|
||||
adc=add with carry
|
||||
sbb=integer subtraction with borrow
|
||||
and=logical and
|
||||
sub=subtract
|
||||
xor=logical exclusive or
|
||||
cmp=compare two operands
|
||||
add=add
|
||||
or=logical inclusive or
|
||||
adc=add with carry
|
||||
sbb=integer subtraction with borrow
|
||||
and=logical and
|
||||
sub=subtract
|
||||
xor=logical exclusive or
|
||||
cmp=compare two operands
|
||||
test=logical compare
|
||||
xchg=exchange register/memory with register
|
||||
mov=move
|
||||
lea=load effective address
|
||||
mov=move
|
||||
pop=pop a value from the stack
|
||||
xchg=exchange register/memory with register
|
||||
nop=no operation
|
||||
pause=spin loop hint
|
||||
cbw=convert byte to word
|
||||
cwde=convert word to doubleword
|
||||
cbw=convert
|
||||
cwd=convert word to doubleword
|
||||
cdq=convert doubleword to quadword
|
||||
cwd=convert
|
||||
callf=call procedure
|
||||
fwait=check pending unmasked floating-point exceptions
|
||||
pushf=push flags register onto the stack
|
||||
pushfd=push eflags register onto the stack
|
||||
pushf=push rflags register onto the stack
|
||||
popf=pop stack into flags register
|
||||
popfd=pop stack into eflags register
|
||||
popf=pop stack into rflags register
|
||||
sahf=store ah into flags
|
||||
lahf=load status flags into ah register
|
||||
mov=move
|
||||
movs=move data from string to string
|
||||
movs=move data from string to string
|
||||
movs=move data from string to string
|
||||
movs=move data from string to string
|
||||
cmps=compare string operands
|
||||
cmps=compare string operands
|
||||
cmps=compare string operands
|
||||
cmps=compare string operands
|
||||
test=logical compare
|
||||
stos=store string
|
||||
stos=store string
|
||||
stos=store string
|
||||
stos=store string
|
||||
lods=load string
|
||||
lods=load string
|
||||
lods=load string
|
||||
lods=load string
|
||||
scas=scan string
|
||||
scas=scan string
|
||||
scas=scan string
|
||||
scas=scan string
|
||||
mov=move
|
||||
rol=rotate
|
||||
ror=rotate
|
||||
rcl=rotate
|
||||
rcr=rotate
|
||||
shl=shift
|
||||
shr=shift
|
||||
sal=shift
|
||||
sar=shift
|
||||
rol=rotate
|
||||
ror=rotate
|
||||
rcl=rotate
|
||||
rcr=rotate
|
||||
shl=shift
|
||||
shr=shift
|
||||
sal=shift
|
||||
sar=shift
|
||||
retn=return from procedure
|
||||
les=load far pointer
|
||||
lds=load far pointer
|
||||
mov=move
|
||||
enter=make stack frame for procedure parameters
|
||||
leave=high level procedure exit
|
||||
retf=return from procedure
|
||||
int=call to interrupt procedure
|
||||
into=call to interrupt procedure
|
||||
iret=interrupt return
|
||||
iretd=interrupt return
|
||||
iret=interrupt return
|
||||
rol=rotate
|
||||
ror=rotate
|
||||
rcl=rotate
|
||||
rcr=rotate
|
||||
shl=shift
|
||||
shr=shift
|
||||
sal=shift
|
||||
sar=shift
|
||||
rol=rotate
|
||||
ror=rotate
|
||||
rcl=rotate
|
||||
rcr=rotate
|
||||
shl=shift
|
||||
shr=shift
|
||||
sal=shift
|
||||
sar=shift
|
||||
rol=rotate
|
||||
ror=rotate
|
||||
rcl=rotate
|
||||
rcr=rotate
|
||||
shl=shift
|
||||
shr=shift
|
||||
sal=shift
|
||||
sar=shift
|
||||
rol=rotate
|
||||
ror=rotate
|
||||
rcl=rotate
|
||||
rcr=rotate
|
||||
shl=shift
|
||||
shr=shift
|
||||
sal=shift
|
||||
sar=shift
|
||||
aam=ascii adjust ax after multiply
|
||||
aad=ascii adjust ax before division
|
||||
salc=set al if carry
|
||||
xlat=table look-up translation
|
||||
fadd" => "fmul" => "fcom=compare real
|
||||
fcomp=compare real and pop
|
||||
fsub" => "fsubr" => "fdiv" => "fdivr" => "fld=load floating point value
|
||||
fxch=exchange register contents
|
||||
fst=store floating point value
|
||||
fnop=no operation
|
||||
fstp=store floating point value and pop
|
||||
fldenv=load x87 fpu environment
|
||||
fchs=change sign
|
||||
fabs=absolute value
|
||||
ftst=test
|
||||
fxam=examine
|
||||
fldcw=load x87 fpu control word
|
||||
fld1=load constant +1.0
|
||||
fldl2t=load constant log<sub>2</sub>10
|
||||
fldl2e=load constant log<sub>2</sub>e
|
||||
fldpi=load constant π
|
||||
fldlg2=load constant log<sub>10</sub>2
|
||||
fldln2=load constant log<sub>e</sub>2
|
||||
fldz=load constant +0.0
|
||||
fnstenv=store x87 fpu environment
|
||||
fstenv=store x87 fpu environment
|
||||
f2xm1=compute 2<sup>x</sup>-1
|
||||
fyl2x=compute y × log<sub>2</sub>x and pop
|
||||
fptan=partial tangent
|
||||
fpatan=partial arctangent and pop
|
||||
fxtract=extract exponent and significand
|
||||
fprem1=ieee partial remainder
|
||||
fdecstp=decrement stack-top pointer
|
||||
fincstp=increment stack-top pointer
|
||||
fnstcw=store x87 fpu control word
|
||||
fstcw=store x87 fpu control word
|
||||
fprem=partial remainder (for compatibility with i8087 and i287)
|
||||
fyl2xp1=compute y × log<sub>2</sub>(x+1) and pop
|
||||
fsqrt=square root
|
||||
fsincos=sine and cosine
|
||||
frndint=round to integer
|
||||
fscale=scale
|
||||
fsin=sine
|
||||
fcos=cosine
|
||||
fiadd=add
|
||||
fcmovb=fp conditional move - below (cf=1)
|
||||
fimul=multiply
|
||||
fcmove=fp conditional move - equal (zf=1)
|
||||
ficom=compare integer
|
||||
fcmovbe=fp conditional move - below or equal (cf=1 or zf=1)
|
||||
ficomp=compare integer and pop
|
||||
fcmovu=fp conditional move - unordered (pf=1)
|
||||
fisub=subtract
|
||||
fisubr=reverse subtract
|
||||
fucompp=unordered compare floating point values and pop twice
|
||||
fidiv=divide
|
||||
fidivr=reverse divide
|
||||
fild=load integer
|
||||
fcmovnb=fp conditional move - not below (cf=0)
|
||||
fisttp=store integer with truncation and pop
|
||||
fcmovne=fp conditional move - not equal (zf=0)
|
||||
fist=store integer
|
||||
fcmovnbe=fp conditional move - below or equal (cf=0 and zf=0)
|
||||
fistp=store integer and pop
|
||||
fcmovnu=fp conditional move - not unordered (pf=0)
|
||||
fneni=enable npx interrupt
|
||||
feni=enable npx interrupt
|
||||
fneni=treated as integer nop
|
||||
fndisi=disable npx interrupt
|
||||
fdisi=disable npx interrupt
|
||||
fndisi=treated as integer nop
|
||||
fnclex=clear exceptions
|
||||
fclex=clear exceptions
|
||||
fninit=initialize floating-point unit
|
||||
finit=initialize floating-point unit
|
||||
fnsetpm=set protected mode
|
||||
fsetpm=set protected mode
|
||||
fnsetpm=treated as integer nop
|
||||
fld=load floating point value
|
||||
fucomi=unordered compare floating point values and set eflags
|
||||
fcomi=compare floating point values and set eflags
|
||||
fstp=store floating point value and pop
|
||||
fadd=add
|
||||
fmul=multiply
|
||||
fcom=compare real
|
||||
fcomp=compare real and pop
|
||||
fsub=subtract
|
||||
fsubr=reverse subtract
|
||||
fsub=subtract
|
||||
fdiv=divide
|
||||
fdivr=reverse divide
|
||||
fdiv=divide and pop
|
||||
fld=load floating point value
|
||||
ffree=free floating-point register
|
||||
fisttp=store integer with truncation and pop
|
||||
fst=store floating point value
|
||||
fstp=store floating point value and pop
|
||||
frstor=restore x87 fpu state
|
||||
fucom=unordered compare floating point values
|
||||
fucomp=unordered compare floating point values and pop
|
||||
fnsave=store x87 fpu state
|
||||
fsave=store x87 fpu state
|
||||
fnstsw=store x87 fpu status word
|
||||
fstsw=store x87 fpu status word
|
||||
fiadd=add
|
||||
faddp=add and pop
|
||||
fimul=multiply
|
||||
fmulp=multiply and pop
|
||||
ficom=compare integer
|
||||
ficomp=compare integer and pop
|
||||
fcompp=compare real and pop twice
|
||||
fisub=subtract
|
||||
fsubrp=reverse subtract and pop
|
||||
fisubr=reverse subtract
|
||||
fsubp=subtract and pop
|
||||
fidiv=divide
|
||||
fdivrp=reverse divide and pop
|
||||
fidivr=reverse divide
|
||||
fdivp=divide and pop
|
||||
fild=load integer
|
||||
fisttp=store integer with truncation and pop
|
||||
fist=store integer
|
||||
fistp=store integer and pop
|
||||
fbld=load binary coded decimal
|
||||
fnstsw=store x87 fpu status word
|
||||
fstsw=store x87 fpu status word
|
||||
fild=load integer
|
||||
fucomip=unordered compare floating point values and set eflags and pop
|
||||
fbstp=store bcd integer and pop
|
||||
fcomip=compare floating point values and set eflags and pop
|
||||
fistp=store integer and pop
|
||||
loopnz=decrement count; jump short if count!=0 and zf=0
|
||||
loopnz=decrement count; jump short if count!=0 and zf=0
|
||||
loopz=decrement count; jump short if count!=0 and zf=1
|
||||
loopz=decrement count; jump short if count!=0 and zf=1
|
||||
loop=decrement count; jump short if count!=0
|
||||
jcxz=jump short if ecx register is 0
|
||||
jrcxz=jump short if rcx register is 0
|
||||
in=input from port
|
||||
out=output to port
|
||||
call=call procedure
|
||||
jmp=jump
|
||||
jmpf=jump
|
||||
jmp=jump
|
||||
in=input from port
|
||||
out=output to port
|
||||
lock=assert lock# signal prefix
|
||||
int1=call to interrupt procedure
|
||||
repnz=repeat string operation prefix
|
||||
rep=repeat string operation prefix
|
||||
repnz=repeat string operation prefix
|
||||
rep=repeat string operation prefix
|
||||
repz=repeat string operation prefix
|
||||
rep=repeat string operation prefix
|
||||
repz=repeat string operation prefix
|
||||
rep=repeat string operation prefix
|
||||
hlt=halt
|
||||
cmc=complement carry flag
|
||||
test=logical compare
|
||||
not=one's complement negation
|
||||
neg=two's complement negation
|
||||
mul=unsigned multiply
|
||||
imul=signed multiply
|
||||
div=unsigned divide
|
||||
idiv=signed divide
|
||||
test=logical compare
|
||||
not=one's complement negation
|
||||
neg=two's complement negation
|
||||
mul=unsigned multiply
|
||||
imul=signed multiply
|
||||
div=unsigned divide
|
||||
idiv=signed divide
|
||||
clc=clear carry flag
|
||||
stc=set carry flag
|
||||
cli=clear interrupt flag
|
||||
sti=set interrupt flag
|
||||
cld=clear direction flag
|
||||
std=set direction flag
|
||||
inc=increment by 1
|
||||
dec=decrement by 1
|
||||
inc=increment by 1
|
||||
dec=decrement by 1
|
||||
call=call procedure
|
||||
callf=call procedure
|
||||
jmp=jump
|
||||
jmpf=jump
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
sldt" => "str" => "lldt=load local descriptor table register
|
||||
ltr=load task register
|
||||
verr=verify a segment for reading
|
||||
verw=verify a segment for writing
|
||||
jmpe=jump to ia-64 instruction set
|
||||
sgdt=store global descriptor table register
|
||||
vmcall=call to vm monitor
|
||||
vmlaunch=launch virtual machine
|
||||
vmresume=resume virtual machine
|
||||
vmxoff=leave vmx operation
|
||||
sidt=store interrupt descriptor table register
|
||||
monitor=set up monitor address
|
||||
mwait=monitor wait
|
||||
lgdt=load global descriptor table register
|
||||
xgetbv=get value of extended control register
|
||||
xsetbv=set extended control register
|
||||
lidt=load interrupt descriptor table register
|
||||
smsw" => "lmsw=load machine status word
|
||||
invlpg=invalidate tlb entry
|
||||
swapgs=swap gs base register
|
||||
rdtscp=read time-stamp counter and processor id
|
||||
lar" => "lsl" => "loadall=load all of the cpu registers
|
||||
syscall=fast system call
|
||||
clts=clear task-switched flag in cr0
|
||||
loadall=load all of the cpu registers
|
||||
sysret=return from fast system call
|
||||
invd=invalidate internal caches
|
||||
wbinvd=write back and invalidate cache
|
||||
ud2=undefined instruction
|
||||
nop=no operation
|
||||
movups=move unaligned packed single-fp values
|
||||
movss=move scalar single-fp values
|
||||
movupd=move unaligned packed double-fp value
|
||||
movsd=move scalar double-fp value
|
||||
movups=move unaligned packed single-fp values
|
||||
movss=move scalar single-fp values
|
||||
movupd=move unaligned packed double-fp values
|
||||
movsd=move scalar double-fp value
|
||||
movhlps=move packed single-fp values high to low
|
||||
movlps=move low packed single-fp values
|
||||
movlpd=move low packed double-fp value
|
||||
movddup=move one double-fp and duplicate
|
||||
movsldup=move packed single-fp low and duplicate
|
||||
movlps=move low packed single-fp values
|
||||
movlpd=move low packed double-fp value
|
||||
unpcklps=unpack and interleave low packed single-fp values
|
||||
unpcklpd=unpack and interleave low packed double-fp values
|
||||
unpckhps=unpack and interleave high packed single-fp values
|
||||
unpckhpd=unpack and interleave high packed double-fp values
|
||||
movlhps=move packed single-fp values low to high
|
||||
movhps=move high packed single-fp values
|
||||
movhpd=move high packed double-fp value
|
||||
movshdup=move packed single-fp high and duplicate
|
||||
movhps=move high packed single-fp values
|
||||
movhpd=move high packed double-fp value
|
||||
hint_nop=hintable nop
|
||||
prefetchnta=prefetch data into caches
|
||||
prefetcht0=prefetch data into caches
|
||||
prefetcht1=prefetch data into caches
|
||||
prefetcht2=prefetch data into caches
|
||||
hint_nop=hintable nop
|
||||
nop=no operation
|
||||
hint_nop=hintable nop
|
||||
mov=move to/from control registers
|
||||
movaps=move aligned packed single-fp values
|
||||
movapd=move aligned packed double-fp values
|
||||
movaps=move aligned packed single-fp values
|
||||
movapd=move aligned packed double-fp values
|
||||
cvtpi2ps=convert packed dw integers to <!--1.11 packed -->single-fp values
|
||||
cvtsi2ss=convert dw integer to scalar single-fp value
|
||||
cvtpi2pd=convert packed dw integers to <!--1.11 packed -->double-fp values
|
||||
cvtsi2sd=convert dw integer to scalar double-fp value
|
||||
movntps=store packed single-fp values using non-temporal hint
|
||||
movntpd=store packed double-fp values using non-temporal hint
|
||||
cvttps2pi=convert with trunc. packed single-fp values to <!--1.11 packed -->dw integers
|
||||
cvttss2si=convert with trunc. scalar single-fp value to dw integer
|
||||
cvttpd2pi=convert with trunc. packed double-fp values to <!--1.11 packed -->dw integers
|
||||
cvttsd2si=conv. with trunc. scalar double-fp value to signed dw int
|
||||
cvtps2pi=convert packed single-fp values to <!--1.11 packed -->dw integers
|
||||
cvtss2si=convert scalar single-fp value to dw integer
|
||||
cvtpd2pi=convert packed double-fp values to <!--1.11 packed -->dw integers
|
||||
cvtsd2si=convert scalar double-fp value to dw integer
|
||||
ucomiss=unordered compare scalar single-fp values and set eflags
|
||||
ucomisd=unordered compare scalar double-fp values and set eflags
|
||||
comiss=compare scalar ordered single-fp values and set eflags
|
||||
comisd=compare scalar ordered double-fp values and set eflags
|
||||
wrmsr=write to model specific register
|
||||
rdtsc=read time-stamp counter
|
||||
rdmsr=read from model specific register
|
||||
rdpmc=read performance-monitoring counters
|
||||
sysenter=fast system call
|
||||
sysexit=fast return from fast system call
|
||||
getsec=getsec leaf functions
|
||||
pshufb=packed shuffle bytes
|
||||
phaddw=packed horizontal add
|
||||
phaddd=packed horizontal add
|
||||
phaddsw=packed horizontal add and saturate
|
||||
pmaddubsw=multiply and add packed signed and unsigned bytes
|
||||
phsubw=packed horizontal subtract
|
||||
phsubd=packed horizontal subtract
|
||||
phsubsw=packed horizontal subtract and saturate
|
||||
psignb=packed sign
|
||||
psignw=packed sign
|
||||
psignd=packed sign
|
||||
pmulhrsw=packed multiply high with round and scale
|
||||
pblendvb=variable blend packed bytes
|
||||
blendvps=variable blend packed single-fp values
|
||||
blendvpd=variable blend packed double-fp values
|
||||
ptest=logical compare
|
||||
pabsb=packed absolute value
|
||||
pabsw=packed absolute value
|
||||
pabsd=packed absolute value
|
||||
pmovsxbw" => "pmovsxbd" => "pmovsxbq" => "pmovsxwd" => "pmovsxwq" => "pmovsxdq" => "pmuldq=multiply packed signed dword integers
|
||||
pcmpeqq=compare packed qword data for equal
|
||||
movntdqa=load double quadword non-temporal aligned hint
|
||||
packusdw=pack with unsigned saturation
|
||||
pmovzxbw" => "pmovzxbd" => "pmovzxbq" => "pmovzxwd" => "pmovzxwq" => "pmovzxdq" => "pcmpgtq=compare packed qword data for greater than
|
||||
pminsb=minimum of packed signed byte integers
|
||||
pminsd=minimum of packed signed dword integers
|
||||
pminuw=minimum of packed unsigned word integers
|
||||
pminud=minimum of packed unsigned dword integers
|
||||
pmaxsb=maximum of packed signed byte integers
|
||||
pmaxsd=maximum of packed signed dword integers
|
||||
pmaxuw=maximum of packed unsigned word integers
|
||||
pmaxud=maximum of packed unsigned dword integers
|
||||
pmulld=multiply packed signed dword integers and store low result
|
||||
phminposuw=packed horizontal word minimum
|
||||
invept=invalidate translations derived from ept
|
||||
invvpid=invalidate translations based on vpid
|
||||
movbe=move data after swapping bytes
|
||||
crc32=accumulate crc32 value
|
||||
movbe=move data after swapping bytes
|
||||
crc32=accumulate crc32 value
|
||||
roundps=round packed single-fp values
|
||||
roundpd=round packed double-fp values
|
||||
roundss=round scalar single-fp values
|
||||
roundsd=round scalar double-fp values
|
||||
blendps=blend packed single-fp values
|
||||
blendpd=blend packed double-fp values
|
||||
pblendw=blend packed words
|
||||
palignr=packed align right
|
||||
pextrb" => "pextrw" => "pextrd=extract dword/qword
|
||||
extractps=extract packed single-fp value
|
||||
pinsrb" => "insertps" => "pinsrd=insert dword/qword
|
||||
dpps=dot product of packed single-fp values
|
||||
dppd=dot product of packed double-fp values
|
||||
mpsadbw=compute multiple packed sums of absolute difference
|
||||
pcmpestrm=packed compare explicit length strings, return mask
|
||||
pcmpestri=packed compare explicit length strings, return index
|
||||
pcmpistrm=packed compare implicit length strings, return mask
|
||||
pcmpistri=packed compare implicit length strings, return index
|
||||
cmovo=conditional move - overflow (of=1)
|
||||
cmovno=conditional move - not overflow (of=0)
|
||||
cmovb=conditional move - below/not above or equal/carry (cf=1)
|
||||
cmovnb=conditional move - not below/above or equal/not carry (cf=0)
|
||||
cmovz=conditional move - zero/equal (zf=0)
|
||||
cmovnz=conditional move - not zero/not equal (zf=1)
|
||||
cmovbe=conditional move - below or equal/not above (cf=1 and zf=1)
|
||||
cmovnbe=conditional move - not below or equal/above (cf=0 and zf=0)
|
||||
cmovs=conditional move - sign (sf=1)
|
||||
cmovns=conditional move - not sign (sf=0)
|
||||
cmovp=conditional move - parity/parity even (pf=1)
|
||||
cmovnp=conditional move - not parity/parity odd
|
||||
cmovl=conditional move - less/not greater (sf!=of)
|
||||
cmovnl=conditional move - not less/greater or equal (sf=of)
|
||||
cmovle=conditional move - less or equal/not greater ((zf=1) or (sf!=of))
|
||||
cmovnle=conditional move - not less nor equal/greater ((zf=0) and (sf=of))
|
||||
movmskps=extract packed single-fp sign mask
|
||||
movmskpd=extract packed double-fp sign mask
|
||||
sqrtps=compute square roots of packed single-fp values
|
||||
sqrtss=compute square root of scalar single-fp value
|
||||
sqrtpd=compute square roots of packed double-fp values
|
||||
sqrtsd=compute square root of scalar double-fp value
|
||||
rsqrtps=compute recipr. of square roots of packed single-fp values
|
||||
rsqrtss=compute recipr. of square root of scalar single-fp value
|
||||
rcpps=compute reciprocals of packed single-fp values
|
||||
rcpss=compute reciprocal of scalar single-fp values
|
||||
andps=bitwise logical and of packed single-fp values
|
||||
andpd=bitwise logical and of packed double-fp values
|
||||
andnps=bitwise logical and not of packed single-fp values
|
||||
andnpd=bitwise logical and not of packed double-fp values
|
||||
orps=bitwise logical or of single-fp values
|
||||
orpd=bitwise logical or of double-fp values
|
||||
xorps=bitwise logical xor for single-fp values
|
||||
xorpd=bitwise logical xor for double-fp values
|
||||
addps=add packed single-fp values
|
||||
addss=add scalar single-fp values
|
||||
addpd=add packed double-fp values
|
||||
addsd=add scalar double-fp values
|
||||
mulps=multiply packed single-fp values
|
||||
mulss=multiply scalar single-fp value
|
||||
mulpd=multiply packed double-fp values
|
||||
mulsd=multiply scalar double-fp values
|
||||
cvtps2pd=convert packed single-fp values to <!--1.11 packed -->double-fp values
|
||||
cvtpd2ps=convert packed double-fp values to <!--1.11 packed -->single-fp values
|
||||
cvtss2sd=convert scalar single-fp value to scalar double-fp value
|
||||
cvtsd2ss=convert scalar double-fp value to scalar single-fp value
|
||||
cvtdq2ps=convert packed dw integers to <!--1.11 packed -->single-fp values
|
||||
cvtps2dq=convert packed single-fp values to <!--1.11 packed -->dw integers
|
||||
cvttps2dq=convert with trunc. packed single-fp values to <!--1.11 packed -->dw integers
|
||||
subps=subtract packed single-fp values
|
||||
subss=subtract scalar single-fp values
|
||||
subpd=subtract packed double-fp values
|
||||
subsd=subtract scalar double-fp values
|
||||
minps=return minimum packed single-fp values
|
||||
minss=return minimum scalar single-fp value
|
||||
minpd=return minimum packed double-fp values
|
||||
minsd=return minimum scalar double-fp value
|
||||
divps=divide packed single-fp values
|
||||
divss=divide scalar single-fp values
|
||||
divpd=divide packed double-fp values
|
||||
divsd=divide scalar double-fp values
|
||||
maxps=return maximum packed single-fp values
|
||||
maxss=return maximum scalar single-fp value
|
||||
maxpd=return maximum packed double-fp values
|
||||
maxsd=return maximum scalar double-fp value
|
||||
punpcklbw=unpack low data
|
||||
punpcklwd=unpack low data
|
||||
punpckldq=unpack low data
|
||||
packsswb=pack with signed saturation
|
||||
pcmpgtb=compare packed signed integers for greater than
|
||||
pcmpgtw=compare packed signed integers for greater than
|
||||
pcmpgtd=compare packed signed integers for greater than
|
||||
packuswb=pack with unsigned saturation
|
||||
punpckhbw=unpack high data
|
||||
punpckhwd=unpack high data
|
||||
punpckhdq=unpack high data
|
||||
packssdw=pack with signed saturation
|
||||
punpcklqdq=unpack low data
|
||||
punpckhqdq=unpack high data
|
||||
movd=move doubleword
|
||||
movq=move doubleword/quadword
|
||||
movd=move doubleword
|
||||
movq=move doubleword/quadword
|
||||
movdqa=move aligned double quadword
|
||||
movdqu=move unaligned double quadword
|
||||
pshufw=shuffle packed words
|
||||
pshuflw=shuffle packed low words
|
||||
pshufhw=shuffle packed high words
|
||||
pshufd=shuffle packed doublewords
|
||||
psrlw=shift packed data right logical
|
||||
psraw=shift packed data right arithmetic
|
||||
psllw=shift packed data left logical
|
||||
psrld=shift double quadword right logical
|
||||
psrad=shift packed data right arithmetic
|
||||
pslld=shift packed data left logical
|
||||
psrlq=shift packed data right logical
|
||||
psrldq=shift double quadword right logical
|
||||
psllq=shift packed data left logical
|
||||
pslldq=shift double quadword left logical
|
||||
pcmpeqb=compare packed data for equal
|
||||
pcmpeqw=compare packed data for equal
|
||||
pcmpeqd=compare packed data for equal
|
||||
emms=empty mmx technology state
|
||||
vmread=read field from virtual-machine control structure
|
||||
vmwrite=write field to virtual-machine control structure
|
||||
haddpd=packed double-fp horizontal add
|
||||
haddps=packed single-fp horizontal add
|
||||
hsubpd=packed double-fp horizontal subtract
|
||||
hsubps=packed single-fp horizontal subtract
|
||||
movd=move doubleword
|
||||
movq=move doubleword/quadword
|
||||
movd=move doubleword
|
||||
movq=move doubleword/quadword
|
||||
movdqa=move aligned double quadword
|
||||
movdqu=move unaligned double quadword
|
||||
jo=jump short if overflow (of=1)
|
||||
jno=jump short if not overflow (of=0)
|
||||
jb=jump short if below/not above or equal/carry (cf=1)
|
||||
jnb=jump short if not below/above or equal/not carry (cf=0)
|
||||
jz=jump short if zero/equal (zf=0)
|
||||
jnz=jump short if not zero/not equal (zf=1)
|
||||
jbe=jump short if below or equal/not above (cf=1 and zf=1)
|
||||
jnbe=jump short if not below or equal/above (cf=0 and zf=0)
|
||||
js=jump short if sign (sf=1)
|
||||
jns=jump short if not sign (sf=0)
|
||||
jp=jump short if parity/parity even (pf=1)
|
||||
jnp=jump short if not parity/parity odd
|
||||
jl=jump short if less/not greater (sf!=of)
|
||||
jnl=jump short if not less/greater or equal (sf=of)
|
||||
jle=jump short if less or equal/not greater ((zf=1) or (sf!=of))
|
||||
jnle=jump short if not less nor equal/greater ((zf=0) and (sf=of))
|
||||
seto=set byte on condition - overflow (of=1)
|
||||
setno=set byte on condition - not overflow (of=0)
|
||||
setb=set byte on condition - below/not above or equal/carry (cf=1)
|
||||
setnb=set byte on condition - not below/above or equal/not carry (cf=0)
|
||||
setz=set byte on condition - zero/equal (zf=0)
|
||||
setnz=set byte on condition - not zero/not equal (zf=1)
|
||||
setbe=set byte on condition - below or equal/not above (cf=1 and zf=1)
|
||||
setnbe=set byte on condition - not below or equal/above (cf=0 and zf=0)
|
||||
sets=set byte on condition - sign (sf=1)
|
||||
setns=set byte on condition - not sign (sf=0)
|
||||
setp=set byte on condition - parity/parity even (pf=1)
|
||||
setnp=set byte on condition - not parity/parity odd
|
||||
setl=set byte on condition - less/not greater (sf!=of)
|
||||
setnl=set byte on condition - not less/greater or equal (sf=of)
|
||||
setle=set byte on condition - less or equal/not greater ((zf=1) or (sf!=of))
|
||||
setnle=set byte on condition - not less nor equal/greater ((zf=0) and (sf=of))
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
cpuid=cpu identification
|
||||
bt=bit test
|
||||
shld=double precision shift left
|
||||
push=push word, doubleword or quadword onto the stack
|
||||
pop=pop a value from the stack
|
||||
rsm=resume from system management mode
|
||||
bts=bit test and set
|
||||
shrd=double precision shift right
|
||||
fxsave=save x87 fpu, mmx, xmm, and mxcsr state
|
||||
fxrstor=restore x87 fpu, mmx, xmm, and mxcsr state
|
||||
ldmxcsr=load mxcsr register
|
||||
stmxcsr=store mxcsr register state
|
||||
xsave=save processor extended states
|
||||
lfence=load fence
|
||||
xrstor=restore processor extended states
|
||||
mfence=memory fence
|
||||
sfence=store fence
|
||||
clflush=flush cache line
|
||||
imul=signed multiply
|
||||
cmpxchg=compare and exchange
|
||||
lss=load far pointer
|
||||
btr=bit test and reset
|
||||
lfs=load far pointer
|
||||
lgs=load far pointer
|
||||
movzx=move with zero-extend
|
||||
jmpe=jump to ia-64 instruction set
|
||||
popcnt=bit population count
|
||||
bt=bit test
|
||||
bts=bit test and set
|
||||
btr=bit test and reset
|
||||
btc=bit test and complement
|
||||
bsf=bit scan forward
|
||||
bsr=bit scan reverse
|
||||
movsx=move with sign-extension
|
||||
xadd=exchange and add
|
||||
cmpps=compare packed single-fp values
|
||||
cmpss=compare scalar single-fp values
|
||||
cmppd=compare packed double-fp values
|
||||
cmpsd=compare scalar double-fp values
|
||||
movnti=store doubleword using non-temporal hint
|
||||
pinsrw" => "pextrw=extract word
|
||||
shufps=shuffle packed single-fp values
|
||||
shufpd=shuffle packed double-fp values
|
||||
cmpxchg8b=compare and exchange bytes
|
||||
cmpxchg16b=compare and exchange bytes
|
||||
vmptrld=load pointer to virtual-machine control structure
|
||||
vmclear=clear virtual-machine control structure
|
||||
vmxon=enter vmx operation
|
||||
vmptrst=store pointer to virtual-machine control structure
|
||||
bswap=byte swap
|
||||
addsubpd=packed double-fp add/subtract
|
||||
addsubps=packed single-fp add/subtract
|
||||
psrlw=shift packed data right logical
|
||||
psrld=shift packed data right logical
|
||||
psrlq=shift packed data right logical
|
||||
paddq=add packed quadword integers
|
||||
pmullw=multiply packed signed integers and store low result
|
||||
movq=move quadword
|
||||
movq2dq=move quadword from mmx technology to xmm register
|
||||
movdq2q=move quadword from xmm to mmx technology register
|
||||
pmovmskb=move byte mask
|
||||
psubusb=subtract packed unsigned integers with unsigned saturation
|
||||
psubusw=subtract packed unsigned integers with unsigned saturation
|
||||
pminub=minimum of packed unsigned byte integers
|
||||
pand=logical and
|
||||
paddusb=add packed unsigned integers with unsigned saturation
|
||||
paddusw=add packed unsigned integers with unsigned saturation
|
||||
pmaxub=maximum of packed unsigned byte integers
|
||||
pandn=logical and not
|
||||
pavgb=average packed integers
|
||||
psraw=shift packed data right arithmetic
|
||||
psrad=shift packed data right arithmetic
|
||||
pavgw=average packed integers
|
||||
pmulhuw=multiply packed unsigned integers and store high result
|
||||
pmulhw=multiply packed signed integers and store high result
|
||||
cvtpd2dq=convert packed double-fp values to <!--1.11 packed -->dw integers
|
||||
cvttpd2dq=convert with trunc. packed double-fp values to <!--1.11 packed -->dw integers
|
||||
cvtdq2pd=convert packed dw integers to <!--1.11 packed -->double-fp values
|
||||
movntq=store of quadword using non-temporal hint
|
||||
movntdq=store double quadword using non-temporal hint
|
||||
psubsb=subtract packed signed integers with signed saturation
|
||||
psubsw=subtract packed signed integers with signed saturation
|
||||
pminsw=minimum of packed signed word integers
|
||||
por=bitwise logical or
|
||||
paddsb=add packed signed integers with signed saturation
|
||||
paddsw=add packed signed integers with signed saturation
|
||||
pmaxsw=maximum of packed signed word integers
|
||||
pxor=logical exclusive or
|
||||
lddqu=load unaligned integer 128 bits
|
||||
psllw=shift packed data left logical
|
||||
pslld=shift packed data left logical
|
||||
psllq=shift packed data left logical
|
||||
pmuludq=multiply packed unsigned dw integers
|
||||
pmaddwd=multiply and add packed integers
|
||||
psadbw=compute sum of absolute differences
|
||||
maskmovq=store selected bytes of quadword
|
||||
maskmovdqu=store selected bytes of double quadword
|
||||
psubb=subtract packed integers
|
||||
psubw=subtract packed integers
|
||||
psubd=subtract packed integers
|
||||
psubq=subtract packed quadword integers
|
||||
paddb=add packed integers
|
||||
paddw=add packed integers
|
||||
paddd=add packed integers
|
||||
movzx=move dst register size padding with zeroes
|
||||
sar=arithmetic right shift
|
||||
sal=arithmetic left shift
|
||||
shl=logic left shift (0 padding)
|
||||
shr=logic right shift (0 padding)
|
||||
inc=register++
|
||||
dec=register--
|
||||
xlat=al = [ebx+al]
|
||||
lahf=AH = SF:ZF:X:AF:X:PF:X:CF
|
||||
sahf=eflags(SF:ZF:X:AF:X:PF:X:CF) = AX
|
||||
lea=load efective address
|
||||
rol=rotate bits left
|
||||
ror=rotate bits right
|
||||
rcl=rotate bits left (with CF)
|
||||
rcr=rotate bits right (with CF)
|
||||
add=adds src and dst, stores result on dst
|
||||
and=binary and operation between src and dst, stores result on dst
|
||||
xor=exclusive or x^=y (x86) or x = y ^ z (arm)
|
||||
sub=substract src and dst, stores result on dst
|
||||
jmp=changes eip to another position
|
||||
call"=> "calls a subroutine, pushes eip into stack (esp)
|
||||
push"=> "pushes the argument to stack (esp)
|
||||
pop=pops last element of stack and stores the result in argument
|
||||
mov=moves data from src to dst
|
||||
nop=does nothing (nop [eax] (0F 1X XX) performs a memory read and nops)
|
||||
movsb=ES:[edi] = (byte)DS:[esi] (esi++, edi++)
|
||||
movsw=ES:[edi] = (word)DS:[esi] (esi+=2, edi+=2)
|
||||
movsd=ES:[edi] = (dword)DS:[esi] (esi+=4, edi+=4)
|
||||
lodsb=al = (byte)DS:[esi] (esi++)
|
||||
lodsw=ax = (word)DS:[esi] (esi+=2)
|
||||
stosb=ES:[edi] = al (edi++)
|
||||
cmpsb=cmp DS:[SI], ES:[edi] (esi++, edi++)
|
||||
scasb=cmp al, ES:[edi++]
|
||||
scasw=cmp ax, ES:[edi+=2]
|
||||
rep=repeats next instruction ECX times
|
||||
ret=return from subroutine. pop 4 bytes from esp and jump there.
|
||||
enter=alias for push ebp mov ebp, esp
|
||||
leave=one byte alias for mov esp, ebp ; pop ebp
|
||||
clc=eflags[CF] = 0
|
||||
stc=eflags[CF] = 1
|
||||
cld=elfags[DF] = 0
|
||||
std=elfags[DF] = 1
|
||||
cli=elfags[IF] = 0
|
||||
sti=elfags[IF] = 1
|
||||
hlt=stop process until external interrupt received
|
||||
wait"=> "stop process execution until TEST pin activated
|
||||
lock=instruction prefix to setup the LOCK pin
|
||||
retn=ret* to the same code segment
|
||||
retf=ret* to other code segment
|
||||
test=set eflags after comparing two registers (AF, CF, OF, PF, SF, ZF)
|
||||
jcxz=Jump if ecx = 0
|
||||
loop=if (ecx-- == 0) jmp ..
|
||||
loopz=if (ecx-- == 0 && eflags[ZF] == 1) jmp ..
|
||||
into=interrupt if eflags[OF]=1
|
||||
iret=return from interrupt
|
||||
fdiv=floating divide
|
||||
fdivp=floating divide and pop
|
||||
fdivr=floating divide reversed
|
||||
fdivrp=floating divide reversed and pop
|
||||
fidiv=integer divide
|
||||
fidivr=integer divide reserved
|
||||
feni=enable interrupts
|
||||
fneni=enable interrupts, no wait
|
||||
ffree=free register
|
||||
fiadd=integer add
|
||||
ficom=integer compare
|
||||
ficomp=integer compare and pop
|
||||
fild=load integer
|
||||
fimul=integer multiply
|
||||
fabs=absolute value
|
||||
fadd=floating point add
|
||||
faddp=floating point add and pop
|
||||
fbld=load bcd
|
||||
fbstp=store bcd and pop
|
||||
fchs=change sign
|
||||
fclex=clear exceptions
|
||||
fnclex=clear exceptions, no wait
|
||||
fcom=floating point compare
|
||||
fcomp=floating point compare and pop
|
||||
fcompp=floating point compare and pop twice
|
||||
fcos=floating point cosine
|
||||
finit=initialize fpu
|
||||
fninit=initialize fpu, no wait
|
||||
fist=store integer
|
||||
fistp=store integer and pop
|
||||
fisub=integer substract
|
||||
fisubr=integer susbtract reversed
|
||||
fld=floatint point load
|
||||
fldz=load constant onto stack 0.0f
|
||||
fld1=load constant onto stack 1.0f
|
||||
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, 3.14159..
|
||||
fldcw=load control word
|
||||
fldenv=load environment state
|
||||
fmul=floating point multiply
|
||||
fmulp=floating point multiply and pop
|
||||
fnop=no operation
|
||||
fincstp=increment floating point stack pointer (%foo)
|
||||
fdecstp=decrement floating point stack pointer (%foo)
|
||||
fdisi=disable interrupts
|
||||
fndisi=disable interrupts, no wait
|
||||
Loading…
x
Reference in New Issue
Block a user