Machine Code Made Easy - Part 1

From Fred 6

Machine Code Made Easy - Part 1

Hello everyone out there in Coupé‚ land. This is (hopefully!) the
first in a series on machine code for beginners. No, please,
don’t all groan at once - m/c has its uses - it’s not just for
swotty egg-headed squares. Just think of all the games you’ll
write and all the money you’ll make after reading this article!
Now, firstly you’ll need an assembler. This is a program with
which the machine code can be entered. I can ..recommend the one
from LERM although any old one’ll do. Got one? Right. Now to
lesson one…..

REGISTERS:-

The first thing we’ll deal with are the registers.
You could compare these with variables from BASIC, and there are
8 main ones. They are named after letters: A;B;C;D;E;F;H;L and
each can contain a number between 0 and 255

To allocate a number to one of these registers we use the
command: LD A,100

This stands for LoaD A with 100 and is like the BASIC: LET A=100
The contents of one register can be copied into another by using : LD A,B

This will load A with whatever is in B and is like : LET A=B in BASIC
Although each register can only hold a number 0 to 255,
they can be used in pairs to hold a number 0 to 65535. The
pairings used are: B&C ; D&E ; H&L ; A&F
The F register is special and is used to store the results
of tests via FLAGS (F for flag, geddit?) and so shouldn’t be
tampered with. A flag is just a binary digit which indicates
whether a calculation has produced a carry or a zero and things
like that. Don’t be concerned with flags for the moment.
2 other registers we will use are IX and IY. These are known
as INDEXES and can hold a number 0 to 6..5535.

To use a number which is stored in memory we use brackets
around the ADDRESS of the number. ie, where about in memory it
is. The address must be between 0 and 65535 and the number is
always between 0 and 255. For example, to load the ACCUMULATOR
(another name for the A register) with the contents of 30000 we
use : LD A,(30000)

Similarly, to load A with the contents of the address held
in the HL register pair use : LD A,(..HL)
Another two very useful commands are DEC and INC. These
DECrement (take away 1 from) or INCrement (add 1 to) any
register or register pair. So, if we have a program:

Our end result is that A=101 an..d B=99

Let us now look at a program the way it would appear on an
assembler:

PLEASE NOTE: On some assemblers DM is written as DEFM

There are two new instructions in this one. RST 16 jumps to
a ROM routine which prints the character currently held in the A
register. (NB. The character is stored as an ASCII code. Refer
to your manual for explanation)

The other new command, DJNZ, is more complex. Firstly, it
does a DEC B and decrements the B register. If this produces a
non-zero number (ie B is now not 0) then the zero flag (in the F
register, remember) is not se..t and so the program jumps back to
LOOP1. If the B register IS now 0 then the zero flag is set and so
the CPU goes on with the next instruction in the program
which in this case is RET. RET simply means RETurn and will,
in our case, stick us back into BASIC.

To get this up and running, assemble it (see your assembler for details),
save it and reload it to address 50000.
To run a m/c routine we can use the BASIC command CALL 50000
where 50000 is our start ad..dress.

Now, let’s get onto something more complicated. (Great,huh?)

THE STACK:-

The stack is a part of memory where numbers can be
stored temporarily using simple commands. It grows downwards and
its current memory location is held in another 16-bit register
called SP for Stack Pointer. (A 16-bit register can hold a value
0 to 65535, while an 8-bit one can only hold a value 0 to 255)
The two main commands for using the stack are PUSH and POP.
To store a value held in HL, we can use: PUSH HL
This puts the value to the position pointed to by SP and then lets SP=SP-2
To retrieve this value we can use use: POP HL . This lets
SP=SP+2, takes the value in the address pointed to by SP and
sticks it into HL. There is no reason why this value couldn’t be
POPped off into BC or IX etc. and you should note that the value
stays in memory - just under SP.

The stack is also used when a subroutine is called. The
command to jump to a subroutine is CALL xxxx, where xxxx is the
start address of the routine. The computer has to know where to RETurn
to when the subroutine ends, so the address of the
command after the CALL is PUSHed onto the stack. When the CPU
comes across a RET command it POPs a value off the stack and
jumps to this address.

Jumping from place to place also uses certain commands:
JP xxxx ; JumPs to address xxxx without affecting the stack
JR xx ; Jumps Relative to current address without affecting
the stack.

This means that JR -100 will jump back 100 addresses,
and JR +100 will jump forward 100 addresses. The jump MUST be in
the range -127 to +128.

Another important feature of jumping is that we can qualify the jump.
In simple terms this means that we can JP, JR or CALL depending or
the state of certain flags.

For example, CALL NZ means call if not zero. ie, the zero
flag is NOT set. CALL Z would do the opposite and call if the
zero flag IS set. All the flags can be used in this way,although
a beginner would probably only use the CARRY and ZERO flags.
A jump can also be made to the address in HL. The command is
JP HL or JP (HL). Don’t be confused by the brackets - they
shouldn’t really be there.

We will end today by looking at some simple arithmetical
commands:-

ADD A,xx ; xx is added to the A register. The result is
stored in A. xx could be an 8-bit number or an 8-bit register.
SUB xx ; xx is subtacted from the A register. The result is
stored in A and xx could be an 8-bit number or an 8-bit register

CP xx ; This is a sneaky one. CP stands for ComPare and
the A register is compared to xx. In fact, xx is subtracted from
A, but the result isn’t stored anywhere. xx can be as above.
In all three of the above commands, flags are affected. If, during
an addition or subtraction (including CP), the result
crosses 0 or 255 then the CARRY flag is set.
eg. if A=100 and we did an ADD A,200 the carry would be set.
if A=100 and we did a SUB 200 or a CP 200 carry would
also be set.

BUT if A=100 and we did an ADD A,50 or a SUB 50 or even a
CP 50 then carry would be reset.

If the final result of any of these commands is 0, then the zero flag is set.
eg. If A=100 and we do a SUB 100 or a CP 100 then zero would be set.

PLEASE NOTE although the final result may be less than 0 or
more than 255 the A register always contains a number 0 to 255. So,
in effect any values above/below 255/0 are “wrapped around” so that they
will fit into this range

Finally, here’s a short proggie. Try to see how it works.