Machine-Level Programming Ii: Arithmetic & Control

MACHINE-LEVEL
PROGRAMMING II:
ARITHMETIC & CONTROL
University of Texas at Austin
Today
• Complete addressing mode, address computation
(leal)
• Arithmetic operations
• Control: Condition codes
• Conditional branches
• While loops
2
Complete Memory Addressing Modes
• Most General Form

• D(Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]+ D]
• D: Constant “displacement” 1, 2, or 4 bytes
• Rb: Base register: Any of 8 integer registers
• Ri: Index register: Any, except for %esp
• Unlikely you’d use %ebp, either
• S: Scale: 1, 2, 4, or 8 (why these numbers?)
• Special Cases
• (Rb,Ri) Mem[Reg[Rb]+Reg[Ri]]
• D(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]+D]
• (Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]]
3
Address Computation Examples

%edx 0xf000
%ecx 0x0100
Expression Address Computation Address

0x8(%edx) 0xf000 + 0x8 0xf008
(%edx,%ecx) 0xf000 + 0x100 0xf100
(%edx,%ecx,4) 0xf000 + 4*0x100 0xf400
0x80(,%edx,2) 2*0xf000 + 0x80 0x1e080
4
Address Computation Instruction

• leal Src,Dest
• Src is address mode expression
• Set Dest to address denoted by expression
• Uses
• Computing addresses without a memory reference
• E.g., translation of p = &x[i];
• Computing arithmetic expressions of the form x + k*y
• k = 1, 2, 4, or 8
•int
Example
int mul12(int
mul12(int x)
x)
Converted to ASM by compiler:
{
{ leal
leal (%eax,%eax,2),
(%eax,%eax,2), %eax
%eax ;t
;t <-
<- x+x*2
x+x*2
return
return x*12;
x*12; sall
sall $2,
$2, %eax
%eax ;return
;return t<<2
t<<2
}
}
5
Today
(leal)
• While loops
6
Some Arithmetic Operations

• Two Operand Instructions:
Format Computation
addl Src,Dest Dest = Dest + Src
subl Src,Dest Dest = Dest  Src
imull Src,Dest Dest = Dest * Src
sall Src,Dest Dest = Dest << Src Also called shll
sarl Src,Dest Dest = Dest >> Src Arithmetic
shrl Src,Dest Dest = Dest >> Src Logical
xorl Src,Dest Dest = Dest ^ Src
andl Src,Dest Dest = Dest & Src
orl Src,Dest Dest = Dest | Src
• Watch out for argument order!
• No distinction between signed and unsigned int (why?)
7
Some Arithmetic Operations

• One Operand Instructions
incl Dest Dest = Dest + 1
decl Dest Dest = Dest  1
negl Dest Dest =  Dest
notl Dest Dest = ~Dest
• See book for more instructions
8
Arithmetic Expression Example

arith:
pushl %ebp Set
int
int arith(int
arith(int x,
x, int
int y,
y, int z) movl
int z) %esp, %ebp Up
{
{
int
int t1
t1 =
= x+y;
x+y; movl 8(%ebp), %ecx
int
int t2
t2 =
= z+t1;
z+t1; movl 12(%ebp), %edx
int
int t3
t3 =
= x+4;
x+4; leal (%edx,%edx,2), %eax
int
int t4
t4 =
= y
y ** 48;
48; sall $4, %eax
int
int t5
t5 =
= t3
t3 ++ t4;
t4; leal 4(%ecx,%eax), %eax Body
int
int rval
rval =
= t2
t2 *
* t5;
t5; addl %ecx, %edx
return
return rval;
rval; addl 16(%ebp), %edx
}
} imull %edx, %eax
popl %ebp
ret Finish
9
Understanding arith •
•
int
int arith(int
arith(int x,
x, int
int y,
y, int
int z)
z) Offset •
{
{
int
int t1
t1 =
= x+y;
x+y; 16 z
int
int t2
t2 =
= z+t1;
z+t1; 12 y
int
int t3
t3 =
= x+4;
x+4;
int
int t4
t4 =
= y
y ** 48;
48; 8 x
int
int t5
t5 =
= t3
t3 ++ t4;
t4;
int 4 Rtn Addr
int rval
rval =
= t2
t2 *
* t5;
t5;
return
return rval;
rval; 0 Old %ebp %ebp
}
}
movl 8(%ebp), %ecx

movl 12(%ebp), %edx
leal (%edx,%edx,2), %eax
sall $4, %eax
leal 4(%ecx,%eax), %eax
addl %ecx, %edx
addl 16(%ebp), %edx
imull %edx, %eax
10
Understanding arith • Stack
•
int
int arith(int
arith(int x,
x, int
int y,
y, int
int z)
z) Offset •
{
{
int
int t1
t1 =
= x+y;
x+y; 16 z
int
int t2
t2 =
= z+t1;
z+t1; 12 y
int
int t3
t3 =
= x+4;
x+4;
int
int t4
t4 =
= y
y ** 48;
48; 8 x
int
int t5
t5 =
= t3
t3 ++ t4;
t4;
int 4 Rtn Addr
int rval
rval =
= t2
t2 *
* t5;
t5;
return
return rval;
rval; 0 Old %ebp %ebp
}
}
movl 8(%ebp), %ecx # ecx = x

movl 12(%ebp), %edx # edx = y
leal (%edx,%edx,2), %eax # eax = y*3
sall $4, %eax # eax *= 16 (t4)
leal 4(%ecx,%eax), %eax # eax = t4 +x+4 (t5)
addl %ecx, %edx # edx = x+y (t1)
addl 16(%ebp), %edx # edx += z (t2)
imull %edx, %eax # eax = t2 * t5 (rval)
11
Observations about arith

• Instructions in different order
int
int arith(int
arith(int x,
x, int
int y,
y, int
int z)
z)
{
from C code
{
int
int t1
t1 =
= x+y;
x+y; • Some expressions require
int
int t2
t2 =
= z+t1;
z+t1; multiple instructions
int
int t3
t3 =
= x+4;
x+4; • Some instructions cover
int
int t4
t4 =
= y
y ** 48;
48; multiple expressions
int
int t5
t5 =
= t3
t3 ++ t4;
t4;
int • Get exact same code when
int rval
rval =
= t2
t2 *
* t5;
t5;
return
return rval;
rval; compile:
}
} • (x+y+z)*(x+4+48*y)
movl 8(%ebp), %ecx # ecx = x

movl 12(%ebp), %edx # edx = y
leal (%edx,%edx,2), %eax # eax = y*3
sall $4, %eax # eax *= 16 (t4)
leal 4(%ecx,%eax), %eax # eax = t4 +x+4 (t5)
addl %ecx, %edx # edx = x+y (t1)
addl 16(%ebp), %edx # edx += z (t2)
imull %edx, %eax # eax = t2 * t5 (rval)
12
Another Example
logical:
pushl %ebp Set
int
int logical(int
logical(int x,
x, int
int y)
y) movl %esp,%ebp Up
{
{
int
int t1
t1 =
= x^y;
x^y; movl 12(%ebp),%eax
int
int t2
t2 =
= t1
t1 >>
>> 17;
17; xorl 8(%ebp),%eax
int
int mask
mask =
= (1<<13)
(1<<13) -- 7;
7; sarl $17,%eax
int
int rval
rval =
= t2
t2 &
& mask;
mask; Body
andl $8185,%eax
return
return rval;
rval;
}
} popl %ebp
ret Finish
movl 12(%ebp),%eax # eax = y

xorl 8(%ebp),%eax # eax = x^y (t1)
sarl $17,%eax # eax = t1>>17 (t2)
andl $8185,%eax # eax = t2 & mask (rval)
13
Another Example
logical:
int
int logical(int
logical(int x,
x, int
int y)
y) pushl %ebp Set
{
{ movl %esp,%ebp Up
int
int t1
t1 =
= x^y;
x^y;
int
int t2
t2 =
= t1
t1 >>
>> 17;
17; movl 12(%ebp),%eax
int
int mask
mask =
= (1<<13)
(1<<13) -- 7;
int
int rval
rval =
= t2
t2 &
& mask;
mask; sarl $17,%eax Body
return
return rval;
rval; andl $8185,%eax
}
}
popl %ebp
ret Finish

sarl $17,%eax # eax = t1>>17 (t2)
14
Another Example
logical:
int
int logical(int
logical(int x,
x, int
int y)
y) pushl %ebp
{ Set
{ movl %esp,%ebp
int Up
int t1
t1 =
= x^y;
x^y;
int
int t2
t2 =
= t1
t1 >>
>> 17;
17; movl 12(%ebp),%eax
int
int mask
mask =
= (1<<13)
(1<<13) -- 7;
int
int rval
rval =
= t2
t2 &
& mask;
mask; sarl $17,%eax
return
return rval;
rval; Body
andl $8185,%eax
}
}
popl %ebp
ret Finish

sarl $17,%eax # eax = t1>>17 (t2)
15
Another Example
int logical:
int logical(int
logical(int x,
x, int
int y)
y)
{ pushl %ebp Set
{
int movl %esp,%ebp
int t1
t1 =
= x^y;
x^y; Up
int
int t2
t2 =
= t1
t1 >>
>> 17;
17;
int movl 12(%ebp),%eax
int mask
mask =
= (1<<13)
(1<<13) -- 7;
7;
int xorl 8(%ebp),%eax
int rval
rval =
= t2
t2 &
& mask;
mask;
return sarl $17,%eax
return rval;
rval; Body
} andl $8185,%eax
}
popl %ebp
ret Finish
2
213 == 8192,
13
8192, 2
213 –– 7
13
7 == 8185
8185

sarl $17,%eax # eax = t1>>17 (t2)
16
Today
(leal)
• Loops
17
Processor State (IA32, Partial)

• Information about %eax
currently executing %ecx
program %edx General purpose
• Temporary data %ebx registers
( %eax, … ) %esi
• Location of runtime %edi
stack
%esp Current stack top
( %ebp,%esp )
%ebp Current stack frame
• Location of current
code control point
%eip Instruction pointer
( %eip, … )
• Status of recent tests
CF ZF SF OF Condition codes
( CF, ZF, SF, OF )
18
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: addl/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 lea instruction
• Full documentation (IA32), link on course website
19
Condition Codes (Explicit Setting: Compare)
• Explicit Setting by Compare Instruction

•cmpl/cmpq Src2, Src1
•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 (as signed)
•OF set if two’s-complement (signed) overflow
(a>0 && b<0 && (a-b)<0) || (a<0 && b>0 && (a-b)>0)
20
Condition Codes (Explicit Setting: Test)
• Explicit Setting by Test instruction

•testl/testq Src2, Src1
testl 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
•ZF set when a&b == 0

•SF set when a&b < 0
21
Reading Condition Codes

• SetX Instructions
• Set single byte based on combinations of condition
codes
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)
22
Reading Condition Codes (Cont.)

%eax %ah %al
• SetX Instructions:
• Set single byte based on combination %ecx %ch %cl
of condition codes
• One of 8 addressable byte registers %edx %dh %dl
• Does not alter remaining 3 bytes %ebx %bh %bl

• Typically use movzbl to finish job
%esi
int
int gt
gt (int
(int x,
x, int
int y)
y)
{
{
return
return x
x >
> y; %edi
Body }
y;
}
movl 12(%ebp),%eax # eax = y %esp
cmpl %eax,8(%ebp) # Compare x : y
setg %al # al = x > y
movzbl %al,%eax # Zero rest of %eax %ebp
23
Today
(leal)
• x86-64
• Conditional branches & Moves
• Loops
25
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)
26
Conditional Branch Example

int
int absdiff(int
absdiff(int x, x, int
int y)
y) absdiff:
{
{ pushl %ebp
Setup
int
int result;
result; movl %esp, %ebp
if
if (x
(x >
> y)y) {
{ movl 8(%ebp), %edx
result
result = = x-y;
x-y; movl 12(%ebp), %eax
}
} else
else {{ cmpl %eax, %edx
result Body1
result = = y-x;
y-x; jle .L6
}
} subl %eax, %edx
return
return result;
result; movl %edx, %eax Body2a
}
} jmp .L7
.L6:
subl %edx, %eax Body2b
.L7:
popl %ebp
ret Finish
27

(Cont.)
int
int goto_ad(int
goto_ad(int x,
x, int
int y)
y)
{
{ absdiff:
int
int result;
result; pushl %ebp
Setup
if
if (x
(x <=
<= y)
y) goto
goto Else;
Else; movl %esp, %ebp
result
result == x-y;
x-y; movl 8(%ebp), %edx
goto
goto Exit;
Exit; movl 12(%ebp), %eax
Else:
Else: cmpl %eax, %edx
jle .L6 Body1
result
result == y-x;
y-x;
Exit:
Exit: subl %eax, %edx
return movl %edx, %eax Body2a
return result;
result;
}
} jmp .L7
.L6:
• C allows “goto” as means of subl %edx, %eax Body2b
transferring control .L7:
popl %ebp
• Closer to machine-level ret Finish
programming style
• Generally considered bad
coding style
28

(Cont.)
int
int goto_ad(int
goto_ad(int x,
x, int
int y)
y)
{
{ absdiff:
int
int result;
result; pushl %ebp
Setup
if
if (x
(x <=
<= y)
y) goto
goto Else;
result
result == x-y;
goto
goto Exit;
Else:
jle .L6 Body1
result
result == y-x;
y-x;
Exit:
return result;
result;
}
} jmp .L7
.L6:
.L7:
popl %ebp
ret Finish
29

(Cont.)
int
int goto_ad(int
goto_ad(int x,
x, int
int y)
y)
{
{ absdiff:
int
int result;
result; pushl %ebp
Setup
if
if (x
(x <=
<= y)
y) goto
goto Else;
result
result == x-y;
goto
goto Exit;
Else:
jle .L6 Body1
result
result == y-x;
y-x;
Exit:
return result;
result;
}
} jmp .L7
.L6:
.L7:
popl %ebp
ret Finish
30

(Cont.)
int
int goto_ad(int
goto_ad(int x,
x, int
int y)
y)
{
{ absdiff:
int
int result;
result; pushl %ebp
Setup
if
if (x
(x <=
<= y)
y) goto
goto Else;
result
result == x-y;
goto
goto Exit;
Else:
jle .L6 Body1
result
result == y-x;
y-x;
Exit:
return result;
result;
}
} jmp .L7
.L6:
.L7:
popl %ebp
ret Finish
31
General Conditional Expression Translation
C Code
val = Test ? Then_Expr : Else_Expr;
val
val =
= x>y
x>y ?
? x-y
x-y :
: y-x;
y-x;
• Test is expression returning
integer
Goto Version
nt • = 0 interpreted as false
nt == !Test;
!Test;
if
if (nt)
(nt) goto
goto Else;
Else; • ≠ 0 interpreted as true
val
val == Then_Expr;
Then_Expr;
goto
goto Done;
Done;
• Create separate code
Else:
Else: regions for then & else
val
val == Else_Expr;
Else_Expr;
Done:
Done:
expressions
.
. .. .
. • Execute appropriate one
32
Using Conditional Moves

• Conditional Move Instructions
• Instruction supports:
if (Test) Dest  Src
C Code
• Supported in post-1995 x86 processors
val = Test
• GCC does not always use them
? Then_Expr
• Wants to preserve compatibility with :
: Else_Expr;
Else_Expr;
ancient processors
• Enabled for x86-64
Goto Version
• Use switch –march=686 for IA32
• Why? tval
tval = Then_Expr;
= Then_Expr
result
result == Else_Expr;
Else_Expr;
• Branches are very disruptive to t
t == Test;
Test;
instruction flow through pipelines if
if (t)
(t) result
result == tval;
tval;
• Conditional move do not require control return
return result;
result;
transfer
33
Conditional Move Example: x86-

64
int
int absdiff(int
absdiff(int x, x, int
int y)
y) {
{
int
int result;
result;
if
if (x
(x >
> y)y) {
{
result
result = = x-y;
x-y;
}
} else
else {{
result
result = = y-x;
y-x;
}
}
return
return result;
result;
}
}
absdiff:
x in %edi movl %edi, %edx
subl %esi, %edx # tval = x-y
y in %esi
movl %esi, %eax
subl %edi, %eax # result = y-x
cmpl %esi, %edi # Compare x:y
cmovg %edx, %eax # If >, result = tval
ret
34
Bad Cases for Conditional Move

Expensive Computations
val
val =
= Test(x)
Test(x) ?
? Hard1(x)
Hard1(x) :
: Hard2(x);
Hard2(x);
• Both values get computed

• Only makes sense when computations are very simple
Risky Computations
val
val =
= p
p ?
? *p
*p :
: 0;
0;
• May have undesirable effects
Computations with side effects

val
val =
= x
x >
> 0
0 ?
? x*=7
x*=7 :
: x+=3;
x+=3;
• Must be side-effect free
35
Control transfer and basic blocks

• jmp, jxx, and call pushl %ebp
movl %esp, %ebp
instructions transfer movl 8(%ebp), %edx
processor control movl 12(%ebp), %eax
L1:
• Basic block: region of cmpl %eax, %edx
subl %eax, %edx
uninterrupted control movl %edx, %eax
• No transfers in subl %edx, %eax
L2:
• No transfers out
36

movl %esp, %ebp
L1:
subl %eax, %edx
L2:
• No transfers out
37

movl %esp, %ebp
L1:
subl %eax, %edx
jne L1
• No transfers out L2:
38

movl %esp, %ebp
L1:
subl %eax, %edx
jne L1
• No transfers out L2:
39

movl %esp, %ebp
L1:
subl %eax, %edx
uninterrupted control jne L2
• No transfers in movl %edx, %eax
subl %edx, %eax
• No transfers out jne L1
L2:
40

movl %esp, %ebp
L1:
subl %eax, %edx
uninterrupted control jne L2
• No transfers in movl %edx, %eax
subl %edx, %eax
• No transfers out jne L1
L2:
41

• Basic blocks form a int x = 1;
int y = 1;
graph while (y < 1000) {
• Nodes: basic blocks y = x + y;
}
• Edges: control transfers printf(“%d\n”, y);
• BB graph often reflects
high-level programming
constructs
42

• Basic blocks form a int x = 1;
int y = 1;
graph
• Nodes: basic blocks
while (y < 1000) {
• Edges: control transfers y = x + y;
}
• BB graph often reflects
high-level programming
printf(“%d\n”, y);
constructs
43
Today
(leal)
• x86-64
• Conditional branches and moves
• Loops
44
“Do-While” Loop Example

C Code Goto Version
int
int pcount_do(unsigned
pcount_do(unsigned x)x) int
pcount_do(unsigned x)
x)
{
{ {
{
int
int result
result =
= 0;
0; int
int result
result = = 0;
0;
do
do {{ loop:
loop:
result
result +=
+= xx &
& 0x1;
0x1; result
result +=+= x
x && 0x1;
0x1;
x
x >>=
>>= 1;
1; x
x >>=
>>= 1;
1;
}
} while
while (x);
(x); if
if (x)
(x)
return
return result;
result; goto
goto loop;
loop;
}
} return
return result;
result;
}
}
• Count number of 1’s in argument x (“popcount”)

• Use conditional branch to either continue looping or to exit
loop
45
“Do-While” Loop Compilation

Goto Version
int
x) {
{
int
int result
result = = 0;
0;
loop:
loop:
result
result +=+= x
x && 0x1;
0x1;
x
x >>=
>>= 1;
1;
if
if (x)
(x)
goto
goto loop;
loop;
return
return result;
result;
}
}
movl $0, %ecx # result = 0

• Registers: .L2: # loop:
%edx x movl %edx, %eax
%ecx result andl $1, %eax # t = x & 1
addl %eax, %ecx # result += t
shrl %edx # x >>= 1
jne .L2 # If !0, goto loop
46
General “Do-While” Translation

C Code Goto Version
do loop:
Body Body
while (Test); if (Test)
goto loop
• Body: {
Statement1;
Statement2;
…
Statementn;
}
• Test returns integer

• = 0 interpreted as false
• ≠ 0 interpreted as true 47
“While” Loop Example

C Code Goto Version
int
int pcount_while(unsigned
pcount_while(unsigned x)
x) {
{ int
x) {
{
int
int result
result = = 0;
0; int
int result
result = = 0;
0;
while
while (x)
(x) {{ if
if (!x)
(!x) goto
goto done;
done;
result
result +=
+= x x &
& 0x1;
0x1; loop:
loop:
x
x >>=
>>= 1;
1; result
result +=+= xx &
& 0x1;
0x1;
}
} x
x >>=
>>= 1;
1;
return
return result;
result; if
if (x)
(x)
}
} goto
goto loop;
loop;
done:
done:
return
return result;
result;
}
}
• Is this code equivalent to the do-while version?

• Must jump out of loop if test fails
48
General “While” Translation

While version
while (Test)
Body
Goto Version
Do-While Version
if (!Test)
if (!Test) goto done;
goto done; loop:
do Body
Body if (Test)
while(Test); goto loop;
done: done:
49
“For” Loop Example

C Code
#define
#define WSIZE
WSIZE 8*sizeof(int)
8*sizeof(int)
int
int pcount_for(unsigned
pcount_for(unsigned x) x) {{
int
int i;
i;
int
int result
result = = 0;
0;
for
for (i
(i == 0;
0; ii <
< WSIZE;
WSIZE; i++)
i++) { {
unsigned
unsigned mask
mask = = 1
1 <<
<< i;
i;
result
result +=
+= (x
(x &
& mask)
mask) !=
!= 0;
0;
}
}
return
return result;
result;
}
}
• Is this code equivalent to

other versions?
50
“For” Loop Form

General Form Init
for (Init; Test; Update ) i
i =
= 0
0
Body Test
i
i <
< WSIZE
WSIZE
for
for (i
(i =
= 0;
0; ii <
< WSIZE;
WSIZE; i++)
i++) {
{ Update
unsigned
unsigned mask
mask == 1
1 <<
<< i;
i; i++
i++
result
result +=
+= (x
(x && mask)
mask) !=
!= 0;
0;
}
}
Body
{
{
unsigned
unsigned mask
mask == 1
1 <<
<< i;
i;
result
result +=
+= (x
(x &
& mask)
mask) !=
!= 0;
0;
}
}
51
“For” Loop  While Loop

For Version
for (Init; Test; Update )
Body
While Version
Init;
while (Test ) {
Body
Update;
}
52
“For” Loop  …  Goto Init;

Init;
if (!Test)
For Version goto done;
for (Init; Test; Update ) loop:
loop:
Body
Body Update
if (Test)
goto loop;
done:
While Version
Init;
Init;
Init;
while (Test ) { if (!Test)
Body goto done;
do
do
Update; Body
} Update
while(Test);
done:
53
“For” Loop Conversion Example

C Code Goto Version
int
int pcount_for_gt(unsigned
pcount_for_gt(unsigned x) x) {{
#define
#define WSIZE
WSIZE 8*sizeof(int)
8*sizeof(int) int
int i;
i;
int
int pcount_for(unsigned
pcount_for(unsigned x) x) {{
int
int
int result
result = 0; Init
= 0;
int i;
i; i
int i == 0;
0;
int result
result = = 0;
0; if !Test
for if (!(i
(!(i < < WSIZE))
WSIZE))
for (i
(i == 0;
0; ii <
< WSIZE;
WSIZE; i++)
i++) { { goto
unsigned goto done;
done;
unsigned mask
mask == 1
1 <<
<< i;
i; loop:
result loop: Body
result +=
+= (x
(x && mask)
mask) !=
!= 0;0; {
} {
} unsigned
return unsigned mask
mask = = 11 <<
<< i;
i;
return result;
result; result
} result +=+= (x
(x &
& mask)
mask) !=!= 0;
0;
} }
} Update
i++;
i++; Test
if (i < WSIZE)
if (i < WSIZE)
• Initial test can be optimized goto
goto loop;
loop;
done:
done:
away return
return result;
result;
}
}
54
Summary
• Today
• Complete addressing mode, address computation (leal)
• Conditional branches & conditional moves
• Loops
• Next Time
• Switch statements
• Stack
• Call / return
• Procedure call discipline
55

Machine-Level Programming Ii: Arithmetic & Control

Uploaded by

Copyright:

Available Formats

Machine-Level Programming Ii: Arithmetic & 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 Ii: Arithmetic & Control

Uploaded by

Copyright:

Available Formats

MACHINE-LEVEL

Complete Memory Addressing Modes

• Most General Form

Address Computation Examples

Expression Address Computation Address

Address Computation Instruction

Some Arithmetic Operations

Some Arithmetic Operations

• See book for more instructions

Arithmetic Expression Example

movl 8(%ebp), %ecx

Understanding arith • Stack

movl 8(%ebp), %ecx # ecx = x

Observations about arith

movl 8(%ebp), %ecx # ecx = x

movl 12(%ebp),%eax # eax = y

movl 12(%ebp),%eax # eax = y

movl 12(%ebp),%eax # eax = y

movl 12(%ebp),%eax # eax = y

Processor State (IA32, Partial)

Condition Codes (Implicit Setting)

Condition Codes (Explicit Setting: Compare)

• Explicit Setting by Compare Instruction

Condition Codes (Explicit Setting: Test)

• Explicit Setting by Test instruction

•Sets condition codes based on value of Src1 & Src2

•ZF set when a&b == 0

Reading Condition Codes

Reading Condition Codes (Cont.)

• Does not alter remaining 3 bytes %ebx %bh %bl

Conditional Branch Example

Conditional Branch Example

Conditional Branch Example

Conditional Branch Example

Conditional Branch Example

General Conditional Expression Translation

Using Conditional Moves

Conditional Move Example: x86-

Bad Cases for Conditional Move

• Both values get computed

Computations with side effects

Control transfer and basic blocks

Control transfer and basic blocks

Control transfer and basic blocks

Control transfer and basic blocks

Control transfer and basic blocks

Control transfer and basic blocks

Control transfer and basic blocks

Control transfer and basic blocks

“Do-While” Loop Example

• Count number of 1’s in argument x (“popcount”)

“Do-While” Loop Compilation

movl $0, %ecx # result = 0

General “Do-While” Translation

• Test returns integer

“While” Loop Example

• Is this code equivalent to the do-while version?

General “While” Translation