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