CS 208 s20 — Implementing Procedure Calls

void swap(long *xp, long *yp) {
    long t = *xp;
    *xp = *yp;
    *yp = t;
}

long f(long x, long y) {
    swap(&x, &y);
    return x - y;
}

swap(long*, long*):
        movq    (%rdi), %rax
        movq    (%rsi), %rdx
        movq    %rdx, (%rdi)
        movq    %rax, (%rsi)
        ret
f(long, long):
        subq    $16, %rsp            // allocate space on the stack by moving the stack pointer (grows DOWN)
        movq    %rdi, 8(%rsp)        // move x onto the stack
        movq    %rsi, (%rsp)         // move y onto the stack
        movq    %rsp, %rsi           // copy the stack address for y to rsi
        leaq    8(%rsp), %rdi        // copy the stack address for x in rdi
        call    swap(long*, long*)
        movq    8(%rsp), %rax
        subq    (%rsp), %rax
        addq    $16, %rsp            // free stack space by moving the stack pointer back up
        ret

void parse_five_numbers(char *input, int numbers[])
{
  int numScanned = sscanf(input, "%d %d %d %d %d",
                          &(numbers[0]), &(numbers[1]), &(numbers[2]),
                          &(numbers[3]), &(numbers[4]));
  if (numScanned < 5)
    printf("KABLOOEY!!!");
}

.LC0:
        .string "%d %d %d %d %d"
.LC1:
        .string "KABLOOEY!!!"
parse_five_numbers:
        subq    $16, %rsp         // allocate stack frame
        movq    %rsi, %rdx        // address of numbers[0] as third arg
        leaq    16(%rsi), %rax    // load address of numbers[4] into rax
        leaq    4(%rsi), %rcx     // address of numbers[1] as fourth arg
        pushq   %rax              // push address of numbers[4] onto the stack as seventh arg
        leaq    12(%rsi), %r9     // address of numbers[3] as sixth arg
        leaq    8(%rsi), %r8      // address of numbers[2] as fifth arg
        movl    $.LC0, %esi       // address of format string as second arg
        movl    $0, %eax
        call    __isoc99_sscanf   // never loaded something into %rdi (first arg), why?
                                  // it's the same as the first arg to parse_five_numbers, so we just keep it
        addq    $16, %rsp         // deallocate stack frame
        cmpl    $4, %eax
        jg      .L1
        movl    $.LC1, %edi
        movl    $0, %eax
        call    printf
.L1:
        addq    $8, %rsp          // cleaning up the pushq %rax from before
        ret

long P(long x, long y) {
    long u = Q(y);
    long v = Q(x);
    return u + v;
}

P:
        pushq   %rbp        // save value of callee-saved register this procedure will use
        pushq   %rbx        // save value of callee-saved register this procedure will use
        movq    %rdi, %rbp  // %rdi is a caller-saved register, we'll need its value later so we
                            // save it in a callee-saved register that Q will have to preserve
        movq    %rsi, %rdi
        call    Q
        movq    %rax, %rbx  // %rax is also caller-saved, so put in it callee-saved %rbx for 
                            // later use
        movq    %rbp, %rdi
        call    Q
        addq    %rbx, %rax
        popq    %rbx        // restore value of callee-saved register this procedure used
        popq    %rbp        // restore value of callee-saved register this procedure used
        ret

long fact_rec(long n) {
    long result;
    if (n <= 1)
        result = 1;
    else 
        result = n * fact_rec(n - 1);
    return result;
}

fact_rec:
        cmpq    $1, %rdi
        jg      .L8
        movl    $1, %eax
        ret
.L8:
        pushq   %rbx
        movq    %rdi, %rbx
        leaq    -1(%rdi), %rdi
        call    fact_rec
        imulq   %rbx, %rax
        popq    %rbx
        ret

long increment(long* p, long val) {
    long x = *p;
    long y = x + val;
    *p = y;
    return x;
}

long call_incr() {
    long v1 = 208;
    long v2 = increment(&v1, 124);
    return v1+v2;
}

int main() {
    call_incr();
}

increment:
        movq    (%rdi), %rax
        addq    %rax, %rsi
        movq    %rsi, (%rdi)
        ret
call_incr:
        subq    $16, %rsp
        movq    $208, 8(%rsp)
        movl    $124, %esi
        leaq    8(%rsp), %rdi
        call    increment
        addq    8(%rsp), %rax
        addq    $16, %rsp
        ret
main:
        movl    $0, %eax
        call    call_incr
        movl    $0, %eax
        ret