# 3.67 Caller and Callee

For this exercise, we will examine the code generated by GCC for functions that have structures as arguments and return values, and from this see how these language features are typically implemented.

The following C code has a function `process` having structures as argument and return values, and a function `eval` that calls `process`:

```c
typedef struct {
    long a[2];
    long *p;
} strA;

typedef struct {
    long u[2];
    long q;
} strB;

strB process(strA s) {
    strB r;
    r.u[0] = s.a[1];
    r.u[1] = s.a[0];
    r.q = *s.p;
    return r;
}

long eval(long x, long y, long z) {
    strA s;
    s.a[0] = x;
    s.a[1] = y;
    s.p = &z;
    strB r = process(s);
    return r.u[0] + r.u[1] + r.q;
}
```

GCC generates the following code for these two functions:

```
process:    ; strB process(strA s)
    movq     %rdi, %rax
    movq     24(%rsp), %rdx
    movq     (%rdx), %rdx
    movq     16(%rsp), %rcx
    movq     %rcx, (%rdi)
    movq     8(%rsp), %rcx
    movq     %rcx, 8(%rdi)
    movq     %rdx, 16(%rdi)
    ret
```

and:

```
eval:    ; long eval(long x, long y, long z)
    subq     $104, %rsp
    movq     %rdx, 24(%rsp)
    leaq     24(%rsp), %rax
    movq     %rdi, (%rsp)
    movq     %rsi, 8(%rsp)
    movq     %rax, 16(%rsp)
    leaq     64(%rsp), %rdi
    call     process
    movq     72(%rsp), %rax
    addq     64(%rsp), %rax
    addq     80(%rsp), %rax
    addq     $104, %rsp
    ret
```

A. We can see on line 2 of function `eval` that it allocates 104 bytes on the stack. Diagram the stack frame for `eval`, showing the values that it stores on the stack prior to calling `process`.

```
104  +------------------+
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
 64  +------------------+ <-- %rdi
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
 32  +------------------+
     |         z        |
 24  +------------------+
     |        &z        |
 16  +------------------+
     |         y        |
  8  +------------------+
     |         x        |
  0  +------------------+ <-- %rsp
```

B. What value does `eval` pass in its call to `process`?

%rsp+64

C. How does the code for `process` access the elements of structure argument `s`?

%rsp+offset

D. How does the code for `process` set the fields of result structure `r`?

`process` get %rsp+64 as parameter from `eval`, and stores data here for `eval`.

E. Complete your diagram of the stack frame for `eval`, showing how `eval` accesses the elements of structure `r` following the return from `process`.

```
104  +------------------+
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
     |                  |
 88  +------------------+
     |        z         |
 80  +------------------+
     |        x         |
 72  +------------------+
     |        y         |
 64  +------------------+ <-- %rdi(eval pass in)
     |                  |  \
     |                  |   -- %rax(process pass out)
     |                  |
     |                  |
     |                  |
     |                  |
 32  +------------------+
     |         z        |
 24  +------------------+
     |        &z        |
 16  +------------------+
     |         y        |
  8  +------------------+
     |         x        |
  0  +------------------+ <-- %rsp in eval
     |                  |
 -8  +------------------+ <-- %rsp in process
```

F. What general principles can you discern about how structure values are passed as function arguments and how they are returned as function results?

Caller allocats space in stack and pass the address to callee, callee stores data in the space and return the address to caller.