Machine code generation
Lecture 18

• data
  • Fixed size, global data section (bss section is zeroed out)
• rodata
  • Immutable data, e.g., for string constants
• text
  • Executable part

https://wiki.osdev.org/ELF

• (Diagram)

• (Diagram)

• Holds all information needed to "freeze" state of function
  • Parameters and local variables
  • Return address
  • Caller's stack frame (nested calls)

• Registers and/or stack

• Calling conventions and stack frame layout
  • How to pass parameters
  • Layout of data in the stack frame
  • How to return values
  • Caller and callee responsbilities
• Architecture- and OS-dependent
  • Stack frame layout on x86 64

• %rbp - base pointer points to the current function's stack frame
• %rsp - stack pointer points to the top of the stack
• push/pop - push to and pop from the stack (move data and update %rsp)
• call - saves next instruction address (%rip) onto stack and branches to function's address
• ret - pops the caller's next instruction address and branches to it

• Function definition
  • Prologue
  • Epilogue
• Function call
  • Parameter passing
  • Return value
• (Demo)

# 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

• Emit prologue
  • Save base pointer of caller's stack frame push %rbp
  • Update base pointer to current function's stack frame mov %rsp, %rbp
  • Allocate space on stack for locals and temps sub $96, %rsp
• Emit epilogue for each function
  • Restore stack pointer to caller's mov %rbp, %rsp
  • Restore the base pointer to the caller's stack frame pop %rbp
  • Return ret
    • Recall that this pops the return address from the stack and branches
• Emit return instructions
  • Store result of expression in rax per ABI mov -80(%rbp), %rax
  • Goto the epilogue jmp _main_return

• Move parameters to registers or the stack per the ABI mov -56(%rbp), %rsi
• Make the call call f
  • call will store the return address (the instruction/program counter plus one instruction) onto the stack

f(x, y) {
  return x + y;
}

main() {
  int x;
  int result;
  input x;
  result = f(x, 100);
  output result;
  return 0;
}

[f
CONST _t0 1
ASSIGN true _t0
CONST _t1 0
ASSIGN false _t1
ADD _t2 x y
RETURN _t2
, main
CONST _t0 1
ASSIGN true _t0
CONST _t1 0
ASSIGN false _t1
INPUT x
PARAM x
CONST _t2 100
PARAM _t2
CALL _t3 f
ASSIGN result _t3
OUTPUT result
CONST _t4 0
RETURN _t4
]

.text
.globl f
.type f, @function
f:
        push    %rbp
        mov     %rsp, %rbp
        sub     $64, %rsp
        mov     %rdi, -8(%rbp)
        mov     %rsi, -16(%rbp)
        movq    $1, -40(%rbp)
        mov     -40(%rbp), %rax
        mov     %rax, -24(%rbp)
        movq    $0, -48(%rbp)
        mov     -48(%rbp), %rax
        mov     %rax, -32(%rbp)
        mov     -8(%rbp), %rax
        mov     -16(%rbp), %rcx
        add     %rcx, %rax
        mov     %rax, -56(%rbp)
        mov     -56(%rbp), %rax
        jmp     _f_return
_f_return:
        mov     %rbp, %rsp
        pop     %rbp
        ret
.text
.globl main
.type main, @function
main:
        push    %rbp
        mov     %rsp, %rbp
        sub     $80, %rsp
        movq    $1, -40(%rbp)
        mov     -40(%rbp), %rax
        mov     %rax, -8(%rbp)
        movq    $0, -48(%rbp)
        mov     -48(%rbp), %rax
        mov     %rax, -16(%rbp)
        call    input_int64_t@PLT
        mov     %rax, -24(%rbp)
        mov     -24(%rbp), %rdi
        movq    $100, -56(%rbp)
        mov     -56(%rbp), %rsi
        call    f
        mov     %rax, -64(%rbp)
        mov     -64(%rbp), %rax
        mov     %rax, -32(%rbp)
        mov     -32(%rbp), %rdi
        call    output_int64_t@PLT
        movq    $0, -72(%rbp)
        mov     -72(%rbp), %rax
        jmp     _main_return
_main_return:
        mov     %rbp, %rsp
        pop     %rbp
        ret

Push the complete code generator to the main branch of your github repository. Be sure that it builds with make from the root directory and can be run with java Compiler program.simplec.

The compiler will be checked for functional correctness on a suite of example SimpleC programs with know inputs and outputs. For the example program above, for instance, if we have fun.in1

203

which has known output fun.groundtruth1

303

we can test the compiler by checking its output against the known output:

./fun < fun.in1 > fun.out1
diff fun.groundtruth1 fun.out1
echo $?

diff should produce no output and the exit code $? should be zero. If this goes wrong, you might see something like this

$ ./fun < fun.in1 > fun.out1
$ diff fun.groundtruth1 fun.out1
1c1
< 303
---
> 0
$ echo $?
1