Address Calculation

• Syntax is offset ( base, index, stride ), e.g.: 8(%rdi, %rsi, 4)
  • base and index are registers
  • offset must be number
  • stride is a number (only 1, 2, 4, or 8)
• The computed address is base + offset + (index × stride)
  • base → pointer
  • offset → fixed offset from pointer
  • index → index within array = variable offset from pointer
  • stride → how big each index is = pointer scaling
• C code ≈ base[index + offset]

scanf

• Reads formatted input from the user
• Format declares what we expect them to type, scanf converts text into other types accordingly
  • Can read characters with %c, integers with %d, floats with %f, and strings with %s.
  • When reading strings, you must* specify the max size.
• You provide one additional argument per format specifier which is a pointer to write the result into
  • This is how all multi-output functions work in C
• Return value specifies how many values were converted (or error if it’s negative)

scanf

• Reference for scanf and related functions
• Subject to buffer overflow, numeric overflow, and partial read issues
  • Great summary of the issues with scanf
• scanf_s requires arguments to specify buffer sizes, but is NOT available in C99 (which we’re using in this class)

int x, y;
printf("Enter two numbers separated by a comma: ");
scanf("%d,%d\n", &x, &y);
printf("Their sum is: %d\n", x + y);

Calls Scramble Registers

#include <stdio.h>

int doSomething(int a) {
    int x = a + 8;
    printf("My x is: %d\n", x);
    return x;
}

int main(int argc, char** av) {
    int x = argc;
    printf("x is: %d\n", x);
    int y = doSomething(x);
    printf("x is: %d\n", x);
    printf("y is: %d\n", y);
    return x;
}

Calls Scramble Registers

• Each function uses the same 16 registers
  • Could be 1000s of functions in a program…
  • Using stack to save info is slow…
• Convention:
  • Clean up after yourself in some cases (callee saved)
    • %rbx, %rsp, %rbp, plus %r12-15
  • Do whatever in other cases (caller saved)
    • Any other register

%rbp

long getAndSumValues() {
    long x;
    printf("Enter an integer: ");
    scanf(" %ld",&x);
    if (x == 0) {
        return 0;
    } else {
        return x + getAndSumValues();
    }
}

Explorer link

%rbp

• The stack “base” pointer
  • Callee-saved, so we need to save it
  • Points to base (top) of our stack frame
• Useful for accessing stuff we store on the stack, even when the stack pointer is moving up and down
  • You’ll see things like -4(%rbp) a lot
  • Optimization sometimes avoids it

Stack instructions

• push → Move stack pointer %rsp down & store value
• pop → Load value & move stack pointer %rsp up
• call → Move %rsp down, store return address, and jump
• ret → Load return address into %rip and move %rsp up
• leave → Copies %rbp into %rsp and then pops into %rbp
• sub, mov, etc. (Anything that stores to %rsp directly)

Stack Equivalences

Drawing the Stack

Stack grows downwards

Drawing the Stack

Drawing the Stack

• Stack grows downwards from top
• Sometimes grows in multiples of 16 for alignment
• Represents “notes as we go” that we come back to later
  • When calling a function, the current notes get buried
  • When returning, we go back to our old notes
  • If we didn’t write something down, it may be lost

Drawing the Stack

Recursion

long getAndSumValues() {
    long x;
    printf("Enter an integer: ");
    scanf(" %ld",&x);
    if (x == 0) {
        return 0;
    } else {
        return x + getAndSumValues();
    }
}

Explorer link

Recursion

getAndSumValues:
        subq    $24, %rsp
        movl    $.LC0, %edi
        movl    $0, %eax
        call    printf
        leaq    8(%rsp), %rsi
        movl    $.LC1, %edi
        movl    $0, %eax
        call    __isoc99_scanf

        cmpq    $0, 8(%rsp)
        je      .L3
        call    getAndSumValues
        addq    8(%rsp), %rax
        jmp     .L2
.L3:
        movl    $0, %eax
.L2:
        addq    $24, %rsp
        ret

Recursion

getAndSumValues:
        subq    $24, %rsp
        #
        #
        #
        leaq    8(%rsp), %rsi
        #
        #
        call    __isoc99_scanf

        #
        #
        call    getAndSumValues
        addq    8(%rsp), %rax
        #
.L3:
        #
.L2:
        addq    $24, %rsp
        ret

Recursion

getAndSumValues:
        subq    $24, %rsp
        #
        #
        #
        leaq    8(%rsp), %rsi
        #
        #
        call    __isoc99_scanf

        cmpq    $0, 8(%rsp)
        je      .L3
        call    getAndSumValues
        addq    8(%rsp), %rax
        jmp     .L2
.L3:
        movl    $0, %eax
.L2:
        addq    $24, %rsp
        ret

Recursion