Nested Procedure calls and Flowcharts

Sahar Mosleh California State University San Marcos Page 1

Nested Procedure calls and Flowcharts


• A nested procedure call occurs when

a called procedure calls another before

the first procedure returns.

• Suppose that main calls a procedure

named Sub1.While sub 1 is executing

it calls the Sub2 procedure.

• While Sub2 is executing, it calls the

Sub3 procedure.


• When the RET instruction at the end of Sub3 executes, it pops the

value at the stack[ESP]. Into the instruction pointer. This causes

execution to resume at the instruction following the call Sub3

instruction.

• The following diagram shows the stack just before the return from

Sub3 is executed.


• After the return, ESP points to the next highest stack entry. When the RET instruction at the end of Sub2 is about to execute, the stack appears as follows:


• Finally, when Sub1 returns, stack [ESP] is popped into the instruction pointer, and execution resumes in main:

• Clearly stack proves itself a useful device for remembering information, including nested procedure calls. Stack structures, in general, are in situations where program must retrace their steps in a specific order.


Flow Charts

• A flow chart is

a well-established

way of diagramming

program logic.

• Each shape in a

flowchart represents

a single logical step,

and lines with arrows

connecting the shapes.


• Text notation such as Yes and No are added next to decision symbols to show branching direction.

• There is no required position for each arrow connected to a decision symbol.

• Each process symbol can contain one or more closely related instructions.

• The instructions need not be syntactically correct. For example, we could add 1 to CX using either of the following process symbols: cx = cx +1 add cx,1


TITLE Integer Summation Program (Sum2.asm)

; This program inputs multiple integers from the user,; stores them in an array, calculates the sum of the; array, and displays the sum.

INCLUDE Irvine32.inc

.dataprompt1 BYTE "Enter a signed integer: ",0prompt2 BYTE "The sum of the integers is: ",0IntegerCount DWORD 3 ; array sizearray DWORD IntegerCount DUP(?)

.codemain PROC

call Clrscrmov esi,OFFSET arraymov ecx,IntegerCountcall PromptForIntegerscall ArraySumcall DisplaySumexit

main ENDP


;-----------------------------------------------------PromptForIntegers PROC;; Prompts the user for an array of integers, and fills; the array with the user's input.; Receives: ESI points to the array, ECX = array size; Returns: nothing;-----------------------------------------------------

pushad ; save all registers

L1:call WriteString ; display stringcall ReadInt ; read integer into EAXcall Crlf ; go to next output linemov [esi],eax ; store in arrayadd esi,4 ; next integerloop L1popad ; restore all registersret

PromptForIntegers ENDP


;-----------------------------------------------------ArraySum PROC;; Calculates the sum of an array of 32-bit integers.; Receives: ESI points to the array, ECX = array size; Returns: EAX = sum of the array elements;-----------------------------------------------------

push esi ; save ESI, ECXpush ecxmov eax,0 ; set the sum to zero

L1:add eax,[esi] ; add each integer to sumadd esi,4 ; point to next integerloop L1 ; repeat for array size

L2:pop ecx ; restore ECX, ESIpop esiret ; sum is in EAX

ArraySum ENDP


;-----------------------------------------------------

DisplaySum PROC

;

; Displays the sum on the screen

; Recevies: EAX = the sum

; Returns: nothing

;-----------------------------------------------------

push edx

mov edx,OFFSET prompt2 ; display message

call WriteString

call WriteInt ; display EAX

call Crlf

pop edx

ret

DisplaySum ENDP

END main


Flow chart of Arraysum procedure


Uses Operator

• The uses operator, coupled with the directive, lets you list names of all the registers modified within a procedure. This tells the assembler to do two things:

• first, generate Push instructions that save the registers on the stack.

•The uses operator Pop instructions to restore the register values at the end of the procedure.

• The USES operator immediately follows PROC, and is itself followed by a list of registers on the same line separated by the space or tabs.


• Lets modify the ArraySum procedure .

• It used PUSH and POP instruction to save and restore ESI and

ECX because these registers were modified by the procedure.

Instead, we can let the USES operator do the same thing:;-----------------------------------------------------ArraySum PROC USES esi ecx;; Calculates the sum of an array of 32-bit integers.; Receives: ESI points to the array, ECX = array size; Returns: EAX = sum of the array elements;-----------------------------------------------------

mov eax,0 ; set the sum to zero

L1:add eax,[esi] ; add each integer to sumadd esi,4 ; point to next integerloop L1 ; repeat for array sizeret ; sum is in EAX

ArraySum ENDP


Exception

• There is an important exception to our standing rule about saving

registers that applies when a procedure uses a register to return a

value. In this case, the return register should not be pushed and

popped. For example, in the ArraySum procedure, if we were to

push and pop EAX, the procedure return value would be lost: ArraySum PROCpush esi ; save ESI, ECXpush ecxpush eaxmov eax,0 ; set the sum to zero

L1:add eax,[esi] ; add each integer to sumadd esi,4 ; point to next integerloop L1 ; repeat for array sizepop ecx ; restore ECX, ESIpop esi

pup eax ; Lost The sumret ; sum is in EAX

ArraySum ENDP

Documents

Nested Procedure calls and Flowcharts