313, CPSC 06w Term 1 Midterm 1 Solutions
Date: October 4, 2006; Instructor: Norm Hutchinson
1. (8 marks)
1a.
Short answers.
Is the address of a local variable in a C function determined statically or dynamically?
Briey explain.
(2 marks)
It is determined dynamically, as it is allocated on the stack.
1b.
Is the code address to which a procedure returns when it exits determined statically or
dynamically? Briey explain.
(2 marks)
It is dynamically determined when the procedure is called during execution of the program,
by pushing the return address on the stack.
1c. (2 marks) Does the IA32 instruction-set architecture require that %esp be used as the stack pointer?
Briey explain.
It does require it. The call and ret instructions implicitly refer to the %esp register and
there are no reasonable alternatives that compiled code can use if chooses to use a different
register to point to the stack.
1d.
(2 marks)
Give assembly-language code that computes %eax = %eax * 9 + 7 as efciently
as possible.
leal
2. (8 marks)
7(%eax,%eax,8), %eax
# eax = eax * 9 + 7
Consider the following C source le.
/* global variables */
int g, *gp, **gpp;
void foo (int *a1, int a2) {
int l;
/* consider each statement as if it were here */
}
Give an assembly-code implementation of each of the following statements of function foo(). Consider
each statement in isolation (i.e., as if it were the only statement of foo). Do not assume that variables start
out in registers. Be sure to write results to the appropriate location in memory. Assume that the local variable
l is in memory (not in a register). A fully correct answer will use as few instructions as possible. Comment
your code.
2a. (2 marks) gp = &l;
leal
movl
-4(%ebp), %eax
%eax, gp
# eax = &l
# gp = &l
2b. (2 marks) l = *a1 * a2;
movl
movl
imull
movl
8(%ebp), %eax
(%eax), %eax
12(%ebp), %eax
%eax, -4(%ebp)
#
#
#
#
eax
eax
eax
l=
= a1
= *a1
= *a1 * a2
*a1 * a2
2c. (2 marks) **gpp = 3;
movl
movl
movl
gpp, %eax
(%eax), %eax
$3, (%eax)
# eax = gpp
# eax = *gpp
# **gpp = 3
2d. (2 marks) if (a2 > g) l = a2 else l = g;
movl
cmpl
jg
movl
.L0: movl
3. (8 marks)
12(%ebp), %eax # eax = a2
g, %eax
# (a2 ? g)
.L0
# if (a2 > g) goto .L0 (then-part)
g, %eax # %eax is now g rather than a2
%eax, -4(%ebp) # l = either a2 or g
Consider the following assembly language code.
3a. (4 marks) Comment every line of this code carefully.
foo:
pushl
movl
movl
movl
cmpl
je L8
L6:
cmpl
jle L4
subl
jmp L2
L4:
subl
L2:
cmpl
jne L6
L8:
popl
ret
%ebp
%esp, %ebp
8(%ebp), %eax
12(%ebp), %edx
%edx, %eax
# prologue
# arg 0 in %eax
# arg 1 in %edx
# if the same, return arg 0
%edx, %eax
# if arg0 > arg1
%edx, %eax
# arg0 -= arg1
%eax, %edx
# arg1 -= arg0
%edx, %eax
# if arg0 != arg1
# loop
%ebp
# epilogue
3b. (4 marks) Give an equivalent C-language function.
int gcd (int a, int b)
{
while (a != b) {
if (a > b) {
a -= b;
} else {
b -= a;
}
}
return a;
}
4. (10 marks)
Consider this C procedure
int foo(int i)
{
2
switch (i) {
case 1:
i = i * 2;
break;
case -1:
case -4:
i = i - 7;
break;
default:
i = 0;
}
return i;
}
Give the assembly code that implements this switch statement using a jump table, in the most efcient
manner possible. Include both .text and .rodata denitions. Comment your .L2
jmp
.L0: code.
.text
movl
movl
subl
cmpl
ja sall
jmp
.L1: subl
jmp
.L2: movl
.L3:
.rodata
.L4: .long
.long
.long
.long
.long
.long
5. (6 marks)
8(%ebp), %eax
%eax, %ecx
$-4, %ecx
$5, %ecx
# eax = i
*.L4(,%ecx,4)
$1, %eax
.L3
$7, %eax
.L3
$0, %eax
# goto .L4[i-(-4)]
# case 1: i = i * 2
.L1
.L2
.L2
.L1
.L2
.L0
#
#
#
#
#
#
# ecx = i-(-4) (base)
# if out of range goto default
# case -1, -4: i = i - 7
# default:
case
case
case
case
case
case
i=0
-4
-3 => default
-2 => default
-1, like -4
0 => default
1
Consider the procedure call to callee() in this C code.
void caller (int i, int j) {
int l;
l = callee (&j);
}
Assume that callee uses one callee-save register (i.e., %esi) and that caller has a value in one callersave register (i.e., %edx) that must not be changed by the call to callee.
5a. (4 marks) Give the assembly code of the procedure call to callee(), including storing the result
in local variable l in memory.
3
pushl
leal
pushl
call
movl
addl
popl
%edx
12(%ebp), %eax
%eax
callee
%eax, -4(%ebp)
$4, %esp
%edx
#
#
#
#
#
#
#
save caller-save register edx
eax = &j
push &j as argument
callee (&j)
l = callee (&j)
discard argument from stack
restore saved register edx
5b. (2 marks) Give the assembly code of callee()s prologue.
pushl
movl
pushl
6.
%ebp
%esp, %ebp
%esi
# save old base pointer
# create new frame
# save callee-save register esi
If you think about what weve been doing in this course so far, you may have been getting
frustrated that it is all about doing again in assembly language things that you could already do in C. However, assembly code is strictly more powerful than C because you can access information that is not exposed
to the C language programmer. This question hints at some of this information.
(10 marks)
6a. (5 marks) Draw a picture of the runtime stack indicating three procedures, A which calls B which
calls C. On your picture, very clearly indicate the locations of the saved frame pointers and return
addresses. You should indicate the general location of parameters and local variables, but need not
show them in detail. Clearly indicate exactly where in the stack the registers %esp and %ebp point.
%esp
towards 0
Locals/temps
%ebp
Saved %ebp
Cs stack frame
Return addr
arg0
arg1
Locals/temps
Saved %ebp
Bs stack frame
Return addr
arg0
arg1
Locals/temps
Saved %ebp
As stack frame
Return addr
arg0
arg1
Towards 232 - 1
6b. (5 marks) Write in assembler a function fetch that can be called by a function like C and fetches
the program counter of Cs caller and Cs callers caller. Its prototype is:
void fetch(int *callerspc, int *callerscallerspc);
Be careful to get the return address of Cs caller, and not fetchs caller!
4
.text
.p2align 4,,15
.globl fetch
.type
fetch, @function
fetch:
#
movl
%ebp, %ecx
#
movl
4(%esp), %edx
#
movl
4(%ecx), %eax
#
movl
%eax, (%edx)
#
movl
movl
movl
movl
(%ecx), %ecx
8(%esp), %edx
4(%ecx), %eax
%eax, (%edx)
#
#
#
#
#
I dont push the %ebp
callers %ebp is in %ecx
callerspc in %edx
callers callers return addr
callerspc = callers callers return addr
repeat for the callers caller
callers callers %ebp is in %ecx
callerscallerspc in %edx
callers callers callers return addr
callerscallerspc = callers callers callers ret
ret
5