517 lines
11 KiB
Plaintext
517 lines
11 KiB
Plaintext
jmp near dword [0]
|
|
jmp far dword [0]
|
|
|
|
mov bx,ax ; general register to general register
|
|
mov [char],al ; general register to memory
|
|
mov dl,32 ; immediate value to general register
|
|
mov cr3,ebx ; general register to control register
|
|
|
|
xchg ax,bx ; swap two general registers
|
|
xchg al,[char] ; swap register with memory
|
|
|
|
push ax ; store general register
|
|
push es ; store segment register
|
|
pushw [bx] ; store memory
|
|
push 1000h ; store immediate value
|
|
|
|
imul ax,[si],10 ; memory by immediate value to register
|
|
|
|
bt ax,15 ; test bit in register
|
|
bts word [bx],15 ; test and set bit in memory
|
|
|
|
bswap edx ; swap bytes in register
|
|
|
|
jmp 100h ; direct near jump
|
|
jmp 0FFFFh:0 ; direct far jump
|
|
jmp ax ; indirect near jump
|
|
jmp pword [ebx] ; indirect far jump
|
|
|
|
movs byte [di],[si] ; transfer byte
|
|
movs word [es:di],[ss:si] ; transfer word
|
|
movsd ; transfer double word
|
|
|
|
cmpxchg8b [bx] ; compare and exchange 8 bytes
|
|
|
|
movq2dq xmm0,mm1 ; move from MMX register to SSE register
|
|
movdq2q mm0,xmm1 ; move from SSE register to MMX register
|
|
|
|
enter 2048,0 ; enter and allocate 2048 bytes on stack
|
|
|
|
mov [rip+3],sil ; manual RIP-relative addressing
|
|
|
|
blendvps xmm3,xmm7,xmm0 ; blend according to mask
|
|
vgatherqps xmm0,[xmm2],xmm3 ; gather two floats
|
|
vgatherqps xmm0,[ymm2+64],xmm3 ; gather four floats
|
|
vfmsub231ps ymm1,ymm2,ymm3 ; multiply and subtract
|
|
vfnmadd132sd xmm0,xmm5,[ebx] ; multiply, negate and add
|
|
vpermil2ps ymm0,ymm3,ymm7,ymm2,0 ; permute from two sources
|
|
|
|
vscatterdps [eax+xmm1]{k1},xmm0 ; scatter four floats
|
|
vscatterdpd [ymm3*8]{k3},zmm0 ; scatter eight doubles
|
|
|
|
dd sum
|
|
x = 1
|
|
x = x+2
|
|
sum = x
|
|
|
|
|
|
if count>0
|
|
mov cx,count
|
|
rep movsb
|
|
end if
|
|
|
|
|
|
if count & ~ count mod 4
|
|
mov cx,count/4
|
|
rep movsd
|
|
else if count>4
|
|
mov cx,count/4
|
|
rep movsd
|
|
mov cx,count mod 4
|
|
rep movsb
|
|
else
|
|
mov cx,count
|
|
rep movsb
|
|
end if
|
|
|
|
repeat 8
|
|
mov byte [bx],%
|
|
inc bx
|
|
end repeat
|
|
|
|
|
|
s = x/2
|
|
repeat 100
|
|
if x/s = s
|
|
break
|
|
end if
|
|
s = (s+x/s)/2
|
|
end repeat
|
|
|
|
repeat $-$$
|
|
load a byte from $$+%-1
|
|
store byte a xor c at $$+%-1
|
|
end repeat
|
|
|
|
GDTR dp ?
|
|
virtual at GDTR
|
|
GDT_limit dw ?
|
|
GDT_address dd ?
|
|
end virtual
|
|
|
|
virtual at 0
|
|
file 'a.txt':10h,1
|
|
load char from 0
|
|
end virtual
|
|
|
|
virtual at 0 as 'asc'
|
|
times 256 db %-1
|
|
end virtual
|
|
|
|
virtual at 0
|
|
hex_digits::
|
|
db '0123456789ABCDEF'
|
|
end virtual
|
|
load a byte from hex_digits:10
|
|
|
|
bits = 16
|
|
display 'Current offset is 0x'
|
|
repeat bits/4
|
|
d = '0' + $ shr (bits-%*4) and 0Fh
|
|
if d > '9'
|
|
d = d + 'A'-'9'-1
|
|
end if
|
|
display d
|
|
end repeat
|
|
display 13,10
|
|
|
|
if ~ defined alpha
|
|
alpha:
|
|
end if
|
|
|
|
if ~ defined alpha | defined @f
|
|
alpha:
|
|
@@:
|
|
end if
|
|
|
|
include 'macros.inc'
|
|
|
|
d equ dword
|
|
NULL equ d 0
|
|
d equ edx
|
|
|
|
d equ d,eax
|
|
|
|
b equ byte
|
|
w equ word
|
|
d equ dword
|
|
p equ pword
|
|
f equ fword
|
|
q equ qword
|
|
t equ tword
|
|
x equ dqword
|
|
y equ qqword
|
|
|
|
incl fix include
|
|
|
|
macro tst {test al,0xFF}
|
|
|
|
macro stos0
|
|
{
|
|
xor al,al
|
|
stosb
|
|
}
|
|
|
|
macro align value { rb (value-1)-($+value-1) mod value }
|
|
|
|
macro mov op1,op2
|
|
{
|
|
if op1 in <ds,es,fs,gs,ss> & op2 in <cs,ds,es,fs,gs,ss>
|
|
push op2
|
|
pop op1
|
|
else
|
|
mov op1,op2
|
|
end if
|
|
}
|
|
|
|
macro stoschar [char]
|
|
{
|
|
mov al,char
|
|
stosb
|
|
}
|
|
|
|
macro movstr
|
|
{
|
|
local move
|
|
move:
|
|
lodsb
|
|
stosb
|
|
test al,al
|
|
jnz move
|
|
}
|
|
|
|
macro strtbl name,[string]
|
|
{
|
|
common
|
|
label name dword
|
|
forward
|
|
local label
|
|
dd label
|
|
forward
|
|
label db string,0
|
|
}
|
|
|
|
push 3
|
|
push 2
|
|
push 1
|
|
call foo
|
|
|
|
macro invoke proc,[arg]
|
|
{ common stdcall [proc],arg }
|
|
|
|
macro jif op1,cond,op2,label
|
|
{
|
|
cmp op1,op2
|
|
j#cond label
|
|
}
|
|
|
|
macro label name
|
|
{
|
|
label name
|
|
if ~ used name
|
|
display `name # " is defined but not used.",13,10
|
|
end if
|
|
}
|
|
|
|
macro message arg
|
|
{
|
|
if arg eqtype ""
|
|
local str
|
|
jmp @f
|
|
str db arg,0Dh,0Ah,24h
|
|
@@:
|
|
mov dx,str
|
|
else
|
|
mov dx,arg
|
|
end if
|
|
mov ah,9
|
|
int 21h
|
|
}
|
|
|
|
macro ext instr
|
|
{
|
|
macro instr op1,op2,op3
|
|
\{
|
|
if op3 eq
|
|
instr op1,op2
|
|
else
|
|
instr op1,op2
|
|
instr op2,op3
|
|
end if
|
|
\}
|
|
}
|
|
|
|
ext add
|
|
ext sub
|
|
|
|
|
|
macro tmacro [params]
|
|
{
|
|
common macro params {
|
|
}
|
|
MACRO fix tmacro
|
|
ENDM fix }
|
|
|
|
|
|
MACRO stoschar char
|
|
mov al,char
|
|
stosb
|
|
ENDM
|
|
|
|
postpone
|
|
{
|
|
code_size = $
|
|
}
|
|
|
|
struc point x,y
|
|
{
|
|
.x dw x
|
|
.y dw y
|
|
}
|
|
|
|
struc db [data]
|
|
{
|
|
common
|
|
. db data
|
|
.size = $ - .
|
|
}
|
|
|
|
rept 5 { in al,dx }
|
|
|
|
rept 3 counter
|
|
{
|
|
byte#counter db counter
|
|
}
|
|
|
|
match +,+ { include 'first.inc' }
|
|
match +,- { include 'second.inc' }
|
|
match a b, 1+2+3 { db a }
|
|
|
|
V fix {
|
|
macro empty
|
|
V
|
|
V fix }
|
|
V
|
|
|
|
|
|
list equ
|
|
|
|
macro append item
|
|
{
|
|
match any, list \{ list equ list,item \}
|
|
match , list \{ list equ item \}
|
|
}
|
|
|
|
define a b+4
|
|
define b 3
|
|
rept 1 result:a*b+2 { define c result }
|
|
|
|
rept 8 n:0 { pxor xmm#n,xmm#n }
|
|
|
|
|
|
irps reg, al bx ecx
|
|
{ xor reg,reg }
|
|
|
|
|
|
if 0
|
|
a = 1
|
|
b equ 2
|
|
end if
|
|
dd b
|
|
|
|
|
|
extrn exit
|
|
extrn '__imp__MessageBoxA@16' as MessageBox:dword
|
|
|
|
extrn 'printf' as _printf
|
|
printf = PLT _printf
|
|
|
|
tester? = 0
|
|
|
|
space:
|
|
space.x = 1
|
|
space.y = 2
|
|
space.color:
|
|
space.color.r = 0
|
|
space.color.g = 0
|
|
space.color.b = 0
|
|
|
|
space:
|
|
namespace space
|
|
x = 1
|
|
y = 2
|
|
color:
|
|
.r = 0
|
|
.g = 0
|
|
.b = 0
|
|
end namespace
|
|
|
|
|
|
first:
|
|
.child = 1
|
|
..other = 0
|
|
second:
|
|
.child = 2
|
|
..another = ..other
|
|
|
|
|
|
label character:byte
|
|
label char:1
|
|
|
|
byte? = 1 ; 8 bits
|
|
word? = 2 ; 16 bits
|
|
dword? = 4 ; 32 bits
|
|
fword? = 6 ; 48 bits
|
|
pword? = 6 ; 48 bits
|
|
qword? = 8 ; 64 bits
|
|
tbyte? = 10 ; 80 bits
|
|
tword? = 10 ; 80 bits
|
|
dqword? = 16 ; 128 bits
|
|
xword? = 16 ; 128 bits
|
|
qqword? = 32 ; 256 bits
|
|
yword? = 32 ; 256 bits
|
|
dqqword? = 64 ; 512 bits
|
|
zword? = 64 ; 512 bits
|
|
|
|
element A
|
|
linpoly = A + A + 3
|
|
vterm = linpoly scale 1 * linpoly element 1 ; vterm = 2 * A
|
|
|
|
db 4 dup 90h ; generate 4 bytes
|
|
db 2 dup ('abc',10) ; generate 8 bytes
|
|
|
|
macro measured name,string
|
|
local top
|
|
name db string
|
|
top: name.length = top - name
|
|
end macro
|
|
|
|
measured hello, 'Hello!' ; hello.length = 6
|
|
|
|
A equ 1
|
|
A equ 2
|
|
|
|
drop A
|
|
drop A
|
|
|
|
data1 dw 1
|
|
buffer1 rb 10h ; zeroed and present in the output
|
|
|
|
org 400h
|
|
data dw 2
|
|
buffer2 rb 20h ; not in the output
|
|
|
|
section 1000h
|
|
data3 dw 3
|
|
buffer3 rb 30h ; not in the output
|
|
|
|
virtual at 0
|
|
hex_digits::
|
|
db '0123456789ABCDEF'
|
|
end virtual
|
|
load a:byte from hex_digits:10 ; a = 'A'
|
|
|
|
db "Text"
|
|
key = 7Bh
|
|
repeat $-$$
|
|
load a : byte from $$+%-1
|
|
store a xor key : byte at $$+%-1
|
|
end repeat
|
|
|
|
load char : byte from const:0
|
|
|
|
if $>10000h
|
|
err 'segment too large'
|
|
end if
|
|
calminstruction please? cmd&
|
|
match =do? =not? cmd, cmd
|
|
jyes done
|
|
assemble cmd
|
|
done:
|
|
end calminstruction
|
|
|
|
please do not display 'Bye!'
|
|
|
|
macro jmpi target
|
|
if target-($+2) < 80h & target-($+2) >= -80h
|
|
db 0EBh
|
|
db target-($+1)
|
|
else
|
|
db 0E9h
|
|
dw target-($+2)
|
|
end if
|
|
end macro
|
|
|
|
macro EX? first,second
|
|
match (=SP?), first
|
|
match =HL?, second
|
|
db 0E3h
|
|
else match =IX?, second
|
|
db 0DDh,0E3h
|
|
else match =IY?, second
|
|
db 0FDh,0E3h
|
|
else
|
|
err "incorrect second argument"
|
|
end match
|
|
else match =AF?, first
|
|
match =AF'?, second
|
|
db 08h
|
|
else
|
|
err "incorrect second argument"
|
|
end match
|
|
else match =DE?, first
|
|
match =HL?, second
|
|
db 0EBh
|
|
else
|
|
err "incorrect second argument"
|
|
end match
|
|
else
|
|
err "incorrect first argument"
|
|
end match
|
|
end macro
|
|
|
|
EX (SP),HL
|
|
|
|
macro INC? argument
|
|
match [:r:], argument
|
|
db 100b + r shl 3
|
|
else match (=HL?), argument
|
|
db 34h
|
|
else match (=IX?+d), argument
|
|
db 0DDh,34h,d
|
|
else match (=IY?+d), argument
|
|
db 0FDh,34h,d
|
|
else
|
|
err "incorrect argument"
|
|
end match
|
|
end macro
|
|
|
|
INC (IX+2)
|
|
|
|
element IY?
|
|
|
|
element L? : register + 101b
|
|
|
|
macro CALL? arguments&
|
|
local cc,nn
|
|
match condition =, target, arguments
|
|
cc = condition - CC
|
|
nn = target
|
|
db 0C4h + cc shl 3
|
|
else
|
|
nn = arguments
|
|
db 0CDh
|
|
end match
|
|
dw nn
|
|
end macro
|