Download Lecture Slides on Control Flow - Machine-Level Programming II | CS 367 and more Study notes Computer Science in PDF only on Docsity!
Machine-Level Programming II:
Control Flow
Topics Topics
Condition Codes
Setting Testing
Control Flow
If-then-else Varieties of Loops Switch Statements lecture9.ppt
CS 367
Condition Codes
Single Bit RegistersSingle Bit Registers
CF Carry Flag SF Sign Flag
ZF Zero Flag OF Overflow Flag
Implicitly Set By Arithmetic OperationsImplicitly Set By Arithmetic Operations
addl Src, Dest
C analog: t = a + b
CF set if carry out from most significant bit
Used to detect unsigned overflow
ZF set if t == 0
SF set if t < 0
OF set if two’s complement overflow
(a>0 && b>0 && t<0) || (a<0 && b<0 && t>=0)
NotNot Set bySet by lealleal instructioninstruction
Setting Condition Codes (cont.)
Explicit Setting by Compare InstructionExplicit Setting by Compare Instruction
cmpl Src2, Src
cmpl b,a like computing a-b without setting destination
CF set if carry out from most significant bit
Used for unsigned comparisons
ZF set if a == b
SF set if (a-b) < 0
OF set if two’s complement overflow
(a>0 && b<0 && (a-b)<0) || (a<0 && b>0 && (a-b)>0)
Setting Condition Codes (cont.)
Explicit Setting by Test instructionExplicit Setting by Test instruction
testl Src2, Src
Sets condition codes based on value of Src1 & Src
Useful to have one of the operands be a mask
testl b,a like computing a&b without setting destination
ZF set when a&b == 0
SF set when a&b < 0
Jumping
jX Condition Description
jmp 1 Unconditional
je ZF Equal / Zero
jne ~ZF Not Equal / Not Zero
js SF Negative
jns ~SF Nonnegative
jg ~(SF^OF)&~ZF Greater (Signed)
jge ~(SF^OF) Greater or Equal (Signed)
jl (SF^OF) Less (Signed)
jle (SF^OF)|ZF Less or Equal (Signed)
ja ~CF&~ZF Above (unsigned)
jb CF Below (unsigned)
jXjX^ InstructionsInstructions
Jump to different part of code depending on condition codes
Conditional Branch Example
int max(int x, int y) { if (x > y) return x; else return y; } _max: pushl %ebp movl %esp,%ebp movl 8(%ebp),%edx movl 12(%ebp),%eax cmpl %eax,%edx jle L movl %edx,%eax L9: movl %ebp,%esp popl %ebp ret Body Set Up Finish
Conditional Branch Example (Cont.)
movl 8(%ebp),%edx # edx = x movl 12(%ebp),%eax # eax = y cmpl %eax,%edx # x : y jle L9 # if <= goto L movl %edx,%eax # eax = x L9: # Done: int goto_max(int x, int y) { int rval = y; int ok = (x <= y); if (ok) goto done; rval = x; done: return rval; } Skipped when x ≤ y
C allows “goto” as means
of transferring control
Closer to machine-level programming style
Generally considered bad
coding style
C Code
int fact_do (int x) { int result = 1; do { result *= x; x = x-1; } while (x > 1); return result; }
Goto Version
int fact_goto(int x) { int result = 1; loop: result *= x; x = x-1; if (x > 1) goto loop ; return result; }
“Do-While” Loop Example
Use backward branch to continue looping
Only take branch when “while” condition holds
C Code
int fact_while (int x) { int result = 1; while (x > 1) { result *= x; x = x-1; }; return result; }
First Goto Version
int fact_while_goto (int x) { int result = 1; loop: if (!(x > 1)) goto done ; result *= x; x = x-1; goto loop ; done: return result; }
“While” Loop Example
Is this code equivalent to the do-while version?
Must jump out of loop if test fails
C Code
int fact_while(int x) { int result = 1; while (x > 1) { result *= x; x = x-1; }; return result; }
Second Goto Version
int fact_while_goto (int x) { int result = 1; if (!(x > 1)) goto done ; loop: result *= x; x = x-1; if (x > 1) goto loop ; done: return result; }
Actual “While” Loop Translation
Uses same inner loop
as do-while version
Guards loop entry with
extra test
C Code
while ( Test ) Body
Do-While Version
if (! Test ) goto done ; do Body while( Test ); done :
General “While” Translation
Goto Version
if (! Test ) goto done ; loop : Body if ( Test ) goto loop ; done :
“For” Loop Example
AlgorithmAlgorithm
Exploit property that p = p 0 + 2 p 1 + 4 p 2 + … 2 n –^1 pn – 1
Gives: xp^ = z 0 · z 1 2 · ( z 2 2 ) 2 · … · (…(( zn – 12 ) 2 )…) 2
zi = 1 when pi = 0 zi = x when pi = 1
Complexity O(log p )
/* Compute x raised to nonnegative power p / int ipwr_for(int x, unsigned p) { int result; for (result = 1; p != 0; p = p>>1) { if (p & 0x1) result = x; x = xx; } return result; } n– 1 times Example 310 = 3^2 *** 3^8 = 3^2 *** ((3*^2 ) 2 ) 2
“For” → “While”
for ( Init ; Test ; Update ) Body Init ; while ( Test ) { Body Update ; }
Goto Version
Init ; if (! Test ) goto done ; loop: Body Update ; if ( Test ) goto loop ; done:
For Version While Version
Do-While Version
Init ; if (! Test ) goto done ; do { Body Update ; } while ( Test ) done :
“For” Loop Compilation
Init
result = 1
Test
p != 0
Update
p = p >> 1
Body
if (p & 0x1) result = x; x = xx; }
Goto Version
Init ; if (! Test ) goto done ; loop : Body Update ; if ( Test ) goto loop ; done : result = 1; if (p == 0) goto done ; loop : if (p & 0x1) result = x; x = xx; p = p >> 1; if (p != 0) goto loop ; done :
Switch
Statements
Implementation Options Implementation Options
Series of conditionals
Good if few cases Slow if many
Jump Table
Lookup branch target Avoids conditionals Possible when cases are small integer constants
GCC
Picks one based on case structure
Bug in example code
No default given typedef enum {ADD, MULT, MINUS, DIV, MOD, BAD} op_type; char unparse_symbol(op_type op) { switch (op) { case ADD : return '+'; case MULT: return '*'; case MINUS: return '-'; case DIV: return '/'; case MOD: return '%'; case BAD: return '?'; } }
Jump Table Structure
Code Block 0 Targ0: Code Block 1 Targ1: Code Block 2 Targ2: Code Block n– 1 Targ n -1:
Targ Targ Targ Targ n -
jtab: target = JTab[op]; goto *target; switch(op) { case val_0: Block 0 case val_1: Block 1
- • • case val_ n -1: Block n– 1 }
Switch Form
Approx. Translation
Jump Table Jump Targets
Jump Table
Enumerated Values
ADD 0
MULT 1
MINUS 2
DIV 3
MOD 4
BAD 5
.section .rodata .align 4 .L57: .long .L51 #Op = 0 .long .L52 #Op = 1 .long .L53 #Op = 2 .long .L54 #Op = 3 .long .L55 #Op = 4 .long .L56 #Op = 5
Table Contents
.L51:
movl $43,%eax # ’+’ jmp .L .L52: movl $42,%eax # ’*’ jmp .L .L53: movl $45,%eax # ’-’ jmp .L .L54: movl $47,%eax # ’/’ jmp .L .L55: movl $37,%eax # ’%’ jmp .L .L56: movl $63,%eax # ’?’
Fall Through to .L
Targets & Completion
Switch Statement Completion
PuzzlePuzzle
What value returned when op is invalid?
AnswerAnswer
Register %eax set to op at beginning of procedure
This becomes the returned value
Advantage of Jump TableAdvantage of Jump Table
Can do k -way branch in O ( 1 ) operations
.L49: # Done: movl %ebp,%esp # Finish popl %ebp # Finish ret # Finish
Object Code
SetupSetup
Label .L49 becomes address 0x804875c
Label .L57 becomes address 0x8048bc
08048718 : 8048718: 55 pushl %ebp 8048719: 89 e5 movl %esp,%ebp 804871b:8b 45 08 movl 0x8(%ebp),%eax 804871e: 83 f8 05 cmpl $0x5,%eax 8048721: 77 39 ja 804875c 8048723:ff 24 85 c0 8b jmp *0x8048bc0(,%eax,4)
Object Code (cont.)
Jump TableJump Table
Doesn’t show up in disassembled code
Can inspect using GDB
gdb code-examples
(gdb) x/6xw 0x8048bc
E xamine 6 he xadecimal format “ words” (4-bytes each) Use command “ help x ” to get format documentation
0x8048bc0 <_fini+32>:
0x
0x
0x
0x
0x
0x
Matching Disassembled Targets
8048730:b8 2b 00 00 00 movl 8048735:eb 25 jmp 8048737:b8 2a 00 00 00 movl 804873c:eb 1e jmp 804873e:89 f6 movl 8048740:b8 2d 00 00 00 movl 8048745:eb 15 jmp 8048747:b8 2f 00 00 00 movl 804874c:eb 0e jmp 804874e:89 f6 movl 8048750:b8 25 00 00 00 movl 8048755:eb 05 jmp 8048757:b8 3f 00 00 00 movl
Entry
0x 0x 0x 0x 0x 0x
Sparse Switch Example
Not practical to use
jump table
Would require 1000 entries
Obvious translation into
if-then-else would have
max. of 9 tests
/* Return x/111 if x is multiple && <= 999. -1 otherwise */ int div111(int x) { switch(x) { case 0: return 0; case 111: return 1; case 222: return 2; case 333: return 3; case 444: return 4; case 555: return 5; case 666: return 6; case 777: return 7; case 888: return 8; case 999: return 9; default: return -1; } }
Sparse Switch Code
Compares x to possible
case values
Jumps different places
depending on outcomes
movl 8(%ebp),%eax # get x cmpl $444,%eax # x: je L jg L cmpl $111,%eax # x: je L jg L testl %eax,%eax # x: je L jmp L
...
L5:
movl $1,%eax jmp L L6: movl $2,%eax jmp L L7: movl $3,%eax jmp L L8: movl $4,%eax jmp L
...
Sparse Switch Code Structure
Organizes cases as binary tree
Logarithmic performance
< ≠ (^) = > = < > = < > = < > = ≠ (^) = ≠ (^) = ≠ (^) = = ≠ = ≠
