Next Previous Contents

## 10. Details of instructions

This section gives a detailed explanation of the available assembler instructions.

## 10.1 mov

mov dest,source :

> `

>     Copies a value from source to dest.
>     Source can be a register, memory referencing register,value or mem-adress.
>     dest can be a register, memory referencing register or mem-adress
>     (though you can't mov mem,mem)

>     example:

>     mov ax,100
>     mov @ax,100
>     mov ax,@100
>     mov @100,ax
>     mov ax,bx

>     It can also be a mov with an offset, example:

>     mov ax,@bx +4
>     mov @cx +3,dx ;These are the only two instructions taking 3 arguments

>     Observe that the mov with offset only works with exactly these operands
>     ( reg,@reg +val and @reg +val,reg )

> `

## 10.2 nop

> `

>     Wastes a clock-cycle

>     Can be useful if you want to make sure that your out command is in
>     effect before you continue in your code.

> `

## 10.3 movsb/movsw

> `

>     Copies cx number of bytes/words from @si to @di.

>     Example:

>     mov cx,100
>     mov si, 50
>     mov di, 150
>     movsb       ;Copy bytes 50-149 to 150-249

>     movsw would have copied twice as much data

> `

## 10.4 stosb/stosw

> `

>     Fills cx number of bytes/words at @di with contents of ah

>     Example:

>     mov ah,0
>     mov di,100
>     mov cx,100
>     stosb      ;Zero bytes 100-199

>     stosw would have zeroed twice as much data

> `

## 10.5 lodsb/lodsw

> `

>     lodsb does the equivalent of:
>     mov ah,@si
>     inc si

>     lodsw does the equivalent of:
>     mov ax,@si
>     add si,2

> `

## 10.6 push

push source :

> `

>     PUSHes a value onto the stack, and changes the stackpointer to point
>     past the PUSHed value.

>     Example :

>     push ax ;save ax to the stack
>     push @ax ;save value ax points to on the stack
>     push 100 ;put value 100 on the stack

> `

## 10.7 pop

pop dest :

> `

>     POPs the value off the stack and changes stack pointer (used with push).

>     Example:

>     push cx   ;save cx

>     do something else with cx

>     pop cx    ;restore cx

> `

## 10.8 xchg

xchg arg1,arg2 :

> `

>     Exchanges the contents of arg1 and arg2.
>     arg1 MUST be a register, arg2 can be register,memory or
>      memory referencing register

>     Example :

>     mov ax,5
>     mov bx,7
>     mov @5,8
>     xchg ax,bx  ; ax=7, bx=5
>     xchg ax,@100 ; ax=8, @5=7
>     xchg ax,@bx ; ax=7 @bx or @5 = 8

> `

## 10.9 test

test arg1,bit :

> `

>     Tests a single bit in arg1. If no value is given for bit,
>     cl is used. If bit is set, equality flag is set, otherwise
>     cleared.

>     Example :

>     mov cl,3  ;test bit 3
>     test flags
>     jz next  ;Jump to next if bit was set

>     or this works just as good:

>     test flags,3
>     jz next

> `

## 10.10 cmp/icmp

cmp arg1,arg2 :

> `

>     Compares arg1 with arg2. sets/clears the equality, above and
>     below flags depending on the value of the operands...

>     icmp treats the values as signed.

>     Example :

>     mov ax,100
>     :loop
>     inc ax
>     cmp ax, 200  ;When ax is 200, jump outside the loop
>     jz next

>     jmp loop

>     :next

> `

## 10.11 cmpsb

cmpsb

> `

>     Compares cl bytes at @di with @si, sets/clears the equality,
>     above and below flags.

>     Example:

>     mov cl,5  ;Check 5 bytes
>     mov di,100
>     mov si,200
>     cmpsb     ;Check if the 5 bytes at @100 are the same as @200

> `

## 10.12 jmp

jmp val :

> `

>     jumps to a position in RAM, often used with labels as the value.

>     Examples:

>     :label
>     ...
>     ...
>     ...
>     jmp label

>     but nothing stops you from doing:

>     jmp 100  ;NOT RECOMMENDED!! use labels!

>     You can also use a register as the adress container:

>     mov ax,100
>     jmp ax ; Use with caution!

> `

## 10.13 jz,jnz,jae,jbe,ja,jb,cj,cjn

jz, jnz, jae/jnb , jbe/jna , cj , cjn :

> `

>     Conditional jumps... takes the latest flag modifying operation into
>     account (test, cmp, cmpsb), or the value of a register

>     jz dest : jump if equal
>     jnz dest : jump if not equal
>     jae dest : jump if above or equal
>     jnb dest : jump if not below (same as above)
>     jbe dest : jump if below or equal
>     jna dest : jump if not above (same as above)
>     ja dest : jump if above
>     jb dest : jump if below
>     cj reg dest: jump if register reg != 0
>     cjn reg dest: jump if register reg == 0

> `

## 10.14 lz,lnz,la,lb,lae,lbe

lz/lnz/la/lb/lae/lbe reg

> `

>     Loads either a 1 or a 0 inte register reg, depending on the state of the flags.
>     lz reg : 1 if equal (otherwise 0)
>     lnz reg : 1 if not equal
>     lae reg : 1 if above or equal
>     lnb reg : 1 if not below (same as above)
>     lbe reg : 1 if below or equal
>     lna reg : 1 if not above (same as above)
>     la reg : 1 if above
>     lb reg : 1 if below

> `

## 10.15 loop

loop dest :

> `

>     decreases cx, and jumps to dest if cx != 0.

>     Example:

>     mov cx,100 ;100 loops
>     :loopdest

>     ...
>     ...

>     loop loopdest

> `

## 10.16 call

call dest :

> `

>     Pushes the current position to the stack and jumps
>     to dest.

>     Example

>     :start

>     call dosomething
>     call dosomethingelse

>     jmp start

>     :dosomething
>     ...
>     ret

>     :dosomethingelse
>     ...
>     ret

> `

## 10.17 ret

ret ,ret val:

> `

>     ret Pops the position of execution from the stack and jumps there
>     see call for example

>     ret val also pops a number of bytes (val)
>     This is useful if you make generic functions that takes pushed arguments
>     example:

>     :start

>     push ax
>     push dx
>     call funk
>     ...
>     ...
>     jmp start

>     :funk
>     ...
>     ...
>     ret 4 ;return with 4 bytes used for arguments

> `

## 10.18 iret

iret :

> `

>     Same as ret except it enables interrupts too.
>     Used in interrupt service routines:

>     %interrupt 0
>     dosomething
>     iret

> `

## 10.19 cli,sti

cli sti :

> `

>     cli : Clear Interrupt flag (disable hardware interrupts)
>     sti : Set Interrupt flag (enable hardware interrupts)

> `

## 10.20 out

out port,arg :

> `

>     Sends value arg to port, this is the way to give your devices
>     orders to do something.

>     example:

>     out 10,ax
>     out 9,7

> `

## 10.21 in

in reg,port

> `

>     Gets value from port to register reg. Thisi is the way to get
>     info from your devices

>     Example :

>     in ax,10

> `

## 10.22 inc,dec

inc arg / dec arg :

> `

>     Increases/decreases arg with 1:

>     inc ax
>     dec @bx
>     inc @100

> `

## 10.23 add,sub

add arg1,arg2 / sub arg1,arg2 :

> `

>     Adds /Subtracts arg1 with arg2.
>     Result is in arg1 :

>     add ax,bx
>     sub cx,100

> `

## 10.24 and,or,xor

and/or/xor arg1,arg2

> `

>     Performs bitwise and/or/xor on operands
>     Result is in arg1

>     Example:

>     and ax,24
>     or ax,bx

> `

## 10.25 shr,shl

shr / shl arg1,arg2 :

> `

>     Performs a shift left/right on arg1 arg2 bits

>     Example :

>     shl ax,2 ;shift ax left 2 bits (same as multiply of 4)

> `

## 10.26 ishr,ishl

ishr/ishl :

> `

>     Same as above, except sign bit is preserved

> `

## 10.27 ror,rol

ror/rol arg1,arg2 :

> `

>     Rotates arg1 around arg2 bits.

>     Example :
>     ror ax,2 ;rotates the bits in ax 2 steps

> `

## 10.28 int

int val :

> `

>     Performs a software interrupt, with interrupt vector
>     val being called:

>     int 0 ;Perform int 0

> `

## 10.29 mul/imul

mul/imul :

> `

>     Performs a multiplication of ax and dx. the low 16 bits
>     of the result end up in ax, and the high 16 bits in dx.

>     mov ax, 1024
>     mov dx, 300
>     mul
>     (dx is now 4 and ax is 45056 I think (haven't double checked))

>     imul is the same as mul, except it uses signed math

> `

## 10.30 div/idiv

div :

> `

>     Performs an integer division of ax and dx. The integer part
>     of the result end up in ax, the rest is in dx.

>     mov ax,50
>     mov dx,7
>     div

>     (ax is now 7 and dx is 1 )

>     idiv is the same as div except it uses signed math

> `

## 10.31 sin

sin :

> `

>     It takes the value in ax (0-1024 botgrades)
>     And puts the sin value for it back in ax.
>     The sin value is formatted as -32768 to 32767 (as -1 to 1)

>     I would like to get some comments on how this instruktion
>     should be changed or something

> `

## 10.32 cos

cos :

> `

>     It takes the value in ax (0-1024 botgrades)
>     And puts the cos value for it back in ax.
>     The cos value is formatted as -32768 to 32767 (as -1 to 1)

>     I would like to get some comments on how this instruktion
>     should be changed or something

> `

## 10.33 sinfunc

sinfunc :

> `

>     This instruction uses 3 registers in this formula:

>     ax = ax + bx * sin dx
>     (dx is 0-1024 botgrades)

>     I would like some comments on the usefullness of this
>     instruktion...

> `

## 10.34 cosfunc

cosfunc :

> `

>     This instruction uses 3 registers in this formula:

>     ax = ax + bx * cos dx
>     (dx is 0-1024 botgrades)

>     I would like some comments on the usefullness of this
>     instruktion...

> `

## 10.35 atanfunc

atanfunc :

> `

>     This instruction takes relative coordinates and returns the
>     angle to those coordinates:
>     bx is used as the relative X and dx as relative Y.
>     result is in ax.
>     bx and dx are treated as signed values

>     mov bx, 100 ;100 units to the right and
>     mov dx, -80 ;80 units up
>     atanfunc    ;calculate angle

> `

## 10.36 rnd

rnd :

> `

>     This instruction puts a random number into ax.

>     It uses a 32-bit Mersenne Twister engine for generating randomness, with uniform distribution in the entire range of 16 bits numbers.

> `

## 10.37 hwait

hwait :

> `

>     This instruction decreases the current number of cycles to zero for the CPU.
>     In each "hardware cycle" the CPU has between 3-7 cycles. if you execute an out
>     instruction the effect is not applied until the next hardware cycle. The standard
>     way of doing this was to insert a number of nop:s after an out instruktion.
>     However you never knew exact how many nop:s would be needed, so you had to insert
>     the "worst case" number of nop:s. with the hwait instruktion you don't waste any more
>     cycles than necessary.

> `

## 10.38 sqr

sqr :

> `

>     This instruction calculates the square root of ax.
>     The integer part is in ax and the decimal part in dx.
>     example :
>     mov ax,90
>     sqr
>     ;ax is now 9
>     ;dx is now 31904

> `

## 10.39 msg

msg adress:

> `

>     This instruction sends a message that will be visible in the battle infowindow.
>     The message is max 18 characters, and is ended by a zero-value

>     example :

>     msg @message ;Put "ABC" as the message
>     ...
>     #message
>     db "ABC"

>     You can also:
>     mov ax, message
>     msg @ax

>     The msg instruction is a zero-latency instruktion.

> `

## 10.40 err

err val :

> `

>     This instruction sends a message (much like msg) but it looks like this:

>     example:

>     err 6 ;Print message "ERROR #: 6"

> `

## 10.41 readfile / writefile

readfile writefile

> `

>     These instructions lets you access a file on disk.
>     The file survives between battles, (it has the name of the bot with the
>     ending .dat)

>     The size of your file is 64 bytes for every kb of RAM.
>     That is, a bot wit 4 kb RAM will have 256 bytes on disk.

>     Writing to the file:
>     mov ax,(position in file to start in)
>     mov cx,(number of bytes to write)
>     mov si,(position in RAM where the data to be written is positioned)
>     writefile

>     Reading from the file:
>     mov ax,(position in file to start)
>     mov cx,(number of bytes to read)
>     mov di,(position in RAM to read to)
>     readfile

>     ax+cx must not be more than he filesize limit of your bot.

>     Return value is in ax, and is number of bytes written/read,
>     or -1 if an error occured

> `

Next Previous Contents