Machine-Level Programming IV Control

Ithaca College
Carnegie Mellon
Machine-Level Programming IV Control

Comp 21000: Introduction to Computer Organization & Systems
March 2016 Systems book chapter 3*
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 1

Ithaca College
Today
 Control: Condition codes
 Conditional branches
 Loops
 Switch Statements

Ithaca College
Processor State (x86-64, Partial)

 Information about
currently executing Registers
program %rax %r8
▪ Temporary data %rbx %r9
( %rax, … ) %rcx %r10
▪ Location of runtime stack %rdx %r11
( %rsp ) %rsi %r12
▪ Location of current code %rdi %r13
control point %rsp %r14
( %rip, … )
%rbp %r15
▪ Status of recent tests
( CF, ZF, SF, OF )
%rip Instruction pointer
Current stack top
CF ZF SF OF Condition codes
Ithaca College
Condition Codes (Implicit Setting)

 Single bit registers
▪CF Carry Flag (for unsigned) SF Sign Flag (for signed)
▪ZF Zero Flag OF Overflow Flag (for signed)
 Implicitly set (think of it as side effect) by arithmetic operations

Example: addq Src,Dest ↔ t = a+b
CF set if carry out from most significant bit (unsigned overflow)
ZF set if t == 0
SF set if t < 0 (as signed)
OF set if two’s-complement (signed) overflow
(a>0 && b>0 && t<0) || (a<0 && b<0 && t>=0)
 Not set by leaq instruction

Condition Codes
 Examples: assume %rax contains 20
addl $10, %rax CF  0
ZF  0
SF  0
OF  0
subl $50, %rax CF  0 Note that these flags are set just
like we talked about in chapter 2!
ZF  0
SF  1
OF  0

Condition Codes
 Single Bit Registers
CF Carry Flag SF Sign Flag
ZF Zero Flag OF Overflow Flag
 Also implicitly Set By logical Operations
xorl Src,Dest
C analog: t = a ^ b (a = Src, b = Dest)
▪ CF set to 0
▪ ZF set if t == 0
▪ SF set if t < 0
▪ OF set to 0
▪ For shift operations:
▪ CF set to last bit shifted out
▪ OF set to 0

Condition Codes (Implicit Setting)
 There are no Boolean types in assembly language.
 There is no concept of Boolean operators in assembly
language.
 So what is there?
▪ Bits
▪ All we can do is look at bits. What those bits mean is determined by the
context of the program.
▪ Instructions set flags.
▪ Other instructions take action based on the bits in those flags.
▪ Don’t think about it as comparison as in the C language sense.

Ithaca College
Condition Codes (Explicit Setting: Compare)

 Explicit Setting by Compare Instruction
▪cmpq Src2, Src1
▪cmpq 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 (as signed)
▪OF set if two’s-complement (signed) overflow
(a>0 && b<0 && (a-b)<0) || (a<0 && b>0 && (a-b)>0)
Note: notice that the operands are in reverse order; b is the first operand , but
we compute a – b!
Note 2: there are also cmpw and cmpb instructions.

Example %rax 0000 0000
cmpl %rax, %rcx %rcx 0000 0010
do %rcx - %rax
%rdx 0000 0000
then set condition codes
NO other action taken! %rbx 0000 0000
Condition codes
%rsi
CF ZF SF OF
%rdi
?? ?? ?? ??
%rsp
%rbp

Example %rax 0000 0000
cmpl %rax, %rcx %rcx 0000 0010
do %rcx - %rax
%rdx 0000 0000
then set condition codes
NO other action taken! %rbx 0000 0000
Condition codes
%rsi
CF ZF SF OF
%rdi
0 0 0 0
%rsp
%rbp

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.
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ÔF)&~ZF Greater (Signed)
setge ~(SFÔF) Greater or Equal (Signed)
setl (SFÔF) Less (Signed)
setle (SFÔF)|ZF Less or Equal (Signed)
seta ~CF&~ZF Above (unsigned)
setb CF Below (unsigned)
x86-64 Integer Registers
%rax %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

Reading condition codes
 Consider:
setl D (SFÔF) Less (Signed <) D  (SFÔF)
 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

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
setl D ; D  (SFÔF)
 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 00000000 or 00000001
depending on the value of (SFÔF)

 Example: assume %rax holds 20 and %rdx holds 50
cmpq %rax, %rdx
50 – 20, SF  0, OF  0
setl %al setl D ; D  (SFÔF)
%al  0 ^ 0 = 00000000
 Example: assume %rax holds 0x8000001 and %rdx holds 20

cmpq %rax, %rdx
20 – (-2147483647) , SF  1, OF  1
setl %al
%al  1 ^ 1 = 00000000 setq gives false;
20 is not less than
-2147483647

 Example: assume %rax holds 20 and %rdx holds 0x8000001
cmpq %rax, %rdx
(-2147483647) - 20 , SF  0, OF  1
0x80000001 + 0xFFFFFFEC
= 0x7FFFFFED (note that 7 = 0111)
setl %al
%al  0 ^ 1 = 00000001 setq gives true;
-2147483647 is less
than 20

Setg Greater (Signed)
~(SFÔF)&~ZF
First do an arith, logical, ~SF&~OF If this is zero, can’t be >

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?

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)
int gt (long x, long y)
{ %rdi Argument x
return x > y; %rsi Argument y
}
%rax Return value
cmpq %rsi, %rdi # Compare x:y

setg %al # Set when >
movzbl %al, %rax # Zero rest of %rax
ret
Ithaca College
Reading Condition Codes (Cont.)

Register Use(s)
%rax %ah %al
%rdi Argument x
%rdx %dh %dl
%rsi Argument y All 0’s:
%rax Return value 0000000000000000000000000 %rcx %ch %cl
%rbx %bh %bl
Either
00000000 %rsi
or
int gt (long x, long y) 00000001 %rdi
{
%rsp
return x > y;
} %rbp
cmpq %rsi, %rdi # Compare x:y

setg %al # Set when >
movzbl %al, %rax # Zero rest of %rax
ret
Ithaca College
Today
 Control: Condition codes
 Conditional branches
 Loops
 Switch Statements

Jumping
 A jump instruction causes execution to jump to a new
address
▪ Really just puts the argument of the jump into the EIP
▪ Jump destinations are usually indicated by a label
▪ A label marks a place in code
1 xorq %rax, %rax

2 jmp .L1
3 movq (%rax), %rdx
4 .L1:
popq %rdx
▪ The instruction jmp .L1 causes program to skip line 3

▪ jmp is an unconditional jump instruction
▪ Note that we wouldn’t really use the code this way!

Jumping
 A jump instruction has two types of arguments
▪ Direct jumps. Target is part of the instruction
Use a label
▪
▪ Indirect jumps. Target read from a register or memory.
▪ Use a ‘*’ followed by an operand specifier
jmp *%eax
or
jmp *(%eax)
▪ Any addressing mode can be used

▪ Note that jmp is an unconditional jump instruction

Jumping
 Other jump instructions are conditional
▪ Either jump or continue executing at next instruction in the code
▪ Depends on some combination of the condition codes
▪ Names and conditions match the set instructions.
▪ Conditional jumps can only be direct
 Assembler changes labels into actual memory addresses

▪ See section 3.6.3 of the book
▪ Not very important now; will be very important in chapter 7

Ithaca College
Jumping
 jX Instructions
▪ Jump to different part of code depending on condition codes
jX Condition Description
jmp 1 Unconditional
je ZF Equal / Zero
jne ~ZF Not Equal / Not Zero
js SF Negative
jns ~SF Nonnegative
jg ~(SFÔF)&~ZF Greater (Signed)
jge ~(SFÔF) Greater or Equal (Signed)
jl (SFÔF) Less (Signed)
jle (SFÔF)|ZF Less or Equal (Signed)
ja ~CF&~ZF Above (unsigned)
jb CF Below (unsigned)

jg Greater (Signed)
~(SFÔF)&~ZF
First do an arith, logical, ~SF&~OF If this is zero, can’t be >

cmp or test.
Then use the flags If the overflow flag is set, can’t be > if we did a
cmpq or testq as the previous instruction.
Why?

Ithaca College
Conditional Branch Example (Old Style)

 Generation
nori> gcc –Og -S –fno-if-conversion control.c
absdiff:
long absdiff cmpq %rsi, %rdi # x:y
(long x, long y) jle .L4
{ movq %rdi, %rax
long result; subq %rsi, %rax
if (x > y) ret
result = x-y; .L4: # x <= y
else movq %rsi, %rax
result = y-x; subq %rdi, %rax
return result; ret
}
Register Use(s)
%rdi Argument x
%rsi Argument y
%rax Return value
Ithaca College
Expressing with Goto Code

 C allows goto statement
 Jump to position designated by label
long absdiff long absdiff_j

(long x, long y) (long x, long y)
{ {
long result; long result;
if (x > y) int ntest = x <= y;
result = x-y; if (ntest) goto Else;
else result = x-y;
result = y-x; goto Done;
return result; Else:
} result = y-x;
Done:
return result;
Generally considered bad coding style }

Ithaca College

absdiff:
long absdiff_j cmpq %rsi, %rdi # x:y
{ movq %rdi, %rax
int ntest = x <= y; ret
if (ntest) goto Else; .L4: # x <= y
result = x-y; movq %rsi, %rax
goto Done; subq %rdi, %rax
Else: ret
result = y-x;
Done: Register Use(s)
return result;
%rdi Argument x
}
%rsi Argument y
%rax Return value
Ithaca College

absdiff:
{ movq %rdi, %rax
Else: ret
result = y-x;
return result;
%rdi Argument x
}
%rsi Argument y
%rax Return value
Ithaca College

absdiff:
{ movq %rdi, %rax
Else: ret
result = y-x;
return result;
%rdi Argument x
}
%rsi Argument y
%rax Return value
Ithaca College

absdiff:
{ movq %rdi, %rax
Else: ret
result = y-x;
return result;
%rdi Argument x
}
%rsi Argument y
%rax Return value
Example 2
 Download ifStmt.c
 gcc –O0 –o ifStmt –fno-if-conversion ifStmt.c
 gdb ifStmt
 In gdb: disass testIf1
int testIf1(int x, int y)

{
int result;
if (x < y)
result = x * 4;
else
result = y * 4;
return result;
}
Register Use(s)
Example 2 continued… %rdi Argument x

%rsi Argument y
pushq %rbp
movq %rsp, %rbp Setting up the %rax Return value
movq %rdi, -8(%rbp) runtime stack
movq %rsi, -16(%rbp)
movq -8(%rbp), %rsi
if x - y >= 0
cmpq -16(%rbp), %rsi
jump int testIf1(int x, int y)
jge LBB0_2 {
movq -8(%rbp), %rax else calculate int result;
shlq $2, %rax x=x*4 if (x < y)
movq %rax, -24(%rbp) and jump result = x * 4;
jmp LBB0_3 else
LBB0_2: result = y * 4;
movq -16(%rbp), %rax Calculate y=y*4 return result;
shlq $2, %rax
}
movq %rax, -24(%rbp)
LBB0_3:
movq -24(%rbp), %rax Set up the return
popq %rbp value
retq
Ithaca College
General Conditional Expression Translation

(Using Branches)
C Code
val = Test ? Then_Expr : Else_Expr;
val = x>y ? x-y : y-x;
▪ Test Is an expression returning an

Goto Version integer
ntest = !Test; ▪ = 0 interpreted as false
if (ntest) goto Else;
val = Then_Expr; ▪ ≠ 0 interpreted as true
goto Done;
Else: ▪ Create separate code regions for
val = Else_Expr;
then & else expressions
Done:
. . . ▪ Execute appropriate one

Ithaca College
Using Conditional Moves

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

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ÔF)&~ZF Greater (Signed)
cmovge S,R cmovnl ~(SFÔF) Greater or Equal (Signed)
cmovl S,R cmovnge (SFÔF) Less (Signed)
cmovle S,R cmovng (SFÔF)|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)
Ithaca College
Conditional Move Example

long absdiff
(long x, long y)
{ Register Use(s)
long result;
if (x > y) %rdi Argument x
result = x-y; %rsi Argument y
else
%rax Return value
result = y-x;
return result;
}
absdiff:
movq %rdi, %rax # x
subq %rsi, %rax # result = x-y
movq %rsi, %rdx
subq %rdi, %rdx # eval = y-x
cmpq %rsi, %rdi # x:y
cmovle %rdx, %rax # if <=, result = eval
ret
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
Risky Computations instructions.
val = p ? *p : 0;

 May have undesirable effects (always dereference p but it may be null!)
Computations with side effects
val = x > 0 ? x*=7 : x+=3;

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

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

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)
Ithaca College
Summary
 Today
▪ Control: Condition codes
▪ Conditional branches & conditional moves
 Next Time
▪ Loops
▪ Switch statements
▪ Stack
▪ Call / return
▪ Procedure call discipline

Machine-Level Programming IV Control

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Machine-Level Programming IV Control

Uploaded by

Copyright:

Available Formats

Ithaca College

Machine-Level Programming IV Control

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 1

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 2

Processor State (x86-64, Partial)

Condition Codes (Implicit Setting)

 Implicitly set (think of it as side effect) by arithmetic operations

 Not set by leaq instruction

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 5

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 6

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 7

Condition Codes (Explicit Setting: Compare)

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 8

cmpl %rax, %rcx %rcx 0000 0010

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 9

cmpl %rax, %rcx %rcx 0000 0010

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 10

Condition Codes (Explicit Setting: Test)

▪Sets condition codes based on value of Src1 & Src2

Reading Condition Codes

%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

cmpq %rax, %rdx

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 14

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 15

 Example: assume %rax holds 0x8000001 and %rdx holds 20

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 16

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 17

First do an arith, logical, ~SF&~OF If this is zero, can’t be >

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 18

Reading Condition Codes (Cont.)

cmpq %rsi, %rdi # Compare x:y

Reading Condition Codes (Cont.)

cmpq %rsi, %rdi # Compare x:y

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 21

1 xorq %rax, %rax

▪ The instruction jmp .L1 causes program to skip line 3

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 22

▪ Any addressing mode can be used

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 23

 Assembler changes labels into actual memory addresses

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 24

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 25

First do an arith, logical, ~SF&~OF If this is zero, can’t be >

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 26

Conditional Branch Example (Old Style)

Expressing with Goto Code

long absdiff long absdiff_j

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 28

Expressing with Goto Code

Expressing with Goto Code

Expressing with Goto Code

Expressing with Goto Code

int testIf1(int x, int y)

Example 2 continued… %rdi Argument x

General Conditional Expression Translation