1. Carnegie Mellon
Ithaca College
Machine-Level Programming IV Control Comp 21000: Introduction to Computer Organization & Systems Systems book chapter 3*

2. Today Control: Condition codes Conditional branches Loops
Ithaca College
Today
Control: Condition codes
Conditional branches
If-then-else statements
Conditional moves
Loops
Switch Statements

3. Using Conditional Moves
Ithaca College
Using Conditional Moves
Conditional Move Instructions
Instruction supports:
if (Test) Dest  Src
Supported in post-1995 x86 processors
GCC tries to use them
But, only when known to be safe
Why?
Branches are very disruptive to instruction flow through pipelines
Conditional moves do not require control transfer
C Code
val = Test
? Then_Expr
: Else_Expr;
Goto Version
result = Then_Expr;
eval = Else_Expr;
nt = !Test;
if (nt) result = eval;
return result;

4. Conditional Move cmovX Instructions
Ithaca College
Conditional Move
* source/destination may be 16, 32, or 64 bits (not 8). No size suffix: assembler infers the operand length based on destination register
cmovX Instructions
Jump to different part of code depending on condition codes jX
Synonym
Condition
Description
cmove S*,R*
cmovz ZF
Equal / Zero
cmovne S,R
cmovnz
~ZF
Not Equal / Not Zero
cmovs S,R SF
Negative
cmovns S,R
~SF
Nonnegative
cmovg S,R
cmovnle
~(SF^OF)&~ZF
Greater (Signed)
cmovge S,R
cmovnl
~(SF^OF)
Greater or Equal (Signed)
cmovl S,R
cmovnge
(SF^OF)
Less (Signed)
cmovle S,R
cmovng
(SF^OF)|ZF
Less or Equal (Signed)
cmova S,R
cmovnbe
~CF&~ZF
Above (unsigned)
cmovae S,R
cmovnb
~CF
Above or equal (unsigned)
cmovb S,R
cmovnae CF
Below (unsigned)
cmovbe S,R
cmovna
CF | ZF
Below or equal (unsigned)

5. Conditional Move Example
Ithaca College
Conditional Move Example
long absdiff
(long x, long y) {
long result;
if (x > y)
result = x-y;
else
result = y-x;
return result; }
Register
Use(s)
%rdi
Argument x
%rsi
Argument y
%rax
Return value
absdiff:
movq %rdi, %rax # x
subq %rsi, %rax # result = x-y
movq %rsi, %rdx # y
subq %rdi, %rdx # eval = y-x
cmpq %rsi, %rdi # x:y
cmovle %rdx, %rax # if <=, result = eval
ret

6. Bad Cases for Conditional Move
Ithaca College
Bad Cases for Conditional Move
Expensive Computations
val = Test(x) ? Hard1(x) : Hard2(x);
Both values get computed
Only makes sense when computations are very simple
In general, gcc only uses conditional moves when the two expressions can be computed very easily, e.g., single instructions.
Risky Computations
val = p ? *p : 0;
Both values get computed
May have undesirable effects (always dereference p but it may be null!)
Computations with side effects
val = x > 0 ? x*=7 : x+=3;
Both values get computed
Must be side-effect free

7. Practice Problem Generation Register Use(s) %rdi Argument x %rsi
Ithaca College
Practice Problem
Register
Use(s)
%rdi
Argument x
%rsi
Argument y
%rax
Return value
Generation
test:
leaq 0(,%rdi,8), %rax
testq %rsi, %rsi
jle .L4
movq %rsi, %rax
subq %rdi, %rax
movq %rdi, %rdx
andq %rsi, %rdx
cmpq %rsi, %rdi
cmovge %rdx, %rax
ret
.L4:
addq %rsi, %rdi
cmpq %-2, %rsi
cmovle %rdi, %rax
long test
(long x, long y) {
long val = _________;
if (_________){
if (__________){
val = ________;
else
} else if (________)
return val; }
test %rsi, %rsi
Does %rsi & %rsi
long val = 8*x;
if (y > 0) {
if (x < y)
val = y - x;
else
val = x & y;
}else if (y <= -2)
val = x*y;
return val;

8. Practice Problem Generation Register Use(s) %rdi Argument x %rsi
Ithaca College
Practice Problem
Register
Use(s)
%rdi
Argument x
%rsi
Argument y
%rax
Return value
Generation
test:
leaq 0(,%rdi,8), %rax
testq %rsi, %rsi
jle .L4
movq %rsi, %rax
subq %rdi, %rax
movq %rdi, %rdx
andq %rsi, %rdx
cmpq %rsi, %rdi
cmovge %rdx, %rax
ret
.L4: # x <= y
addq %rsi, %rdi
cmpq %-2, %rsi
cmovle %rdi, %rax
long test
(long x, long y) {
long val = 8*x;
if (y > 0){
if (x < y){
val = y - x;
else
val = x & y;
} else if (y <= -2)
val = x + y;
return val; }
long val = 8*x;
if (y > 0) {
if (x < y)
val = y - x;
else
val = x & y;
}else if (y <= -2)
val = x + y;
return val;

9. Condition Codes (Explicit Setting: Test)
Ithaca College
Condition Codes (Explicit Setting: Test)
Explicit Setting by Test instruction
testq Src2, Src1
testq b,a like computing a&b without setting destination
Sets condition codes based on value of Src1 & Src2
Useful to have one of the operands be a mask
CF set to 0
ZF set when a&b == 0
SF set when a&b < 0
OF set to 0
Note: typically the same operand is repeated to test whether it is negative, zero, or positive:
testl %rax, %rax sets the condition codes depending on the value in %rax
Note 2: there are also testl, testw and testb instructions.

10. Reading Condition Codes
Ithaca College
Reading Condition Codes
SetX Instructions
Set low-order byte of destination to 0 or 1 based on combinations of condition codes
Does not alter remaining 7 bytes
SetX
Condition
Description
sete ZF
Equal / Zero
setne
~ZF
Not Equal / Not Zero
sets SF
Negative
setns
~SF
Nonnegative
setg
~(SF^OF)&~ZF
Greater (Signed)
setge
~(SF^OF)
Greater or Equal (Signed)
setl
(SF^OF)
Less (Signed)
setle
(SF^OF)|ZF
Less or Equal (Signed)
seta
~CF&~ZF
Above (unsigned)
setb CF
Below (unsigned)

11. x86-64 Integer Registers %rax %r8 %rbx %r9 %rcx %r10 %rdx %r11 %rsi
%al
%r8
%r8b
%rbx
%bl
%r9
%r9b
%rcx
%cl
%r10
%r10b
%rdx
%dl
%r11
%r11b
%rsi
%sil
%r12
%r12b
%rdi
%dil
%r13
%r13b
%rsp
%spl
%r14
%r14b
%rbp
%bpl
%r15
%r15b
Can reference low-order byte

12. Reading condition codes
Consider:
setl D (SF^OF) Less (Signed <) D  (SF^OF)
First compare two numbers, a and b where both are in 2’s complement form using an arithmetic, logical, test or cmp instruction
Then use setX to set a register with the result of the test
cmpq %rax, %rdx
setl %al puts the result in byte register %al

13. Reading condition codes (cont)
Assume a is in %rax and b in %rdx
cmpq %rax, %rdx
setl %al puts the result in byte register %al
First instruction sets the condition code.
cmpq computes b – a
If b < a then b – a < 0 If there is no overflow, this is indicated by SF
If there is positive overflow (b – a is large), we have b – a < 0 but OF is set
If there is negative overflow (b – a is very small), we have b – a > 0 but OF is set
In either case the sign flag will indicate the opposite of the sign of the true difference. Hence, use exclusive-or of the OF and SF
Second instruction sets the %al register to or depending on the value of (SF^OF)
setl D ; D  (SF^OF)

14. Reading condition codes (cont)
Example: assume %rax holds 20 and %rdx holds 50
cmpq %rax, %rdx
50 – 20, SF  0, OF  0
setl %al
%al  0 ^ 0 =
Example: assume %rax holds 0x and %rdx holds 20
20 – ( ) , SF  1, OF  1
%al  1 ^ 1 = setq gives false;
20 is not less than
setl D ; D  (SF^OF)

15. Reading condition codes (cont)
Example: assume %rax holds 20 and %rdx holds 0x
cmpq %rax, %rdx
( ) - 20 , SF  0, OF  1
0x xFFFFFFEC
= 0x7FFFFFED (note that 7 = 0111)
setl %al
%al  0 ^ 1 = setq gives true;
is less
than 20

16. If this is zero, can’t be >
Setg Greater (Signed)
~(SF^OF)&~ZF
~SF&~OF
If this is zero, can’t be >
First do an arith, logical, cmp or test.
Then use the flags
If the overflow flag is set, can’t be > if we did a cmpl or testl as the previous instruction. Why? CF ZF SF OF
Condition codes

17. Reading Condition Codes (Cont.)
Ithaca College
Reading Condition Codes (Cont.)
SetX Instructions:
Set single byte based on combination of condition codes
One of addressable byte registers
Does not alter remaining bytes
Typically use movzbl to finish job
32-bit instructions also set upper 32 bits to 0
Register
Use(s)
%rdi
Argument x
%rsi
Argument y
%rax
Return value
int gt (long x, long y) {
return x > y; }
cmpq %rsi, %rdi # Compare x:y
setg %al # Set when >
movzbl %al, %rax # Zero rest of %rax
ret

18. Reading Condition Codes (Cont.)
Ithaca College
Reading Condition Codes (Cont.)
Register
Use(s)
%rdi
Argument x
%rsi
Argument y
%rax
Return value
%rax
%ah
%al
%rdx
%dh
%dl
All 0’s:
%rcx
%ch
%cl
%rbx
%bh
%bl
Either or
%rsi
%rdi
int gt (long x, long y) {
return x > y; }
%rsp
%rbp
cmpq %rsi, %rdi # Compare x:y
setg %al # Set when >
movzbl %al, %rax # Zero rest of %rax
ret

19. Summarizing C Control Assembler Control Standard Techniques
Ithaca College
Summarizing
C Control
if-then-else
do-while
while, for
switch
Assembler Control
Conditional jump
Conditional move
Indirect jump (via jump tables)
Compiler generates code sequence to implement more complex control
Standard Techniques
Loops converted to do-while or jump-to-middle form
Large switch statements use jump tables
Sparse switch statements may use decision trees (if-elseif-elseif-else)
long val = 8*x;
if (y > 0) {
if (x < y)
val = y - x;
else
val = x & y;
}else if (y <= -2)
val = x*y;
return val;

20. Summary Today Next Time Control: Condition codes
Ithaca College
Summary
Today
Control: Condition codes
Conditional branches & conditional moves
Next Time
Loops
Switch statements
Stack
Call / return
Procedure call discipline