1. 15-213 Recitation 2 – 2/11/02 Outline Stacks & Procedures
Homogenous Data
Arrays
Nested Arrays
Structured Data
structs / unions
Arrays of structs
Anusha
Office Hours:
Tuesday, 11:30-1:00
Wean Cluster 52xx
Reminders
Lab 2: Tuesday, 11:59

2. Stacks Grows down Stores local variables that can’t fit in registers
Stores arguments and return addresses
%esp Stack Pointer
Points to the top value on the stack
%ebp Base Pointer
Points to a function’s stack frame
pushl
Decrements, then places value
popl
‘Returns’ value, then increments

3. Stack Frames Abstract partitioning of the stack
Caller
Frame
Abstract partitioning of the stack
Each Frame contains the state for a single function instant
Arguments
Frame Pointer
(%ebp)
Return Addr
Old %ebp
Saved
Registers
Local
Variables
Argument
Build
Stack Pointer
(%esp)

4. Procedures call: Caller Responsibilities Arguments (pushl)
In what order?
Return Address (done by call)
ret: Callee Responsibilities
Save Registers (especially %ebp)
Set up Stack Frame
Return value in %eax

5. Problem 1: Call Chain void absdiff(int *result, int x, int y) { int z;
if (x >= y)
z = x - y;
else
z = y - x;
*result = z;
return; }
int main() {
int result;
int x,y;
x = 5;
y = -3;
absdiff(&result, x, y);
printf("|(%d) - (%d)| = %d\n",
x, y, result);
return 0; }

6. Problem 1: Answer <main>: push %ebp mov %esp,%ebp sub $0x18,%esp
Old %ebp
<main>:
push %ebp
mov %esp,%ebp
sub $0x18,%esp
movl $0x5,-8(%ebp)
movl $0xfffffffd, -12(%ebp)
add $0xfffffffc,%esp
mov (%ebp),%eax
push %eax
mov -8(%ebp),%eax
lea -4(%ebp),%eax
call <absdiff>
%ebp
result 5 -3
%esp -3 5
&result
Rtn Address
%esp

7. Problem 1: Answer <absdiff>: push %ebp mov %esp,%ebp
sub $0x18,%esp
mov 0xc(%ebp),%eax
cmp 0x10(%ebp),%eax
jl .L1
mov 0x10(%ebp),%edx
mov %eax,%ecx
sub %edx,%ecx
jmp .L2
.L1
mov 0x10(%ebp),%eax
mov 0xc(%ebp),%edx
.L2
mov 0x8(%ebp),%eax
mov %ecx,(%eax)
mov %ebp,%esp
pop %ebp
ret *
%esp -3 5
&result
Rtn Address
Old %ebp
%ebp
%esp

8. Problem 1: Answer <main>: ….. add $0x10, %esp mov -4(%ebp),%eax
Old %ebp
%ebp
%esp
<main>:
…..
add $0x10, %esp
mov -4(%ebp),%eax
push %eax
mov (%ebp),%eax
mov -8(%ebp),%eax
push $0x80484d8
call <printf>
mov %ebp,%esp
pop %ebp
ret
result 5 -3
%esp
result -3 5
$0x80484d8
Rtn Address

9. Problem 2: Recursion
With the following code, what does the stack look like if we call fib(1, 1, 0) and reach the point where if(n==0) holds true?
int fib(int n, int next, int result) {
if(n == 0)
return result;
return fib(n - 1, next + result, next); }

10. Problem 2: Answer 0 ; third argument to fib 1 ; second 1 ; first
ret ; call fib
oldebp ; <--- ebp of fib’s caller
; <--- push result
; <--- next + result
; <--- n - 1
oldebp

11. Homogenous Data: Arrays
Allocated as contiguous blocks of memory
Address Computation Examples
int cmu[5] = {…}
cmu begins at memory address 40
cmu[0] *0 = 40
cmu[3] *3 = 52
cmu[-1] *-1 = 36
cmu[15] *15 = 100

12. Problem 3: Arrays get_sum: pushl %ebp movl %esp,%ebp pushl %ebx
movl 8(%ebp),%ebx # ebx = 1st arg (array A)
movl 12(%ebp),%ecx # ecx = 2nd arg (size)
xorl %eax,%eax # eax = 0
movl %eax,%edx # edx = 0
cmpl %ecx,%edx #
jge .L # if (0 >= ecx) goto L4
.L6: addl (%ebx,%edx,4),%eax # eax += Mem[ebx+edx*4]
incl %edx # edx ++
jl .L # if (edx < ecx) goto L6
.L4: popl %ebx
movl %ebp,%esp
popl %ebp
ret

13. Problem 3: Answer int get_sum(int * array, int size) { int sum = 0;
pushl %ebp
movl %esp,%ebp
pushl %ebx
movl 8(%ebp),%ebx
movl 12(%ebp),%ecx
xorl %eax,%eax
movl %eax,%edx
cmpl %ecx,%eax
jge .L4
.L6: addl (%ebx,%edx,4),%eax
incl %edx
cmpl %ecx,%edx
jl .L6
.L4: popl %ebx
movl %ebp,%esp
popl %ebp
ret
int get_sum(int * array,
int size) {
int sum = 0;
int i=0;
for (i=0; i<size; i++)
sum += array[i];
return sum; }

14. Challenge Problem A function with prototype
int mystery2(int *A, int x, int N)
is compiled into the assembly on the next page.
Hint: A is an array of integers, and N is the length of the array.
What is this mystery function computing?

15. Challenge Problem A0: mystery2: A1: push %ebp A2: movl %esp, %ebp
A3: movl 8(%ebp), %ebx
A4: movl 16(%ebp), %edx
A5: movl $0xffffffff, %eax
A6: movl $0x0, %ecx
A7: decl %edx
A8: compl %edx, %ecx
A9: jg .L13

16. Challenge Problem (continued)
A11: add %edx, %ecx
A12: sarl $0x1, %ecx
A13: cmpl 12(%ebp), (%ebx, %ecx, 4)
A14: jge .L10
A15: incl %ecx
A16: movl %ecx, 0xfffffff4(%ebp)
A17: jmp .L12
A18: .L10
A19: cmpl (%ebx, %ecx, 4), 12(%ebp)
A20: jle .L11
A21: movl %ecx, %edx
A22: decl %edx
A23: jmp .L12

17. Challenge Problem (more code)
A25: movl %ecx, %eax
A26: jmp .L13
A27: .L12
A28: cmpl %edx, 0xfffffff4
A29: jle .L9
A30: .L13
A31: movl %ebp, %esp
A32: pop %ebp
A33: ret

18. Challenge Problem Answer: Binary Search # Set up A0: mystery2: #
# ebx = Array A
# edx = High = N
# result = -1
# Low = 0
# ecx = Mid = Low
# High—
# Compare Low:High
# If Low > High goto Done
A0: mystery2:
A1: push %ebp
A2: movl %esp, %ebp
A3: movl 8(%ebp), %ebx
A4: movl 16(%ebp), %edx
A5: movl $0xffffffff, %eax
A6: movl $0x0, %ecx
A7: decl %edx
A8: compl %edx, %ecx
A9: jg .L13

19. Challenge Problem (continued)
A11: add %edx, %ecx
A12: sarl $0x1, %ecx
A13: cmpl 12(%ebp), (%ebx, %ecx, 4)
A14: jge .L10
A15: incl %ecx
A16: movl %ecx, 0xfffffff4(%ebp)
A17: jmp .L12
A18: .L10
A19: cmpl (%ebx, %ecx, 4), 12(%ebp)
A20: jle .L11
A21: movl %ecx, %edx
A22: decl %edx
A23: jmp .L12
# Loop:
# Mid += High
# Mid /= 2
# Compare A[Mid]:X
# If >=, goto High
# Mid++
# Low = Mid
# goto Check
# High:
# Compare X:A[Mid]
# If <=, goto Found
# High = Mid
# High—

20. Challenge Problem (more code)
# Found:
# Result = Mid
# goto Done
# Check:
# Compare Low:High
# If <=, goto Loop
# Done: #
# Cleanup
A24: .L11
A25: movl %ecx, %eax
A26: jmp .L13
A27: .L12
A28: cmpl %edx, 0xfffffff4
A29: jle .L9
A30: .L13
A31: movl %ebp, %esp
A32: pop %ebp
A33: ret

21. Challenge Problem int binsearch(int *A, int X, int N) {
int Low, Mid, High;
Low = 0; High = N - 1;
while( Low <= High ) {
Mid = ( Low + High ) / 2;
if( A[ Mid ] < X )
Low = Mid + 1;
else
if( A[ Mid ] > X )
High = Mid - 1;
return Mid; /* Found */ }
return -1;

22. Problem 4: Nested arrays
int main(int argc, char **argv) {
int i,j,r=0;
for (i=0; i<argc; i++) {
j=0;
while(argv[i][j] != '\0') {
r ^= argv[i][j];
j++; }
return r;

23. Problem 4: Answer .L9: main: movsbl (%ecx,%edx),%eax pushl %ebp
xorl %eax,%esi
incl %ecx
cmpb $0,(%ecx,%edx)
jne .L9
.L5:
incl %ebx
cmpl 8(%ebp),%ebx
jl .L6
.L4:
movl %esi,%eax
popl %ebx
popl %esi
popl %edi
movl %ebp,%esp
popl %ebp
ret
main:
pushl %ebp
movl %esp,%ebp
pushl %edi
pushl %esi
pushl %ebx
movl 12(%ebp),%edi
xorl %esi,%esi
xorl %ebx,%ebx
cmpl 8(%ebp),%ebx
jge .L4
.L6:
xorl %ecx,%ecx
movl (%edi,%ebx,4),%eax
cmpb $0,(%eax)
je .L5
movl %eax,%edx

24. structs and unions Organize data
structs store multiple elements, unions store a single element at a time
Members of a union change how you look at data
unions used for mutually exclusive data

25. Alignment Contiguous areas of memory Each block is aligned Why?
Size is a multiple of a base value
“Base value” is the largest alignment of data types in structure
Why?
Efficient load/store from memory
Virtual Memory paging
This applies to any variable type

26. Structure of a struct Find largest alignment
Size of structure must be a multiple of this
For each element e (top to bottom):
Find alignment of e
Starting offset must be a multiple of this
Pad previous element with empty space until alignment matches
Allocate alignment worth of space to e
Pad last element with empty space until alignment of structure matches
Note this isn’t optimal!

27. Structure of a union Find largest alignment Allocate this much space
Size of structure must be a multiple of this
Allocate this much space
Examples
struct one { union two {
int i; int i;
double d; double d;
char c[2]; char c[2]; }

28. Problem 5: Structs .LC0: #define MAX_STRING 20 .string "Jack" .LC1:
.string "Black"
.LC2:
.string "12345ZXY"
.align 32
.LC3:
.string "Name : %s %s\nID : %s\nAge : %i\n“
main:
pushl %ebp
movl %esp, %ebp
subl $88, %esp
subl $4, %esp
pushl $5
pushl $.LC0
leal -72(%ebp), %eax
pushl %eax
call strncpy
addl $16, %esp
pushl $6
pushl $.LC1
addl $20, %eax
call strncpy
#define MAX_STRING 20
#struct student #{
# char first [ MAX_STRING ];
# char last [ MAX_STRING ];
# char id [ MAX_STRING ];
# int age;
#};
# struct student s1;
# struct student *s2;
# strncpy(s1.first, fName,
# sizeof(fName));
# strncpy(s1.last, lName,
# sizeof(lName));

29. Problem 5: Structs addl $16, %esp subl $4, %esp pushl $9 pushl $.LC2
strncpy(s1.id, ID, sizeof(ID));
# s1.age = AGE;
# s2 = &s1;
# printf("Name : %s %s\nID : %s\nAge : %i\n",
# s2->first, s2->last, s2->id, s2 ->age);
# clean up and exit
addl $16, %esp
subl $4, %esp
pushl $9
pushl $.LC2
leal -72(%ebp), %eax
addl $40, %eax
pushl %eax
call strncpy
movl $19, -12(%ebp)
movl %eax, -76(%ebp)
subl $12, %esp
movl -76(%ebp), %eax
pushl 60(%eax)
addl $20, %eax
pushl -76(%ebp)
pushl $.LC3
call printf
addl $32, %esp
movl $0, %eax
leave
ret

30. Problem 5: Answer int main ( int argc, char** argv ) {
struct student s1;
struct student *s2;
strncpy ( s1.first, fName, sizeof ( fName ) );
strncpy ( s1.last , lName, sizeof ( lName ) );
strncpy ( s1.id , ID , sizeof ( ID ) );
s1.age = AGE;
s2 = &s1;
printf ( "Name : %s %s\nID : %s\nAge : %i\n",
s2 -> first, s2 -> last, s2 -> id, s2 -> age );
return 0; }

31. Problem 6: Arrays of structs
.LC0:
.string "%i : %s - “
.LC1:
.string "Has no partner\n“
.LC2:
.string "Partnered with : %s \n“
.align 32
.LC3:
.string "Claims parter: %s, but not mutual\n“
partner_check:
pushl %ebp
movl %esp,%ebp
subl $20,%esp
pushl %ebx
nop
movl $0,-4(%ebp)
.p2align 4,,7
.L3:
cmpl $5,-4(%ebp)
jle .L6
jmp .L4
.L6:
addl $-4,%esp
movl -4(%ebp),%eax
movl %eax,%ecx
movl %ecx,%edx
sall $4,%edx
addl %eax,%edx
#define MAX_STRING 20
#define MAX_STUDENTS 6
#struct student #{
# char first [ MAX_STRING ];
# char last [ MAX_STRING ];
# char id [ MAX_STRING ];
# int age; # struct student *partner;
#};
# Lines with < symbols are moving
# data for the printf command at
# the end of the < block. left
# in for informational purposes
<

32. Problem 6: Arrays of structs
leal 0(,%edx,4),%eax
movl %eax,%edx
addl 8(%ebp),%edx
leal 40(%edx),%eax
pushl %eax
movl -4(%ebp),%eax
pushl $.LC0
call printf
addl $16,%esp
movl %eax,%ecx
movl %ecx,%edx
sall $4,%edx
addl %eax,%edx
movl 8(%ebp),%edx
cmpl $0,64(%edx,%eax)
jne .L7
addl $-12,%esp
pushl $.LC1
jmp .L5
.p2align 4,,7
<
< printf ( "%i : %s - ", j, class[j].ID );
< printf ( "Has no partner\n" );

33. Problem 6: Arrays of structs
movl -4(%ebp),%eax
movl %eax,%ecx
movl %ecx,%edx
sall $4,%edx
addl %eax,%edx
leal 0(,%edx,4),%eax
movl 8(%ebp),%edx
movl 64(%edx,%eax),%eax
movl -4(%ebp),%edx
movl %edx,%ebx
movl %ebx,%ecx
sall $4,%ecx
addl %edx,%ecx
leal 0(,%ecx,4),%edx
movl %edx,%ecx
addl 8(%ebp),%ecx
cmpl %ecx,64(%eax)
jne .L9
addl $-8,%esp
addl $40,%eax
pushl %eax
pushl $.LC2
call printf
addl $16,%esp
jmp .L5
.p2align 4,,7
<
< printf ( "Partnered with : %s \n",
< class[j].partner->ID );

34. Problem 6: Arrays of structs
addl $-8,%esp
movl -4(%ebp),%eax
movl %eax,%ecx
movl %ecx,%edx
sall $4,%edx
addl %eax,%edx
leal 0(,%edx,4),%eax
movl 8(%ebp),%edx
movl 64(%edx,%eax),%eax
addl $40,%eax
pushl %eax
pushl $.LC3
call printf
addl $16,%esp
.L10:
.L8:
.L5:
incl -4(%ebp)
jmp .L3
.p2align 4,,7
.L4:
.L2:
movl -24(%ebp),%ebx
movl %ebp,%esp
popl %ebp
ret
<
< printf ( "Claims parter: %s, but not mutual\n",
< class[j].partner->ID );

35. Problem 6: Answer void partner_check ( struct student * class ) {
int j;
for (j = 0; j < MAX_STUDENTS; j++ )
printf ( "%i : %s - ", j, class[j].ID );
if ( (class+j)->partner == NULL )
printf ( "Has no partner\n" );
else if ( (class+j)->partner->partner == (class+j) )
printf ( "Partnered with : %s \n",
class[j].partner->ID );
else printf ( "Claims parter: %s, but not mutual\n", }