1. CS 301 Fall 2002 Control Structures
Slide Set 5
9/21/2018

2. CS 301 Fall 2001 – Chapter 7
Slides by Prof. Hartman, following “IBM PC Assembly Language Programming” by Peter Abel
9/21/2018

3. The Stack Three main uses Saving return addresses for subroutines
Passing data to subroutines
Temporarily saving contents of registers so the program can use those registers for computation.
9/21/2018

4. The Stack 2
SS contains the address of the beginning of the stack, SP contains the size of the stack (and thus points to one address past the end of the stack)
The stack begins storing data at the highest location in the segment and stores data downward through memory using PUSH and POP (and other) instructions.
9/21/2018

5. Stack Instructions
PUSH, POP to and from general register, segment register, or memory
PUSHA, POPA – save and restore contents of all general purpose registers (16 bytes)
PUSHF, POPF – save and restore contents of the flags
PUSHAD, POPAD – save and restore contents of all extended registers. (32 bytes)
9/21/2018

6. Instruction Execution and Addressing
Processor steps in executing an instruction
Fetch next instruction from memory and place it in instruction queue
Decode the instruction: calculate addresses for memory references, deliver data to the ALU, increment IP
Execute the instruction: perform the operation, store results in register or memory, set any required flags.
9/21/2018

7. Address types Short – Same segment, one byte offset, -128 to +127
Near – Same segment, two byte (80286 and earlier) or four byte (80386 and later) offset.
Far – Different segment
9/21/2018

8. Branching Instructions
JMP can jump to Short, Near, or Far addresses
Jxx can jump to Short or Near (80386+) addresses
LOOP can jump to Short addresses
CALL can jump to Near or Far addresses
9/21/2018

9. Short Jumps
If the label is before the jump (jumping back) NASM will automatically choose a Short jump if possible.
If the label is after the jump (jumping forward) NASM will always use a Near jump, unless you specify
jmp short label
9/21/2018

10. NASM labels
Labels beginning with a period are “local” labels – they are associated with the most recent non-local label.
9/21/2018

11. Converting high-level control structures – if/else
if ( condition ) {
// body of then_block }
else {
// body of else_block
In C is roughly equivalent to the following assembly code. Note the use of local labels.
; code to set flags based on condition
jxx .else_block ; select xx to branch if false
; code for body of then_block
jmp .endif
.else_block:
; code for body of else_block
.endif:
9/21/2018

12. Converting high-level control structures – while
while ( condition ) {
// body of loop }
In C is roughly equivalent to the following assembly code. Note the use of local labels.
.while:
; code to set flags based on condition
jxx .endwhile ; select xx so that branches if false
; body of loop
jmp .while
.endwhile:
9/21/2018

13. Converting high-level control structures – do/while
// body of loop
} while ( condition )
In C is roughly equivalent to the following assembly code. Note the use of local labels.
.do:
; code for body of loop
; code to set flags based on condition
jxx .do ; select xx so branches if true
9/21/2018

14. Converting high-level control structures – for
for(int i=0;i<10;++i) {
// body of loop }
In C is roughly equivalent to the following assembly code. Note the use of local labels.
mov ecx, 10
.for:
; code for body of loop
dec ecx jnz .for
9/21/2018

15. LOOP instruction LOOP label LOOPE/LOOPZ label LOOPNE/LOOPNZ label
Decrements ecx (or cx in 16-bit mode) and branches to label unless ecx is then zero.
LOOPE/LOOPZ label
Adds condition that ZF=1.
LOOPNE/LOOPNZ label
Adds condition that ZF=0.
9/21/2018

16. Converting high-level control structures – for
for(int i=0;i<10;++i) {
// body of loop }
In C is roughly equivalent to the following assembly code. Note the use of local labels.
mov ecx, 10
.for:
; code for body of loop
loop .for ;
9/21/2018

17. CALL and RET CALL proc_name RET [n]
Pushes IP, sets IP to offset of proc_name (and clears processor’s prefetch instruction queue)
RET [n]
Pops IP (and clears processor’s prefetch instruction queue)
Possibly “pops” n arguments from the stack
9/21/2018

18. Passing parameters
Can pass parameters by reference (address) or value.
Can pass parameters in registers or on stack.
Examples using registers: regpassing.asm
9/21/2018

19. Passing parameters on the stack 1
Push parameters on the stack before the CALL instruction
Procedure doesn’t pop them off, it accesses them directly on the stack:
Avoids having to pop off return address then put it back on
Allows using the parameter multiple times
Need to use indirect addressing
Examples using stack: stackpassing.asm
9/21/2018

20. Indirect Addressing
Can add registers and/or constants and/or a location and get at what is located in the result
MOV eax,[data]
MOV eax,[ebx]
MOV eax,[data+ebx]
MOV eax,[ebx+2]
MOV eax,[ebx*8+esp+4]
9/21/2018