Code generation: globals, functions
Lecture 09

Note that the heap and stack and created at runtime by the OS

https://wiki.osdev.org/ELF#Loading_ELF_Binaries https://stackoverflow.com/questions/9226088/how-are-the-different-segments-like-heap-stack-text-related-to-the-physical-me

simple_function.simplec

f(a, b) : function(int, int) -> int {
  return a + b;
}

main {
  return f(1, 3);
}

simple_function.s

.file "stdin"
.text
.globl f
.type f, @function
f:
        # emit the function prologue
        push	%rbp
        mov	%rsp, %rbp
        sub	$32, %rsp
        push	%rbx
        # move parameters into the stack
        mov	%rdi, -8(%rbp)
        mov	%rsi, -16(%rbp)
        # generate code for the body
        # generate code for the return expression
        # generate code for the left operand
        mov	-8(%rbp), %rax
        push	%rax
        # generate code for the right operand
        mov	-16(%rbp), %rax
        push	%rax
        # pop the right operand
        pop	%rbx
        # pop the left operand
        pop	%rax
        # do the addition
        add	%rbx, %rax
        # push the expression result
        push	%rax
        # save the return expression into %rax per the abi
        pop	%rax
        pop	%rbx
        mov	%rbp, %rsp
        pop	%rbp
        ret
.text
.globl main
.type main, @function
main:
        # stack space for argc and argv
        # emit main's prologue
        push	%rbp
        mov	%rsp, %rbp
        sub	$32, %rsp
        push	%rbx
        # move argc and argv from parameter registers to the stack
        mov	%rdi, -8(%rbp)
        mov	%rsi, -16(%rbp)
        # generate code for the body
        # generate code for the return expression
        # pass parameters either in registers or in stack
        # evaluate a parameter
        mov	$1, %rax
        push	%rax
        # evaluate a parameter
        mov	$3, %rax
        push	%rax
        # move a parameter to a register
        pop	%rsi
        # move a parameter to a register
        pop	%rdi
        # call the function
        call	f
        # restore the stack afterwards
        # push the return value
        push	%rax
        # save the return expression into %rax per the abi
        pop	%rax
        # emit main's epilogue
        pop	%rbx
        mov	%rbp, %rsp
        pop	%rbp
        ret

showing difference between att and intel assembly syntax

gcc --masm=intel -S abi.c

• Local variables and heap-allocated variables are stored in memory allocated at runtime
• Running program (process) works with the OS to be allocated memory as needed at load and runtime

• User-defined extension of the language
• Lots of uses: abstraction, reuse, organization, interfaces, and more
• Higher-order functions can take functions as inputs
• Lambda functions allow runtime creation of anonymous functions

• Caller transfers control to callee function
• Caller provides input values
• Callee provides output value(s)
• Execution resumes in caller once callee is finished

• Save state on stack
• Unconditional branch
• Save return value
• Another branch to go back to where we left off

Alternatives:

• Allocate state statically
• Use the heap

f(a) {
  return g(a) + 1;
}

g(b) {
  return b * 2;
}

f(2)

stack layout:

• push parameter
• push return address
• push locals

stack frames

• callee points to previous stack frame (previous base pointer)

Can think of recursive functions as invokes a fresh instance of the function, rather than calling itself.

• Registers are faster, but limited in number
• May need to save them before making call

Note that parameter passing is done through registers for the first 6 parameters, then on the stack as needed.

More resources on the ABI and calling conventions

https://sourceware.org/git/?p=glibc.git;a=blob;f=stdio-common/vfprintf-internal.c;h=547a3a868b4668bf615cf3f39a92e3c11cbb98ad;hb=HEAD#l1288

https://wiki.osdev.org/Calling_Conventions

https://eli.thegreenplace.net/2011/09/06/stack-frame-layout-on-x86-64/

https://en.wikipedia.org/wiki/X86_calling_conventions#Register_preservation

https://stackoverflow.com/questions/1658294/whats-the-purpose-of-the-lea-instruction

https://www.fireeye.com/blog/threat-research/2008/03/instruction-poi.html

Recall that "points to" just means that the register holds an address

Recall that compiler is printing out instructions that will implement the stack at runtime, not actually creating the stack while compiling.

# https://github.com/longld/peda
# for C compile with -g for debug symbols
# run gdb
gdb example
b main # break at main
si # step instruction, assembly instructions (intead of code)
info file # get address of rodata
x/8xb 0x0000555555556000 # print memory, 8 he(x) (b)ytes
x/i addr # print as instruction

# dump symtab
objdump -s test

gdb resources:

https://sourceware.org/gdb/onlinedocs/gdb/Memory.html

https://sourceware.org/gdb/onlinedocs/gdb/Registers.html#Registers

https://visualgdb.com/gdbreference/commands/set_disassembly-flavor

http://dbp-consulting.com/tutorials/debugging/basicAsmDebuggingGDB.html

https://github.com/longld/peda

https://sourceware.org/gdb/onlinedocs/gdb/Auto-Display.html#Auto-Display https://sourceware.org/gdb/onlinedocs/gdb/Continuing-and-Stepping.html https://sourceware.org/binutils/docs-2.16/as/index.html https://sourceware.org/binutils/docs/as/i386_002dMemory.html