University of Washington

Complete Memory Addressing Modes

 Remember, the addresses used for accessing memory in mov (and
other) instructions can be computed in several different ways
 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 the 8/16 integer registers
 Ri: Index register: Any, except for %esp or %rsp
 Unlikely you’d use %ebp, either
 S: Scale: 1, 2, 4, or 8 (why these numbers?)
 Special Cases: can use any combination of D, Rb, Ri and S
(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]]
x86
 University of Washington

Address Computation Examples

(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]]
%edx 0xf000 D(,Ri,S) Mem[S*Reg[Ri]+D]
(Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]]
%ecx 0x100
D(Rb) Mem[Reg[Rb] +D]

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

x86
 University of Washington

Address Computation Instruction

 leal Src,Dest
 Src is address mode expression
 Set Dest to address computed by expression
 (lea stands for load effective address)
 Example: leal (%edx,%ecx,4), %eax

 Uses
 Computing addresses without a memory reference
 E.g., translation of p = &x[i];
 Computing arithmetic expressions of the form x + k*i
 k = 1, 2, 4, or 8

x86
 University of Washington

Some Arithmetic Operations

 Two Operand (Binary) 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! (especially subl)
No distinction between signed and unsigned int (why?)

x86
 University of Washington

Some Arithmetic Operations

 One Operand (Unary) Instructions
incl Dest Dest = Dest + 1
decl Dest Dest = Dest - 1
negl Dest Dest = -Dest
notl Dest Dest = ~Dest

See textbook section 3.5.5 for more instructions: mull, cltd,



idivl, divl

x86
 University of Washington

Using leal for Arithmetic Expressions

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

x86
 University of Washington

Understanding arith
int arith
•
(int x, int y, int z) Stack
•
{
Offset •
int t1 = x+y;
int t2 = z+t1; 16 z
int t3 = x+4;
12 y
int t4 = y * 48;
int t5 = t3 + t4; 8 x
int rval = t2 * t5; 4 Rtn adr
return rval;
} 0 Old %ebp %ebp

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

movl 12(%ebp),%edx # edx = y
leal (%edx,%eax),%ecx # ecx = x+y (t1)
leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y
sall $4,%edx # edx = 48*y (t4)
addl 16(%ebp),%ecx # ecx = z+t1 (t2)
leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5)
imull %ecx,%eax # eax = t5*t2 (rval)
x86
 University of Washington

Understanding arith
int arith
•
(int x, int y, int z) Stack
•
{
Offset •
int t1 = x+y;
int t2 = z+t1; 16 z
int t3 = x+4;
12 y
int t4 = y * 48;
int t5 = t3 + t4; 8 x
int rval = t2 * t5; 4 Rtn adr
return rval;
} 0 Old %ebp %ebp

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

movl 12(%ebp),%edx # edx = y
leal (%edx,%eax),%ecx # ecx = x+y (t1)
leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y
sall $4,%edx # edx = 48*y (t4)
addl 16(%ebp),%ecx # ecx = z+t1 (t2)
leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5)
imull %ecx,%eax # eax = t5*t2 (rval)
x86
 University of Washington

Understanding arith
int arith
•
(int x, int y, int z) Stack
•
{
Offset •
int t1 = x+y;
int t2 = z+t1; 16 z
int t3 = x+4;
12 y
int t4 = y * 48;
int t5 = t3 + t4; 8 x
int rval = t2 * t5; 4 Rtn adr
return rval;
} 0 Old %ebp %ebp

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

movl 12(%ebp),%edx # edx = y
leal (%edx,%eax),%ecx # ecx = x+y (t1)
leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y
sall $4,%edx # edx = 48*y (t4)
addl 16(%ebp),%ecx # ecx = z+t1 (t2)
leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5)
imull %ecx,%eax # eax = t5*t2 (rval)
x86
 University of Washington

Understanding arith
int arith
•
(int x, int y, int z) Stack
•
{
Offset •
int t1 = x+y;
int t2 = z+t1; 16 z
int t3 = x+4;
12 y
int t4 = y * 48;
int t5 = t3 + t4; 8 x
int rval = t2 * t5; 4 Rtn adr
return rval;
} 0 Old %ebp %ebp

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

movl 12(%ebp),%edx # edx = y
leal (%edx,%eax),%ecx # ecx = x+y (t1)
leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y
sall $4,%edx # edx = 48*y (t4)
addl 16(%ebp),%ecx # ecx = z+t1 (t2)
leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5)
imull %ecx,%eax # eax = t5*t2 (rval)
x86
 University of Washington

Observations about arith

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

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

movl 12(%ebp),%edx # edx = y
leal (%edx,%eax),%ecx # ecx = x+y (t1)
leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y
sall $4,%edx # edx = 48*y (t4)
addl 16(%ebp),%ecx # ecx = z+t1 (t2)
leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5)
imull %ecx,%eax # eax = t5*t2 (rval)
x86
 University of Washington

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

Stack
movl 8(%ebp),%eax # eax = x •
Offset
•
xorl 12(%ebp),%eax # eax = x^y •
sarl $17,%eax # eax = t1>>17
12 y
andl $8185,%eax # eax = t2 & 8185 8 x
4 Rtn adr
0 Old %ebp %ebp
x86
 University of Washington

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

movl 8(%ebp),%eax eax = x

xorl 12(%ebp),%eax eax = x^y (t1)
sarl $17,%eax eax = t1>>17 (t2)
andl $8185,%eax eax = t2 & 8185

x86
 University of Washington

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

movl 8(%ebp),%eax eax = x

xorl 12(%ebp),%eax eax = x^y (t1)
sarl $17,%eax eax = t1>>17 (t2)
andl $8185,%eax eax = t2 & 8185

x86
 University of Washington

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

movl 8(%ebp),%eax eax = x

xorl 12(%ebp),%eax eax = x^y (t1)
sarl $17,%eax eax = t1>>17 (t2)
andl $8185,%eax eax = t2 & 8185

x86