1. Condition Codes Single Bit Registers
CF Carry Flag SF Sign Flag
ZF Zero Flag OF Overflow Flag
Implicitly Set By Arithmetic Operations, except leal
cmpl and testl jX

2. Set your own CC setX Instructions
Set single byte based on combinations of condition codes
One of 8 addressable byte registers
Embedded within first 4 integer registers
Does not alter remaining 3 bytes
Typically use movzbl to finish job
%eax
%ah
%al
%edx
%dh
%dl
%ecx
%ch
%cl
%ebx
%bh
%bl
%esi
int gt (int x, int y) {
return x > y; }
%edi
%esp
Body
%ebp
movl 12(%ebp),%eax # eax = y
cmpl %eax,8(%ebp) # Compare x : y
setg %al # al = x > y
movzbl %al,%eax # Zero rest of %eax
Note inverted ordering!

3. t = test_expr; if (t) if (!t) then-statement; goto false; else
do then-statement;
goto done;
false:
do else-statement;
done:
if (t)
then-statement;
else
else-statement;
if (!Test)
goto done;
loop:
Body
if (Test)
goto loop
done:
while (Test)
Body

4. Body for (Init; Test; Update ) Init; if (!Test) goto done; loop: Body
goto loop;
done:

5. 3.6.7.Switch Statements Implementation Options Series of conditionals
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 '?'; }
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

6. Jump Table Structure Jump Targets Switch Form Jump Table Targ0: Targ1:
Code Block
Targ0: 1
Targ1: 2
Targ2:
n–1
Targn-1: •
switch(op) {
case val_0:
Block 0
case val_1:
Block 1
• • •
case val_n-1:
Block n–1 }
Targ0
Targ1
Targ2
Targn-1 •
jtab:
Approx. Translation
target = JTab[op];
goto *target;

7. Switch Statement Example
Branching Possibilities
Enumerated Values
ADD 0
MULT 1
MINUS 2
DIV 3
MOD 4
BAD 5
typedef enum
{ADD, MULT, MINUS, DIV, MOD, BAD}
op_type;
char unparse_symbol(op_type op){
switch (op) {
• • • }

8. Approx. Translation target = JTab[op]; goto *target; unparse_symbol:
pushl %ebp # Setup
movl %esp,%ebp # Setup
movl 8(%ebp),%eax # eax = op
cmpl $5,%eax # Compare op : 5
ja .L49 # If > 5 goto done
jmp *.L57(,%eax,4)# goto Table[op]

9. Assembly Setup Explanation
Symbolic Labels
Labels of form .LXX translated into addresses by assembler
Table Structure
Each target requires 4 bytes
Base address at .L57
Jumping
jmp .L49
Jump target is denoted by label .L49
jmp *.L57(,%eax,4)
Start of jump table denoted by label .L57
Register %eax holds op
Must scale by factor of 4 to get offset into table
Fetch target from effective Address .L57 + op*4

10. Jump Table Targets & Completion Table Contents Enumerated Values ADD 0
movl $43,%eax # ’+’
jmp .L49
.L52:
movl $42,%eax # ’*’
.L53:
movl $45,%eax # ’-’
.L54:
movl $47,%eax # ’/’
.L55:
movl $37,%eax # ’%’
.L56:
movl $63,%eax # ’?’
# Fall Through to .L49
.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
Enumerated Values
ADD 0
MULT 1
MINUS 2
DIV 3
MOD 4
BAD 5

11. Switch Statement Completion
.L49: # Done:
movl %ebp,%esp # Finish
popl %ebp # Finish
ret # Finish
Puzzle
What value returned when op is invalid?
Answer
Register %eax set to op at beginning of procedure
This becomes the returned value
Advantage of Jump Table
Can do k-way branch in O(1) operations

12. Object Code Setup Label .L49 becomes address 0x804875c
Label .L57 becomes address 0x8048bc0
<unparse_symbol>:
: pushl %ebp
: 89 e movl %esp,%ebp
804871b: 8b movl 0x8(%ebp),%eax
804871e: 83 f cmpl $0x5,%eax
: ja c <unparse_symbol+0x44>
: ff c0 8b jmp *0x8048bc0(,%eax,4)

13. Sparse Switch Example Not practical to use jump table
/* Return x/111 if x is multiple
&& <= 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; }
Not practical to use jump table
Would require 1000 entries
Obvious translation into if-then-else would have max. of 9 tests

14. IA32/Linux Stack Frame Current Stack Frame (“Top” to Bottom) Caller
Parameters for function about to call
“Argument build”
Local variables
If can’t keep in registers
Saved register context
Old frame pointer
Caller Stack Frame
Return address
Pushed by call instruction
Arguments for this call
Caller
Frame
Arguments
Frame Pointer
(%ebp)
Return Addr
Old %ebp
Saved
Registers +
Local
Variables
Argument
Build
Stack Pointer
(%esp)

15. IA32/Linux Register Usage
Integer Registers
Two have special uses
%ebp, %esp
Three managed as callee-save
%ebx, %esi, %edi
Old values saved on stack prior to using
Three managed as caller-save
%eax, %edx, %ecx
Do what you please, but expect any callee to do so, as well
Register %eax also stores returned value
%eax
Caller-Save
Temporaries
%edx
%ecx
%ebx
Callee-Save
Temporaries
%esi
%edi
%esp
Special
%ebp

16. Recursive Factorial Registers %eax used without first saving
.globl rfact
.type
rfact:
pushl %ebp
movl %esp,%ebp
pushl %ebx
movl 8(%ebp),%ebx
cmpl $1,%ebx
jle .L78
leal -1(%ebx),%eax
pushl %eax
call rfact
imull %ebx,%eax
jmp .L79
.align 4
.L78:
movl $1,%eax
.L79:
movl -4(%ebp),%ebx
movl %ebp,%esp
popl %ebp
ret
Recursive Factorial
int rfact(int x) {
int rval;
if (x <= 1)
return 1;
rval = rfact(x-1);
return rval * x; }
Registers
%eax used without first saving
%ebx used, but save at beginning & restore at end

17. Summary The Stack Makes Recursion Work
Private storage for each instance of procedure call
Instantiations don’t clobber each other
Addressing of locals + arguments can be relative to stack positions
Can be managed by stack discipline
Procedures return in inverse order of calls
IA32 Procedures Combination of Instructions + Conventions
Call / Ret instructions
Register usage conventions
Caller / Callee save
%ebp and %esp
Stack frame organization conventions