Code Generation III

1. Code Generation III

2. PAs • PA4 • 5.1 – 7.2 • PA5 (bonus) • 24.1 – 24.2

3. PA4 • Translate AST to LIR (file.ic -> file.lir) • Instruction list for every method • Dispatch table for each class • Literal strings (all literal strings in file.ic) • Optimizations (optional) • Use microLIR simulator

4. microLIR simulator • Java application • Accepts and executes file.lir • Use it to test your translation • Checks correct syntax • Performs lightweight semantic checks • Runtime semantic checks • Debug modes (-verbose:1|2) • Prints program statistics (#registers, #labels, etc.) • Comes with sample inputs • Read Manual

5. x86 executable exe ICProgram ic IC compiler Compiler LexicalAnalysis Syntax Analysis Parsing AST SymbolTableetc. Inter.Rep.(IR) CodeGeneration

6. Translating static calls StaticCall _A_foo(a=R1,b=5,c=x),R3 LIR code: # push caller-saved registerspush %eaxpush %ecxpush %edx # push parametersmov -4(%ebp),%eax # push xpush %eaxpush $5 # push 5mov -8(%ebp),%eax # push R1push %eax call _A_foo mov %eax,-16(%ebp) # store returned value in R3 # pop parameters (3 params*4 bytes = 12)add $12,%esp # pop caller-saved registerspop %edxpop %ecxpop %eax

7. Translating virtual calls VirtualCall R1.2(b=5,c=x),R3 LIR code: # push caller-saved registerspush %eaxpush %ecxpush %edx R1 DVPtr # push parametersmov -4(%ebp),%eax # push xpush %eaxpush $5 # push 5 x y # Find address of virtual method and call itmov -8(%ebp),%eax # load thispush %eax # push thismov 0(%eax),%eax # Load dispatch table addresscall *8(%eax) # Call table entry 2 (2*4=8) mov %eax,-12(%ebp) # store returned value in R3 _DV_A # pop parameters (2 params+this * 4 bytes = 12)add $12,%esp # pop caller-saved registerspop %edxpop %ecxpop %eax

8. Library function calls • Static function calls • Reference type arguments require non-null runtime check class Library { static void println(string s); // prints string s followed by a newline. static void print(string s); // prints string s. static void printi(inti); // prints integer i. static void printb(boolean b); // prints boolean b. static intreadi(); // reads one character from the input. ...

9. Function prologue/epilogue _A_foo:# prologuepush %ebpmov %esp,%ebp # push local variables of foosub $12,%esp # 3 local vars+regs * 4 = 12 # push callee-saved registerspush %ebxpush %esipush %edi function body _A_foo_epilogoue: # extra label for each function # pop callee-saved registerspop %edipop %esipop %ebx mov %ebp,%esppop %ebpret

10. Representing dispatch tables file.lir PA4 _DV_A: [_A_sleep,_A_rise,_A_shine]_DV_B: [_A_sleep,_B_rise,_B_shine,_B_twinkle] file.ic PA5 class A { void sleep() {…} void rise() {…} void shine() {…} static void foo() {…}}class B extends A { void rise() {…} void shine() {…} void twinkle() {…}} file.s # data section.data .align 4_DV_A: .long _A_sleep .long _A_rise .long _A_shine_DV_B: .long _A_sleep .long _B_rise .long _B_shine .long _B_twinkle

11. Runtime checks • Insert code to check attempt to perform illegal operations • Null pointer check • MoveField, MoveArray, ArrayLength, VirtualCall • Reference arguments to library functions should not be null • Array bounds check • MoveArray • Array allocation size check • __allocateArray(size) – size needs to be >0 • Do we need to check argument of __allocateObject(#)? • Division by zero • Div, Mod • If check fails jump to error handler code that prints a message and gracefully exists program

12. Null pointer check # null pointer check cmp $0,%eax je labelNPE Single generated handler for entire program labelNPE: push $strNPE # error message call __println push $1 # error code call __exit

13. Array bounds check # array bounds check (eax = array, ecx = index) mov -4(%eax),%ebx # ebx = length cmp %ecx,%ebx jle labelABE # ebx <= ecx ? cmp $0,%ecx jl labelABE # ecx < 0 ? Single generated handler for entire program labelABE: push $strABE # error message call __println push $1 # error code call __exit

14. Array allocation size check # array size check cmp $0,%eax # eax == array size jle labelASE # eax <= 0 ? Single generated handler for entire program labelASE: push $strASE # error message call __println push $1 # error code call __exit

15. Division by zero check # division by zero check cmp $0,%eax # eax is divisor je labelDBE # eax == 0 ? Single generated handler for entire program labelDBE: push $strDBE # error message call __println push $1 # error code call __exit

16. Hello world example class Library { void println(string s); ... } class Hello { static void main(string[] args) { Library.println("Hello world\n"); } }

17. Representing strings • Array preceded by a word indicating the length of the array 4 1 1 1 1 1 1 1 1 1 1 1 1 1 n 13 H e l l o w o r l d \ String reference

18. Assembly file structure .title "hello.ic“# global declarations.global __ic_main # data section.data.align 4.int 13str1: .string "Hello world\n“# text (code) section.text#----------------------------------------------------.align 4__ic_main: push %ebp # prologue mov %esp,%ebp push $str1 # print(...) call __print add $4, %esp mov $0,%eax # return 0 mov %ebp,%esp # epilogue pop %ebp ret header statically-allocateddata: string literalsand dispatch tables Method bodiesand error handlers

19. Implementation • Hacker’s approach: translate directly to text • Not flexible • Hard to debug • Use objects representation

20. Possible instruction hierarchy ASMInstr LabelInstr BinOpInstr UnOpInstr CallInstr RetInstr ASMInstr JumpInstr CondJumpInstr

21. Possible operand hierarchy ASMOperand X86Reg Immediate Memory Reg Integer Literal Variable Parameter Displacement

22. Implementation example class BinOpInstr extends ASMInstr { public final Operand src; public final Operand dst; public final String name; public BinOpInstr(String name, Operand src, Operand dst) { // Sanity check if (src instanceof Memory && dst instanceof Memory) { throw new RuntimeException(“Too many memory operands for arith instruction!”); this.name = name; this.src = src; this.dst = dst; } public String toString() {if (ASMInstr.intelSyntax) { return name + “ “ + src + “,” + dst; } else { return name + “ “ + dst + “,” + src; } } }

23. ICProgram prog.ic x86 assembly x86 assembly prog.s prog.s From assembly to executable LexicalAnalysis Syntax Analysis Parsing AST SymbolTableetc. Inter.Rep.(IR) CodeGeneration GNU assembler prog.o GNUlinker prog.exe libic.a(libic + gc)

24. Optimizations • More efficient register allocation for statements • IC statement • Basic Block • Method • … • Eliminate unnecessary labels and jumps • Post-translation pass

25. Optimizing labels/jumps • If we have subsequent labels:_label1:_label2: We can merge labels and redirect jumps to the merged label • If we havejump label1_label1:Can eliminate jump • Eliminate labels not mentioned by any instruction