You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
562 lines
12 KiB
562 lines
12 KiB
bits 64
|
|
|
|
; Arithemtic.
|
|
add al, bl
|
|
add al, sil
|
|
add al, [rbx]
|
|
add [ebx], al
|
|
add al, [ebx]
|
|
add [ebx], al
|
|
add al, 0x10
|
|
add ax, bx
|
|
add ax, r11w
|
|
add ax, [rbx]
|
|
add [ebx], ax
|
|
add ax, [ebx]
|
|
add [ebx], ax
|
|
add ax, 0x1000
|
|
add eax, ebx
|
|
add eax, r11d
|
|
add eax, [rbx]
|
|
add [rbx], eax
|
|
add eax, [ebx]
|
|
add [ebx], eax
|
|
add eax, 0x10000000
|
|
add rax, rbx
|
|
add rax, r11
|
|
add rax, [rbx]
|
|
add [rbx], rax
|
|
add rax, [ebx]
|
|
add [ebx], rax
|
|
add rax, 0x10000000
|
|
|
|
sub al, bl
|
|
sub al, sil
|
|
sub al, [rbx]
|
|
sub [ebx], al
|
|
sub al, [ebx]
|
|
sub [ebx], al
|
|
sub al, 0x10
|
|
sub ax, bx
|
|
sub ax, r11w
|
|
sub ax, [rbx]
|
|
sub [ebx], ax
|
|
sub ax, [ebx]
|
|
sub [ebx], ax
|
|
sub ax, 0x1000
|
|
sub eax, ebx
|
|
sub eax, r11d
|
|
sub eax, [rbx]
|
|
sub [rbx], eax
|
|
sub eax, [ebx]
|
|
sub [ebx], eax
|
|
sub eax, 0x10000000
|
|
sub rax, rbx
|
|
sub rax, r11
|
|
sub rax, [rbx]
|
|
sub [rbx], rax
|
|
sub rax, [ebx]
|
|
sub [ebx], rax
|
|
sub rax, 0x10000000
|
|
|
|
adc al, bl
|
|
adc al, sil
|
|
adc al, [rbx]
|
|
adc [ebx], al
|
|
adc al, [ebx]
|
|
adc [ebx], al
|
|
adc al, 0x10
|
|
adc ax, bx
|
|
adc ax, r11w
|
|
adc ax, [rbx]
|
|
adc [ebx], ax
|
|
adc ax, [ebx]
|
|
adc [ebx], ax
|
|
adc ax, 0x1000
|
|
adc eax, ebx
|
|
adc eax, r11d
|
|
adc eax, [rbx]
|
|
adc [rbx], eax
|
|
adc eax, [ebx]
|
|
adc [ebx], eax
|
|
adc eax, 0x10000000
|
|
adc rax, rbx
|
|
adc rax, r11
|
|
adc rax, [rbx]
|
|
adc [rbx], rax
|
|
adc rax, [ebx]
|
|
adc [ebx], rax
|
|
adc rax, 0x10000000
|
|
|
|
sbb al, bl
|
|
sbb al, sil
|
|
sbb al, [rbx]
|
|
sbb [ebx], al
|
|
sbb al, [ebx]
|
|
sbb [ebx], al
|
|
sbb al, 0x10
|
|
sbb ax, bx
|
|
sbb ax, r11w
|
|
sbb ax, [rbx]
|
|
sbb [ebx], ax
|
|
sbb ax, [ebx]
|
|
sbb [ebx], ax
|
|
sbb ax, 0x1000
|
|
sbb eax, ebx
|
|
sbb eax, r11d
|
|
sbb eax, [rbx]
|
|
sbb [rbx], eax
|
|
sbb eax, [ebx]
|
|
sbb [ebx], eax
|
|
sbb eax, 0x10000000
|
|
sbb rax, rbx
|
|
sbb rax, r11
|
|
sbb rax, [rbx]
|
|
sbb [rbx], rax
|
|
sbb rax, [ebx]
|
|
sbb [ebx], rax
|
|
sbb rax, 0x10000000
|
|
|
|
and al, bl
|
|
and al, sil
|
|
and al, [rbx]
|
|
and [ebx], al
|
|
and al, [ebx]
|
|
and [ebx], al
|
|
and al, 0x10
|
|
and ax, bx
|
|
and ax, r11w
|
|
and ax, [rbx]
|
|
and [ebx], ax
|
|
and ax, [ebx]
|
|
and [ebx], ax
|
|
and ax, 0x1000
|
|
and eax, ebx
|
|
and eax, r11d
|
|
and eax, [rbx]
|
|
and [rbx], eax
|
|
and eax, [ebx]
|
|
and [ebx], eax
|
|
and eax, 0x10000000
|
|
and rax, rbx
|
|
and rax, r11
|
|
and rax, [rbx]
|
|
and [rbx], rax
|
|
and rax, [ebx]
|
|
and [ebx], rax
|
|
and rax, 0x10000000
|
|
|
|
or al, bl
|
|
or al, sil
|
|
or al, [rbx]
|
|
or [ebx], al
|
|
or al, [ebx]
|
|
or [ebx], al
|
|
or al, 0x10
|
|
or ax, bx
|
|
or ax, r11w
|
|
or ax, [rbx]
|
|
or [ebx], ax
|
|
or ax, [ebx]
|
|
or [ebx], ax
|
|
or ax, 0x1000
|
|
or eax, ebx
|
|
or eax, r11d
|
|
or eax, [rbx]
|
|
or [rbx], eax
|
|
or eax, [ebx]
|
|
or [ebx], eax
|
|
or eax, 0x10000000
|
|
or rax, rbx
|
|
or rax, r11
|
|
or rax, [rbx]
|
|
or [rbx], rax
|
|
or rax, [ebx]
|
|
or [ebx], rax
|
|
or rax, 0x10000000
|
|
|
|
xor al, bl
|
|
xor al, sil
|
|
xor al, [rbx]
|
|
xor [ebx], al
|
|
xor al, [ebx]
|
|
xor [ebx], al
|
|
xor al, 0x10
|
|
xor ax, bx
|
|
xor ax, r11w
|
|
xor ax, [rbx]
|
|
xor [ebx], ax
|
|
xor ax, [ebx]
|
|
xor [ebx], ax
|
|
xor ax, 0x1000
|
|
xor eax, ebx
|
|
xor eax, r11d
|
|
xor eax, [rbx]
|
|
xor [rbx], eax
|
|
xor eax, [ebx]
|
|
xor [ebx], eax
|
|
xor eax, 0x10000000
|
|
xor rax, rbx
|
|
xor rax, r11
|
|
xor rax, [rbx]
|
|
xor [rbx], rax
|
|
xor rax, [ebx]
|
|
xor [ebx], rax
|
|
xor rax, 0x10000000
|
|
|
|
cmp al, bl
|
|
cmp al, sil
|
|
cmp al, [rbx]
|
|
cmp [ebx], al
|
|
cmp al, [ebx]
|
|
cmp [ebx], al
|
|
cmp al, 0x10
|
|
cmp ax, bx
|
|
cmp ax, r11w
|
|
cmp ax, [rbx]
|
|
cmp [ebx], ax
|
|
cmp ax, [ebx]
|
|
cmp [ebx], ax
|
|
cmp ax, 0x1000
|
|
cmp eax, ebx
|
|
cmp eax, r11d
|
|
cmp eax, [rbx]
|
|
cmp [rbx], eax
|
|
cmp eax, [ebx]
|
|
cmp [ebx], eax
|
|
cmp eax, 0x10000000
|
|
cmp rax, rbx
|
|
cmp rax, r11
|
|
cmp rax, [rbx]
|
|
cmp [rbx], rax
|
|
cmp rax, [ebx]
|
|
cmp [ebx], rax
|
|
cmp rax, 0x10000000
|
|
|
|
test eax, 1
|
|
test rax, 1
|
|
test eax, r14d
|
|
test rax, r14
|
|
test byte [rbx], 1
|
|
test word [rbx], 1
|
|
test dword [rbx], 1
|
|
test qword [rbx], 1
|
|
test byte [rbx], al
|
|
test word [rbx], ax
|
|
test dword [rbx], eax
|
|
test qword [rbx], rax
|
|
|
|
|
|
; Data transfer.
|
|
mov al, byte 0xBD
|
|
mov ax, word 0xBDBD
|
|
mov eax, dword 0xBDBDBDBD
|
|
mov rax, qword 0xBDBDBDBDBDBDBDBD
|
|
mov al, [qword 0xBDBDBDBDBDBDBDBD]
|
|
mov ax, [qword 0xBDBDBDBDBDBDBDBD]
|
|
mov eax, [qword 0xBDBDBDBDBDBDBDBD]
|
|
mov rax, [qword 0xBDBDBDBDBDBDBDBD]
|
|
mov [qword 0xBDBDBDBDBDBDBDBD], al
|
|
mov [qword 0xBDBDBDBDBDBDBDBD], ax
|
|
mov [qword 0xBDBDBDBDBDBDBDBD], eax
|
|
mov [qword 0xBDBDBDBDBDBDBDBD], rax
|
|
|
|
xlatb
|
|
xchg al, cl
|
|
xchg ax, cx
|
|
xchg eax, ecx
|
|
xchg rax, rcx
|
|
xchg rax, [rbx]
|
|
xchg rax, [ebx]
|
|
|
|
; Unary opcodes.
|
|
inc al
|
|
inc r15b
|
|
inc ax
|
|
inc r15w
|
|
inc eax
|
|
inc r15d
|
|
inc rax
|
|
inc r15
|
|
inc byte [rbx]
|
|
inc word [rbx]
|
|
inc dword [rbx]
|
|
inc qword [rbx]
|
|
|
|
dec al
|
|
dec r15b
|
|
dec ax
|
|
dec r15w
|
|
dec eax
|
|
dec r15d
|
|
dec rax
|
|
dec r15
|
|
dec byte [rbx]
|
|
dec word [rbx]
|
|
dec dword [rbx]
|
|
dec qword [rbx]
|
|
|
|
not al
|
|
not r15b
|
|
not ax
|
|
not r15w
|
|
not eax
|
|
not r15d
|
|
not rax
|
|
not r15
|
|
not byte [rbx]
|
|
not word [rbx]
|
|
not dword [rbx]
|
|
not qword [rbx]
|
|
|
|
neg al
|
|
neg r15b
|
|
neg ax
|
|
neg r15w
|
|
neg eax
|
|
neg r15d
|
|
neg rax
|
|
neg r15
|
|
neg byte [rbx]
|
|
neg word [rbx]
|
|
neg dword [rbx]
|
|
neg qword [rbx]
|
|
|
|
div al
|
|
div r15b
|
|
div ax
|
|
div r15w
|
|
div eax
|
|
div r15d
|
|
div rax
|
|
div r15
|
|
div byte [rbx]
|
|
div word [rbx]
|
|
div dword [rbx]
|
|
div qword [rbx]
|
|
|
|
mul al
|
|
mul r15b
|
|
mul ax
|
|
mul r15w
|
|
mul eax
|
|
mul r15d
|
|
mul rax
|
|
mul r15
|
|
mul byte [rbx]
|
|
mul word [rbx]
|
|
mul dword [rbx]
|
|
mul qword [rbx]
|
|
|
|
idiv al
|
|
idiv r15b
|
|
idiv ax
|
|
idiv r15w
|
|
idiv eax
|
|
idiv r15d
|
|
idiv rax
|
|
idiv r15
|
|
idiv byte [rbx]
|
|
idiv word [rbx]
|
|
idiv dword [rbx]
|
|
idiv qword [rbx]
|
|
|
|
imul al
|
|
imul r15b
|
|
imul ax
|
|
imul r15w
|
|
imul eax
|
|
imul r15d
|
|
imul rax
|
|
imul r15
|
|
imul byte [rbx]
|
|
imul word [rbx]
|
|
imul dword [rbx]
|
|
imul qword [rbx]
|
|
|
|
; Shift/rotate
|
|
rol al, 1
|
|
rol al, 100
|
|
rol al, cl
|
|
rol byte [rbx], 1
|
|
rol byte [rbx], cl
|
|
rol ax, 1
|
|
rol ax, 100
|
|
rol ax, cl
|
|
rol word [rbx], 1
|
|
rol word [rbx], 100
|
|
rol word [rbx], cl
|
|
rol dword [rbx], 1
|
|
rol dword [rbx], 100
|
|
rol dword [rbx], cl
|
|
rol qword [rbx], 1
|
|
rol qword [rbx], 100
|
|
rol qword [rbx], cl
|
|
|
|
ror al, 1
|
|
ror al, 100
|
|
ror al, cl
|
|
ror byte [rbx], 1
|
|
ror byte [rbx], cl
|
|
ror ax, 1
|
|
ror ax, 100
|
|
ror ax, cl
|
|
ror word [rbx], 1
|
|
ror word [rbx], 100
|
|
ror word [rbx], cl
|
|
ror dword [rbx], 1
|
|
ror dword [rbx], 100
|
|
ror dword [rbx], cl
|
|
ror qword [rbx], 1
|
|
ror qword [rbx], 100
|
|
ror qword [rbx], cl
|
|
|
|
rcl al, 1
|
|
rcl al, 100
|
|
rcl al, cl
|
|
rcl byte [rbx], 1
|
|
rcl byte [rbx], cl
|
|
rcl ax, 1
|
|
rcl ax, 100
|
|
rcl ax, cl
|
|
rcl word [rbx], 1
|
|
rcl word [rbx], 100
|
|
rcl word [rbx], cl
|
|
rcl dword [rbx], 1
|
|
rcl dword [rbx], 100
|
|
rcl dword [rbx], cl
|
|
rcl qword [rbx], 1
|
|
rcl qword [rbx], 100
|
|
rcl qword [rbx], cl
|
|
|
|
rcr al, 1
|
|
rcr al, 100
|
|
rcr al, cl
|
|
rcr byte [rbx], 1
|
|
rcr byte [rbx], cl
|
|
rcr ax, 1
|
|
rcr ax, 100
|
|
rcr ax, cl
|
|
rcr word [rbx], 1
|
|
rcr word [rbx], 100
|
|
rcr word [rbx], cl
|
|
rcr dword [rbx], 1
|
|
rcr dword [rbx], 100
|
|
rcr dword [rbx], cl
|
|
rcr qword [rbx], 1
|
|
rcr qword [rbx], 100
|
|
rcr qword [rbx], cl
|
|
|
|
shl al, 1
|
|
shl al, 100
|
|
shl al, cl
|
|
shl byte [rbx], 1
|
|
shl byte [rbx], cl
|
|
shl ax, 1
|
|
shl ax, 100
|
|
shl ax, cl
|
|
shl word [rbx], 1
|
|
shl word [rbx], 100
|
|
shl word [rbx], cl
|
|
shl dword [rbx], 1
|
|
shl dword [rbx], 100
|
|
shl dword [rbx], cl
|
|
shl qword [rbx], 1
|
|
shl qword [rbx], 100
|
|
shl qword [rbx], cl
|
|
|
|
shr al, 1
|
|
shr al, 100
|
|
shr al, cl
|
|
shr byte [rbx], 1
|
|
shr byte [rbx], cl
|
|
shr ax, 1
|
|
shr ax, 100
|
|
shr ax, cl
|
|
shr word [rbx], 1
|
|
shr word [rbx], 100
|
|
shr word [rbx], cl
|
|
shr dword [rbx], 1
|
|
shr dword [rbx], 100
|
|
shr dword [rbx], cl
|
|
shr qword [rbx], 1
|
|
shr qword [rbx], 100
|
|
shr qword [rbx], cl
|
|
|
|
sar al, 1
|
|
sar al, 100
|
|
sar al, cl
|
|
sar byte [rbx], 1
|
|
sar byte [rbx], cl
|
|
sar ax, 1
|
|
sar ax, 100
|
|
sar ax, cl
|
|
sar word [rbx], 1
|
|
sar word [rbx], 100
|
|
sar word [rbx], cl
|
|
sar dword [rbx], 1
|
|
sar dword [rbx], 100
|
|
sar dword [rbx], cl
|
|
sar qword [rbx], 1
|
|
sar qword [rbx], 100
|
|
sar qword [rbx], cl
|
|
|
|
; imul with 3 operands
|
|
imul ax, cx, 100
|
|
imul ax, [rbx], 100
|
|
imul eax, ecx, 100
|
|
imul eax, [rbx], 100
|
|
imul rax, rcx, 100
|
|
imul rax, [rbx], 100
|
|
|
|
; String
|
|
movsb
|
|
movsw
|
|
movsd
|
|
movsq
|
|
stosb
|
|
stosw
|
|
stosd
|
|
stosq
|
|
lodsb
|
|
lodsw
|
|
lodsd
|
|
lodsq
|
|
scasb
|
|
scasw
|
|
scasd
|
|
scasq
|
|
cmpsb
|
|
cmpsb
|
|
cmpsw
|
|
cmpsd
|
|
cmpsq
|
|
|
|
; I/O
|
|
insb
|
|
insw
|
|
insd
|
|
outsb
|
|
outsw
|
|
outsd
|
|
|
|
in al, 0x10
|
|
in ax, 0x10
|
|
in al, dx
|
|
in ax, dx
|
|
out 0x10, al
|
|
out 0x10, ax
|
|
out dx, al
|
|
out dx, ax
|
|
|
|
|
|
; Prefixes.
|
|
lock add qword [rdi + 0x1000], 1
|
|
lock xacquire add dword [rax], 1
|
|
lock xrelease sub qword [rsi + rdi * 8 - 0x1000], 2
|
|
xrelease mov byte [rbp + 0x1000], spl
|
|
|
|
rep stosb
|
|
rep lodsb
|
|
repnz scasw
|
|
repz cmpsq |