where we are
play

Where We Are Source code Lexical, Syntax, and if (b == 0) a = b; - PowerPoint PPT Presentation

Sep 09, 2023 •341 likes •777 views

Where We Are Source code Lexical, Syntax, and if (b == 0) a = b; Semantic Analysis IR Generation Low-level IR code Optimizations Optimized Low-level IR code Assembly code Assembly code generation cmp $0,%rcx cmovz %rax,%rdx 1 Low IR

  1. Where We Are Source code Lexical, Syntax, and if (b == 0) a = b; Semantic Analysis IR Generation Low-level IR code Optimizations Optimized Low-level IR code Assembly code Assembly code generation cmp $0,%rcx cmovz %rax,%rdx 1

  2. Low IR to Assembly Translation t3 = this.x t3 = t2 * t3 • Low IR code (TAC): t0 = t1 + t2 • Variables (and temporaries) r = t0 • No run-time stack t4 = w + 1 • No calling sequences k = t4 • Some abstract set of instructions • Translation • Calling sequences: • Translate function calls and returns • Manage run-time stack • Variables: • globals, locals, arguments, etc. assigned memory location • Instruction selection: • map sets of low level IR instructions to instructions in the target machine 2

  3. x86-64 crash course • a.k.a. CS 240 review, upgrade to 64 bits • Focus on specific recurring details we need to get right. • Calling Conventions • Memory addressing • Field access • Array indexing • Wacky instructions • Division • Store absolute address • setCC and movzbq 3

  4. x86 IA-32: registers high/low bytes of old 16-bit registers %eax %ax %ah %al accumulate general purpose %ecx counter %cx %ch %cl %edx data %dx %dh %dl %ebx base %bx %bh %bl %esi source index %si %edi destination index %di %esp stack pointer %sp %ebp base pointer %bp 16-bit virtual registers (backwards compatible) 4

  5. x86-64: more registers 64-bits wide %rax %eax %r8 %r8d %rbx %ebx %r9 %r9d %rcx %ecx %r10 %r10d %rdx %edx %r11 %r11d %rsi %esi %r12 %r12d %rdi %edi %r13 %r13d %rsp %esp %r14 %r14d %rbp %ebp %r15 %r15d Only %rsp is special-purpose. 5

  6. [AT&T syntax, used in Unix/Linux/Mac OS X land] Most 2-operand instructions movq Source , Dest : • Get argument(s) from Source (and Dest if, e.g. , arithmetic) • Store result in Dest . • Operand Types: • Immediate: Literal integer data, starts with $ • Examples: $0x400 or $-533 or $foo • Register: One of 16 integer registers • Examples: %rax or %rsi • Memory: 8 consecutive bytes in memory, at address held by register • Simplest example: (%rax) • Various other “address modes” 7

  7. Memory Addressing Modes • General Form: D(Rb,Ri,S) Mem[Reg[Rb] + S*Reg[Ri] + D] • D : Displacement (offset): literal value represented in 1, 2, 4, or 8 bytes • Rb : Base register: Any register • Ri : Index register: Any register except %rsp • S : Scale: literal 1, 2, 4, or 8 • Special Cases: use any combination of D, Rb, Ri and S (Rb) Mem[Reg[Rb]] (Ri=0,S=1,D=0) D(Rb) Mem[Reg[Rb] + D] (Ri=0,S=1) (Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]] (D=0) D(,Ri,S) Mem[S*Reg[Ri]+D] (Rb=0) … 8

  8. Big Picture: Memory Layout Param n … Param 0 Heap Stack variables Return address variables Previous fp Local 0 … Local n Global Global n … variables Global 0 9

  9. (A) x86 IA-32/Linux St Stack Fr Frames High addresses … Caller Callee Argument n Frame … Callee Argument 0 Return Address Caller's base pointer Saved Registers Callee + Frame Local Variables Stack Registers Base/Frame pointer %ebp Stack pointer %esp Stack Top Low addresses

  10. (A) x86 IA-32/Linux St Stack Fr Frames High addresses … Caller Callee Argument n Frame … Callee Argument 0 Return Address Caller's base pointer Saved Registers + Callee Local Variables Frame Stack Registers Base/Frame pointer %ebp Arguments Stack pointer %esp for next call Stack Top Low addresses

  11. (B) x86-64 with ol old-st style St Stack Fr Frames High addresses … Caller x = 16 + n*8 x (%rbp) Callee Argument n Frame 24(%rbp) … 16(%rbp) Callee Argument 0 8(%rbp) Return Address 0(%rbp) Caller's base pointer -8(%rbp) -16(%rbp) Saved Registers + Callee Local Variables Frame Stack Registers Base/Frame pointer %rbp Arguments Stack pointer %rsp for next call Stack Top Low addresses

  12. (C) x86-64 with ne new-st style Stack Frames High addresses x86-64/Linux ABI … No base pointer 1 st 6 args in registers Caller Callee Argument n Frame Stack access relative to %rsp … Compiler knows frame size Callee Argument 6 Return Address Saved Registers + Callee Local Variables Frame 128-byte red zone Stack pointer %rsp safe between calls Stack Top Low addresses

  13. (C) Typical x86-64 ne new-st style Stack High addresses x86-64/Linux ABI No base pointer 1 st 6 args in registers Stack access relative to %rsp Compiler knows frame size Caller Frame Return Address Callee 128-byte red zone Frame Stack pointer %rsp safe between calls Stack Top Low addresses

  14. (D) x86-64 with mi mixed-st style St Stack High addresses No base pointer … All args on stack Stack access relative to %rsp Caller Callee Argument n Frame Compiler knows frame size … Callee Argument 0 Return Address Saved Registers + Callee Local Variables Frame Arguments Stack pointer %rsp for next call Stack Top Low addresses

  15. Saving Registers During Function Calls • Problem: execution of callee may overwrite necessary values in registers • Possibilities: • Callee saves and restores registers • Caller saves and restores registers • … or both 16

  16. x86-64/Linux ABI: register conventions %rax %r8 Return value Argument #5 %rbx %r9 Callee saved Argument #6 %rcx %r10 Caller saved Argument #4 %rdx %r11 Argument #3 Caller Saved %rsi %r12 Callee saved Argument #2 %rdi %r13 Argument #1 Callee saved %rsp Stack pointer %r14 Callee saved %rbp %r15 Callee saved Callee saved Only %rsp is special-purpose. 17

  17. ICC Calling Convention • Always follow x86-64/Linux register save convention . • To interface with external code (LIB), use: • (C) x86-64/Linux calling convention. • To interface with other ICC-generated code , use one of: • (B) use frame pointer and stack pointer, all args on stack • Easiest, more work to convert if you convert to (C) later. • (D) use only stack pointer, all args on stack • Moderately easy, easier to convert to (C) later. • (C) x86-64/Linux calling convention • Harder, requires more register allocation work, more efficient, only use this later if you have time. 18

  18. Example ( B ) • Consider call foo(3, 5): Save only the caller-save registers that • %rcx caller-saved • %rbx callee-saved are used after the call. • result passed back in %rax • Code before call instruction: # push caller saved registers push %rcx # push second parameter push $5 # push first parameter push $3 # push return address & jump to callee call _foo Save only the callee-save • Prologue at start of function: registers that are # push old fp push %rbp overwritten in function # compute new fp mov %rsp, %rbp # push 3 integer local variables sub $24, %rsp # push callee saved registers push %rbx 19

  19. Example ( B ) • Epilogue and end of function: # restore callee-saved registers pop %rbx # pop callee frame, including locals mov %rbp,%rsp # restore old fp pop %rbp # pop return address and jump ret • Code after call instruction: # pop parameters add $16,%rsp # restore caller-saved registers pop %rcx # %rax contains return result You are not likely to need to save/restore registers with the most basic code generation techniques. 20

  20. Simple Code Generation ( D ) • Three-address code makes it easy to generate assembly e.g. a = p+q movq 16(%rsp) , %rax addq 8(%rsp) , %rax movq %rax, 24(%rsp) • Need to consider many language constructs: • Operations: arithmetic, logic, comparisons • Accesses to local variables, global variables • Array accesses, field accesses • Control flow: conditional and unconditional jumps • Method calls, dynamic dispatch • Dynamic allocation (new) • Run-time checks 21

  21. Division movq …, %rcx # divisor, any reg. but %rax,%rdx movq …, %rax # dividend cqto # sign-extend %rax into %rdx:%rax idivq %rcx # divide %rdx:%rax by %rcx # quotient in %rax # remainder in %rdx 22

  22. String Literals , using calling convention (D) .rodata ... Method vectors/vtables and .align 8 vtable pointer initialization .quad 13 will be similar. strlit3: .ascii "Hello, World!" ... .text ... # t4 = "Hello, World!" # Works on both LLVM/Mac OS X and GCC/Linux: leaq strlit3(%rip), %rax # GCC only: movq $strlit3, %rax movq %rax, 8(%rsp) # Library.println(t4); movq 8(%rsp), %rax movq %rax, -8(%rsp) subq 8, %rsp callq __LIB_println 23

  23. cmpq and testq computes %rax - %rcx , cmpq %rcx,%rax sets CF, OF SF, ZF, discards result computes %rax & %rcx , testq %rax,%rcx sets SF, ZF, discards result Flags/condition codes: CF: carry flag, 1 iff carry out OF: overflow flag, 1 iff signed overflow SF: sign flag, 1 iff result's MSB=1 ZF: zero flag, 1 iff result=0 Common pattern to test for 0 or <0: testq %rax, %rax 24

  24. jmp and j CC jCC Condition Jump iff … Always jump Unconditional jmp 1 Equal / Zero je, jz ZF Not Equal / Not Zero jne, jnz ~ZF Greater (Signed) jg ~(SF^OF)&~ZF Greater or Equal (Signed) jge ~(SF^OF) Less (Signed) jl (SF^OF) Jump iff condition Less or Equal (Signed) jle (SF^OF)|ZF Negative js SF Nonnegative jns ~SF Above (unsigned) ja ~CF&~ZF Below (unsigned) jb CF 25

Recommend

More recommend