Transcript CS 301 Fall 2002 Control Structures

CS 301 Fall 2002
Control Structures
Slide Set 5
7/7/2015
1
CS 301 Fall 2001 – Chapter 7
Slides by Prof. Hartman, following
“IBM PC Assembly Language
Programming” by Peter Abel
7/7/2015
2
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.

7/7/2015
3
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.

7/7/2015
4
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)

7/7/2015
5
Instruction Execution and
Addressing

Processor steps in executing an instruction
1.
2.
3.
7/7/2015
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.
6
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

7/7/2015
7
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

7/7/2015
8
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
7/7/2015
9
NASM labels

Labels beginning with a period are “local”
labels – they are associated with the most
recent non-local label.
7/7/2015
10
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:
7/7/2015
11
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:
7/7/2015
12
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
7/7/2015
13
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
7/7/2015
14
LOOP instruction

LOOP label


LOOPE/LOOPZ label


Decrements ecx (or cx in 16-bit mode) and
branches to label unless ecx is then zero.
Adds condition that ZF=1.
LOOPNE/LOOPNZ label

7/7/2015
Adds condition that ZF=0.
15
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
;
7/7/2015
16
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

7/7/2015
17
Passing parameters
Can pass parameters by reference (address)
or value.
 Can pass parameters in registers or on stack.
 Examples using registers: regpassing.asm

7/7/2015
18
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
7/7/2015
19
Indirect Addressing

Can add registers and/or constants and/or a
location and get at what is located in the
result
MOV
 MOV
 MOV
 MOV
 MOV

7/7/2015
eax,[data]
eax,[ebx]
eax,[data+ebx]
eax,[ebx+2]
eax,[ebx*8+esp+4]
20