CS 301 Fall 2002 Control Structures

1. CS 301 Fall 2002Control Structures Slide Set 5

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

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.

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.

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)

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.

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

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. 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

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

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:

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:

13. Converting high-level control structures – do/while do { // 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

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 ecxjnz .for

15. LOOP instruction • LOOP 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.

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 ;

17. CALL and RET • CALL proc_name • 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

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

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

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]