CHAPTER 3. BOOT SECTOR PROGRAMMING (IN 16-BIT REAL
MODE) 20
jmp my_print_function
return_to_here: ; This label is our life -line so we can get back.
...
...my_print_function:
mov ah, 0x0e ; int =10/ah=0x0e -> BIOS tele -type output
int 0x10 ; print the character in al
jmp return_to_here ; return from the function call.Firstly, note how we used the registeralas a parameter, by setting it up ready for
the function to use. This is how parameter passing is made possible in higher level
languages, where thecallerandcallee must have some agreement on where and how
many parameters will be passed.
Sadly, the main flaw with this approach is that we need to say explicitly where to
return to after our function has been called, and so it will not be possible to call this
function from arbitrary points in our program --- it will always return the same address,
in this case the labelreturntohere.
Borrowing from the parameter passing idea, the caller code could store the correct
return address (i.e. the address immediately after the call) in some well-known location,
then the called code could jump back to that stored address. The CPU keeps track of the
current instruction being executed in the special registerip(instruction pointer), which,
sadly, we cannot access directly. However, the CPU provides a pair of instructions,call
andret, which do exactly what we want:callbehaves likejmpbut additionally, before
actually jumping, pushes the return address on to the stack;retthen pops the return
address off the stack and jumps to it, as follows:
...
...
mov al, ’H’ ; Store ’H’ in al so our function will print it.
call my_print_function
...
...my_print_function:
mov ah, 0x0e ; int =10/ah=0x0e -> BIOS tele -type output
int 0x10 ; print the character in al
retOur functions are almost self-contained now, but there is a still an ugly problem that we
will thank ourselves later for if we now take the trouble to consider it. When we call a
function, such as a print function, within our assembly program, internally that function
may alter the values of several registers to perform its job (indeed, with registers being
a scarce resource, it will almost certainly do this), so when our program returns from
the function call it may not be safe to assume, say, the value we stored indxwill still be
there.
It is often sensible (and polite), therefore, for a function immediately to push any
registers it plans to alter onto the stack and then pop them off again (i.e. restore the
registers’ original values) immediately before it returns. Since a function may use many
of the general purpose registers, the CPU implements two convenient instructions,pusha
andpopa, that conveniently push and popallregisters to and from the stack respectively,
for example:
...