1 / 20

CS 301 Fall 2002 Control Structures

CS 301 Fall 2002 Control Structures. Slide Set 5. CS 301 Fall 2001 – Chapter 7. Slides by Prof. Hartman, following “IBM PC Assembly Language Programming” by Peter Abel . The Stack. Three main uses Saving return addresses for subroutines Passing data to subroutines

butch
Download Presentation

CS 301 Fall 2002 Control Structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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]

More Related