INTRODUCTION TO PROCEDURES--Notes

INTRODUCTION TO PROCEDURES

·         A procedure is a unit of code designed to perform a particular sub-task of some main task. It is written out only once in some module, but can be used many times.

·         The advantages of using procedures are:

·         Improves code readability because the code does not need to be laid out as one long sequence.

·                     Allows code to be reused because it can be written once and called from more than one place in the code.

·          Allows tasks to be broken down into simpler components because procedures can be written for certain tasks (procedures can also call other procedures).

·         Modular code facilitates modification.

·         A procedure is always enclosed within some code segment.

·         A procedure is defined as:

PROCEDURE_NAME   PROC

.

.

.

PROCEDURE_NAME   ENDP

where PROCEDURE_NAME is any valid identifier.

·         The PROC directive usually includes one of the operands NEAR or FAR. Example:

PROCEDURE_NAME   PROC   FAR

.

.

.

PROCEDURE_NAME   ENDP

A NEAR procedure is defined in the same code segment from which it is called, and a FAR procedure is ordinarily defined in a separate code segment. Note if none of the operands NEAR or FAR follows the PROC directive, then the procedure is by default a NEAR procedure.

CALLING A NEAR PROCEDURE

·         A procedure is invoked by a CALL instruction that can be direct or indirect. A direct procedure call has the format:

                CALL     PROCEDURE_NAME

·         In an indirect near procedure call, the operand for the CALL instruction is either a 16-bit general-purpose register or a memory word containing the offset address of the procedure.

Example: An indirect procedure call using a register operand.

                .  .  .

                                MOV  SI ,  OFFSET  COMP

                                CALL  SI

                                .  .  .

                COMP  PROC  NEAR

                                .  .  .

                                RET

                COMP  ENDP

·         A procedure may be invoked by a JMP instruction if it does not return control to the caller:

JMP   PROCEDURE_NAME

Executing a near CALL

·         The return address to the calling program (the current value of the IP) is saved on the stack

·         IP get the offset address of the first instruction of the procedure (this transfers control to the procedure)

RETURNING FROM A PROCEDURE

The RET instruction returns control to the caller of a procedure. There are two formats for the RET instruction:

                RET

and

                RET  UnsignedInteger

The second form is used to discard parameters passed to the procedure through the stack. (This is discussed in another lecture )

Note: A procedure may have zero, one, or more RET instructions. A procedure will have no RET instruction in those programming situations where we don’t want to return control to the caller.

Executing a near RET

RET causes word at the top of the stack to be popped into IP  (Since this value is the offset address of the statement after the CALL statement, control is transferred to that statement.)

THE GENERAL STRUCTURE OF AN EXE-FORMAT PROGRAM CONTAINING PROCEDURES

                .MODEL SMALL

                .STACK  0400H

                .DATA 

                                .  .  .

                .CODE 

                MAIN  PROC

                                MOV  AX ,  @DATA          ; Initialize DS

                                MOV  DS ,  AX                     ;

                                .  .  .

                                CALL  SUB1

                                .  .  .

                                CALL  SUB2

                                .  .  .

                                MOV  AX ,  4C00H              ; Return to DOS

                                INT  21H

                MAIN  ENDP

                SUB1  PROC

                                .  .  .

                                RET

                SUB1  ENDP

                SUB2  PROC

                                .  .  .

                                CALL  SUB3

                                .  .  .

                                RET

                SUB2  ENDP

                SUB3  PROC

                                .  .  .

                                RET

                SUB3  ENDP

                END  MAIN

THE GENERAL STRUCTURES OF A COM-FORMAT PROGRAM CONTAINING PROCEDURES

.MODEL TINY .CODE                  ORG 100H     MAIN  PROC                 .  .  .             CALL  SUB1                 .  .  .             CALL  SUB2                 .  .  .             MOV  AX ,  4C00H   ; Return to DOS             INT  21H     MAIN  ENDP     SUB1  PROC          .  .  .          RET     SUB1  ENDP     SUB2  PROC          .  .  .         CALL  SUB3          .  .  .          RET      SUB2  ENDP      SUB3  PROC           .  .  .           RET      SUB3  ENDP            .  .  .           ; Data definitions, if any            .  .  .     END  MAIN

.MODEL TINY .CODE                  ORG 100H  START: JMP MAIN            .  .  .           ; Data definitions, if any            .  .  .     MAIN  PROC                 .  .  .             CALL  SUB1                 .  .  .             CALL  SUB2                 .  .  .             MOV  AX ,  4C00H   ; Return to DOS             INT  21H     MAIN  ENDP     SUB1  PROC          .  .  .          RET     SUB1  ENDP     SUB2  PROC          .  .  .         CALL  SUB3          .  .  .          RET      SUB2  ENDP      SUB3  PROC           .  .  .           RET      SUB3  ENDP     END  START

Note: If the entry point is specified in the END directive, the procedures may appear in any order.

PRESERVING THE VALUES OF REGISTERS IN PROCEDURES

It is good programming practice to preserve the values of all the registers modified by a procedure, except if a register is used by the procedure to return a value to the calling program. This is done by PUSHing (i.e., saving) the values of those registers in the stack at the beginning of the procedure, and then POPing (i.e., retrieving) them from the stack, in the reverse order, before the RET instruction.

Example: MYPROC   PROC

                                                PUSH  AX

                                                PUSH  DX

                                                .  .  .                         ;  statements that modify AX and DX

                                                .  .  .                         ;

                                                POP  DX

                                                POP  AX

                                                RET

                                MYPROC  ENDP

·         Syntax of PUSH:

                   PUSH   source

Where source is either imm8, imm16, imm32, segment register, 16- or 32-bit general purpose register. If source is imm8, then the value is zero or sign extended to 16-bits.

·         Syntax of POP:

                POP  destination

Where destination is either mem16, mem32, segment register, 16- or 32-bit general purpose register.

Thus only words or double-words are pushed or popped from the stack. An 8-bit immediate value pushed in the stack is zero- or sign- extended to 16-bits.

Note:  (a) Since the stack is used by the system to store addresses during procedure calls, and to store addresses and the values of the flags during interrupts, it is necessary that to every PUSH instruction in your program there is a corresponding POP instruction.

 (b) To preserve the FLAGS register the instructions PUSHF and POPF are used.

       To preserve the EFLAGS register the instructions PUSHFD and POPFD are used.

(c) PUSHA    pushes the 16-bit general purpose registers in the order AX, CX, DX, BX, SP, BP, SI, and DI. POPA                     pops the 16-bit general purpose registers in the reverse order of PUSHA.

      PUSHAD  pushes the 32-bit general purpose registers in the order EAX, ECX, EDX, EBX, ESP, EBP, ESI,

                             EDI.

      POPAD         pops the 32-bit general-purpose registers in the reverse order of PUSHAD.

(d) USES directive: The PROC directive may have the form:

               procedure_name   PROC   USES  RegisterList

                    where:

RegisterList is a list of registers that are used by the procedure and which must be preserved. The registers in the list are separated by spaces. Including a register in this list will cause the assembler to automatically generate the necessary PUSH instruction to save the register value, and then to generate the necessary POP instruction to restore the value of that register before control is returned to the caller.

Example:  

      DISPLAY   PROC  USES   AX   BX   CX

                                         .   .   .

                                         RET

                         DISPLAY   ENDP

EXAMPLES

·         Procedures should normally be general and not specific, i.e., a procedure must be written such that it can be used by passing to it different parameters.

·         One way of passing parameters to procedures is to use registers.

·         Example1:       DISPLAY_STRING  PROC

                                                PUSH  AX

                                                MOV  AH ,  09H

                                                INT  21H

                                                POP  AX

                                                RET

                                DISPLAY_STRING  ENDP

This procedure will be invoked by a call of the form:

                                .   .   .

                                MOV  DX ,  OFFSET  STRING_NAME

                                CALL  DISPLAY_STRING

                                .   .   .

Note: If the previous procedure were coded as:

DISPLAY_STRING  PROC

                                                PUSH  AX

                                                PUSH  DX

                                                MOV  AH ,  09H

                                                MOV  DX , OFFSET  STRING1

                                                INT  21H

                                                POP  DX

                                                POP  AX

                                                RET

                                DISPLAY_STRING  ENDP

then a separate procedure will be required for every string to be displayed !

                               

·         Example2:       STRING_DISPLAY  PROC

                                                PUSH  AX

                                                PUSH  BX

                                                MOV  AH , 40H

                                                MOV  BX , 01H

                                                INT  21H

                                                POP  BX

                                                POP  AX

                                                RET

                                STRING_DISPLAY  ENDP

This procedure will be invoked by a call of the form:

                                .   .   .

                                MOV  CH , 00H

                                MOV  CL , string_length

                                LEA  DX ,  StringName

                                CALL  STRING_DISPLAY

                                .   .   .

·         Example3:

DISPLAY_CHAR   PROC

                                                PUSH  AX

                                                MOV  AH ,  02H

                                                INT  21H

                                                POP  AX

                                                RET

                                DISPLAY_CHAR  ENDP

This procedure will be invoked by a call of the form:

                                .   .   .

                                MOV  DL ,  character

                                CALL  DISPLAY_CHAR

                                .   .   .

·         Example4:

                                READ_CHAR   PROC

                                                ; Returns the character read in the AL register

                                                PUSH CX                               ; Preserve the CX register

                                                MOV CH, AH                       ; Preserve the AH register

                                                MOV  AH ,  01H

                                                INT  21H

                                                MOV AH, CH                       ; Restore the AH register

                                                POP CX                  ; Restore the CX register

                                                RET

                                READ_CHAR  ENDP

Note: In this procedure the AX register is not pushed and then popped (i.e., it is not preserved) because the procedure returns a value to the calling program in the AL register. This procedure will be invoked by a call of the form:

                                .   .   .

                                CALL  READ_CHAR                         

                                .   .   .

THE CALL AND RETURN MECHANISM FOR A NEAR PROCEDURE

Assume that a program defines a stack segment as:

                .STACK  200 

               

then the original state of this stack is:

			high address
byte 200		¬ SP
byte 199
byte 198
	.	stack segment
	.
	.
byte 1
byte 0		¬ SS
			low address

Notice that the SP register is initialized to point one byte beyond the stack. The reason is that when a PUSH instruction:

                                PUSH Operand16

 is executed the value in the SP register is automatically decremented by 2 and then the value of the word operand is pushed into the stack at the new word pointed to by SP:

                                (SP)  ¬   (SP) - 2

                                (Word at Top of Stack)  ¬   (Operand16)

 In the above example, the first word to be pushed into the stack will be stored at bytes 198 and 199. The state of the stack after pushing one word is then:

			high address
byte 200
byte 199	XX
byte 198	XX	¬ SP
	.	stack segment
	.
	.
byte 1
byte 0		¬ SS
			low address

When a POP instruction:

                POP  Operand16

is executed, the value of the word at the current top of the stack (i.e., the word pointed to by SP) is copied to the operand of the POP instruction and then the value of the SP register is automatically incremented by 2:

                Operand16  ¬  (Word at top of stack)

                (SP)  ¬   (SP) + 2

Since the value of the popped word is no longer accessible in the stack it will be overwritten by a subsequent PUSH operation.

When a NEAR procedure is called the following sequence of events occurs:

·         (SP)  ¬  (SP)  -  2

·         (Word at top of Stack)  ¬   (IP)

i.e., the offset address of the statement after the CALL statement is stored in the stack.

·         (IP)  ¬ offset address of first executable statement in the called procedure.

Since the logical address CS:IP now refers to the first executable statement in the called NEAR procedure, program execution continues with the execution of the procedure statements.

When a RET instruction is executed in the procedure the following sequence of events occurs:

·         (IP)  ¬   (Word at top of Stack)

i.e.,  restore the offset address of the statement, in the calling program, after the CALL statement.

·         (SP)  ¬   (SP)  +  2

Since now the logical address CS:IP refers to the statement, in the calling program, after the CALL statement, program execution continues from that statement.

Note: For a NEAR procedure call the value of CS is not pushed in the stack, because both the calling program and the called procedure are in the same code segment; the value of CS does not change.