Code Generation
COP-5621, Spring 2024

• Immediate: $1
• Register: %rax
• Memory: 0xdeadbeef
• Register indirect (pointers): (%rbp)
  • %rbp is a register that holds an address
• Register indirect plus offset: -32(%rbp)
  • Get value at address in %rbp minus 32 bytes

AT&T syntax puts destination second, e.g., to move contents of %rbx to %rax, use

movq %rbx, %rax

AT&T syntax makes addition look odd:

add %rbx, %rax

if %rbx is 2 and %rax is 0, what is the state of the machine after?

sub %rbx, %rax

movq	$1, -24(%rbp)

mov	-24(%rbp), %rax

mov	%rax, -8(%rbp)

mov	-8(%rbp), %rax
mov	-40(%rbp), %rbx
add	%rbx, %rax

sub	%rbx, %rax

imul	%rbx, %rax

mov	-32(%rbp), %rax
mov	-16(%rbp), %rbx
cdq
idiv	%rbx

jmp is the unconditional branch. It takes an address or a label, which the assembly uses to compute the branch offset. Labels can be placed before other assembly code, e.g., .BB2 below.

        jmp	.BB2
.BB2:
   # more assembly code

No explicit Boolean value. Instead stored in flag register. cmp is effectively subtraction without the result. The result of each operation sets flag registers

cmp	$0, %rax
jl	.BB3

What jump conditions do we need for While2Addr?

• 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

p

• (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

# 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

#include <stdio.h>
#include <stdint.h>

int64_t input_int64_t() {
  int64_t x;
  scanf("%ld", &x);
  return x;
}

void output_int64_t(int64_t x) {
  printf("%ld\n", x);
}

Always link with it (so generated code can call it)

Insert calls into generated code

# initialize return value from input_int64_t
movl 	$0, %eax
# call returns to %rax
call	input_int64_t@PLT
# save return value to inparam
movq	%rax, -56(%rbp)

# call to output_int64_t
# get outparam
movq	-48(%rbp), %rax
# %rdi is the first function argument
movq	%rax, %rdi
call	output_int64_t@PLT

Allocates 80 bytes of stack space for local variables

# prologue, save old base pointer, update stack pointer
pushq	%rbp
movq	%rsp, %rbp
# allocate space for stack local variables
subq	$80, %rsp

Pop local variables, restore caller's stack frame, set return value

# set main's return value
movl	$0, %eax
# epilogue, restore stack pointer, restore old base pointer
mov	%rbp, %rsp
pop	%rbp
ret

begin
outparam := 1;
while inparam > 1 do begin
inparam := inparam - 1;
outparam := outparam * inparam
end
end

0: _t0 := 1
1: outparam := _t0
2: _t1 := 1
3: _t3 := _t1 - inparam
4: if _t3 < 0 goto 7
5: _t2 := 0
6: goto 8
7: _t2 := 1
8: if _t2 = 0 goto 15
9: _t4 := 1
10: _t5 := inparam - _t4
11: inparam := _t5
12: _t6 := outparam * inparam
13: outparam := _t6
14: goto 2

        .file "stdin"
        .text
        .globl main
        .type main, @function
main:
        # prologue, save old base pointer, update stack pointer
        pushq	%rbp
        movq	%rsp, %rbp
        # allocate space for stack local variables
        subq	$96, %rsp
        # prepare args to input_int64_t
        movl 	$0, %eax
        # call returns to %rax
        call	input_int64_t@PLT
        # save return value to inparam
        movq	%rax, -72(%rbp)
.BB0:
        jmp	.BB1
.BB1:
        movq	$1, -32(%rbp)
        mov	-32(%rbp), %rax
        mov	%rax, -64(%rbp)
        jmp	.BB2
.BB2:
        movq	$1, -48(%rbp)
        mov	-48(%rbp), %rax
        mov	-72(%rbp), %rbx
        sub	%rbx, %rax
        mov	%rax, -40(%rbp)
        mov	-40(%rbp), %rax
        cmp	$0, %rax
        jl	.BB4
        jmp	.BB3
.BB3:
        movq	$0, -24(%rbp)
        jmp	.BB5
.BB4:
        movq	$1, -24(%rbp)
        jmp	.BB5
.BB5:
        mov	-24(%rbp), %rax
        cmp	$0, %rax
        je	.BB7
        jmp	.BB6
.BB6:
        movq	$1, -56(%rbp)
        mov	-72(%rbp), %rax
        mov	-56(%rbp), %rbx
        sub	%rbx, %rax
        mov	%rax, -16(%rbp)
        mov	-16(%rbp), %rax
        mov	%rax, -72(%rbp)
        mov	-64(%rbp), %rax
        mov	-72(%rbp), %rbx
        imul	%rbx, %rax
        mov	%rax, -8(%rbp)
        mov	-8(%rbp), %rax
        mov	%rax, -64(%rbp)
        jmp	.BB2
.BB7:
        # call to output_int64_t
        # get outparam
        movq	-64(%rbp), %rax
        # %rdi is the first function argument
        movq	%rax, %rdi
        call	output_int64_t@PLT
        # set main's return value
        movl	$0, %eax
        # epilogue, restore stack pointer, restore old base pointer
        mov	%rbp, %rsp
        pop	%rbp
        ret

https://web.stanford.edu/class/archive/cs/cs143/cs143.1128/lectures/17/Slides17.pdf