Programming Language Dilemma Fall 2002 Lecture 1 Introduction to Compilation. Compilation As Translation. Starting Point

Transcription

1 Programming Language Dilemma Fall 2002 Lecture 1 Introduction to Compilation Martin Rinard Laborator for Computer Science Massachusetts Institute of Technolog Stored program computer How to instruct computer what to do? Need a program that computer can execute Must be written in machine language Unproductive to code in machine language Design a higher level language Implement higher level language Alternative 1: Interpreter Alternative 2: Compiler Compilation As Translation Starting Point Source Program in Some Programming Language Ending Point Compiler Generated Program in Machine Language Starting Point Standard imperative language (Java,C, C++) State Variables Structures Arras Computation Expressions (arithmetic, logical, etc.) Assignment statements Control flow (conditionals, loops) Procedures Ending Point State (SPARC) (32 bit resses, bte ressable) 32 Integer Registers g0-g7: global registers g0 reads as 0, writes have no effect o0-o7: output registers l0-l7: local registers i0-i7: input registers Condition Codes Indicate results of integer operations Used in branch instructions Ending Point Computation (SPARC) <r>,<reg> st <reg>, <r> <binar op> <src1>, <src2>, <dst> <comp op> <src1>, <src2> <branch op> <ress> Conditional Unconditional 1

2 Exploring Compiler Behavior Start with sample input programs Compile to assembler using cc S Tr to match up source code with generated code State Translation Variables (global, local, parameters) Structures and arras Computation Translation Expression evaluation and assignment Flow of control constructs Procedure call and return Implementing Global Variables Allocate memor location for variable When program accesses variable, compiler generates load and store instructions int a, b, c; a b c int a, b, c; a = b + c; Implementing Global Variables.align 8.common a,4,4.common b,4,4.common c,4,4 Allocate storage for a,b, and c sethi %hi(b),%l0 or %l0,%lo(b),%l0 [%l0+0],%l2 sethi %hi(c),%l0 or %l0,%lo(c),%l0 [%l0+0],%l1 %l2,%l1,%l1 sethi %hi(a),%l0 or %l0,%lo(a),%l0 st %l1,[%l0+0] Load value of b into l0 Load value of c into l1 Add l0 and l1 Store result into a Sethi Instruction Encode parts of ress in instruction stream Machine code format of sethi instruction: 00 5 bit <reg> bit <immediate> Effect of sethi instruction: Replace top 22 bits of <reg> with <immediate> Set bottom 10 bits of <reg> to zero Example of general theme store constant values in immediate fies of instructions Implementing Local Variables Concept of procedure call stack Each procedure invocation has state Local variables Return ress Stores state in frame New frame allocated for each call Frames usuall allocated on call stack Call stack allocated at top of memor Call stack grows down Implementing Local Variables Frame pointer register points to current frame Decreases at calls (stack grows down) Increases on returns Local variables allocated in frame int a, b, c; Frame for invocation of proc Frame for caller of proc Local variables of proc a b c Return r Registers fp 2

3 Implementing Local Variables int a, b, c; a = b + c; st [%fp-12],%l0 [%fp-16],%l1 %l0,%l1,%l0 %l0,[%fp-8] Note: %fp is same as %i6 Points to frame for procedure Implementing Structures Structures contain several fies Each structure tpicall stored in a contiguous block of memor tpedef struct { int x,, z; foo; foo *p; z x p Implementing Structures Optimized Version tpedef struct { int x,, z; foo; foo *f; f->x = f->+f->z; st [%fp-8],%l0 %l0,4,%l0 [%l0+0],%l2 [%fp-8],%l0 %l0,8,%l0 [%l0+0],%l1 %l2,%l1,%l1 [%fp-8],%l0 %l1,[%l0+0] Compute ress of f-> load f-> Compute ress of f->z load f->z values Store into f->x tpedef struct { int x,, z; foo; foo *f; f->x = f->+f->z; st [%fp-4],%o0 [%o0+4],%o1 [%o0+8],%o2 %o1,%o2,%o1 %o1,[%o0] Alignment, Ping, and Packing Ping and Packing Example Machines often have alignment requirements Integers (4 btes) must start at 4-bte aligned ress (bottom 2 bits 0) Shorts (2 btes) must start at 2-bte aligned ress (bottom bit 0) Alignment requirements raise issues Ping between fies to ensure alignment Fie packing to minimize memor usage tpedef struct { int w; char x; int ; char z; foo; foo *p; Naïve Laout z x w Packed Laout (4 bte savings) x, z w p p 3

4 Implementing Arras Allocate memor locations for arra elements Elements stored contiguousl int a[4]; a[3] a[2] a[1] a[0] int a[4]; int i, j; i = a[j]; Implementing Arras [%fp-12],%l0 sll %l0,2,%l0 sethi %hi(a),%l1 or %l1,%lo(a),%l1 %l0,%l1,%l0 [%l0+0],%l0 st %l0,[%fp-8] Compute ress of a[j] load a[j] into l0 store l0 into i ress of a[j] = ress of a[0] + (4 * j) = a + (4 * j) Expression Evaluation Implementing Expression Evaluation Evaluate subexpressions, combine to get value of outer expression Must alwas have values of operands in registers Final result placed in register int x; int a,b; a = 3; b = 2; x = (a+b)-(a b); mov 3,%l0 st %l0,[%fp-8] mov 2,%l0 st %l0,[%fp-12] [%fp-8],%l0 [%fp-12],%l1 %l0,%l1,%l2 [%fp-8],%l0 [%fp-12],%l1 or %l0,%l1,%l1 sub %l2,%l1,%l1 sethi %hi(x),%l0 or %l0,%lo(x),%l0 st %l1,[%l0+0] Initialize a and b Load a and b Add a and b to l2 Load a and b Or a and b to l1 Compute l1=l2-l1 Load ress of x Store result in x Implementation Issues Optimized Implementation Generating a linear sequence of instructions to compute a nested expression Allocate storage for temporar values Tpicall registers, but there are a limited number of registers for machine Ma need to store temporaries in memor Expression evaluation order affects number of values ou need to keep around In man cases, ma be able to staticall compute value of subexpressions int x; int a,b; a = 3; b = 2; x = (a+b)-(a b); or %g0,2,%g2 sethi %hi(x),%g1 st %g2,[%g1+%lo(x)] 4

5 Flow of Control Convert structured flow of control to branch statements Two pervasive shapes if C then A else B Code to evaluate C Code to execute A Code to execute B Code after if statement while C A Code to evaluate C Code to execute A Code after while statement int a, b; if (a) { b = 0; else { b = 1; Conditional Example [%g1+%lo(a)],%g1 cmp %g1,0 be.l1 sethi %hi(b),%g1 br.l2 st %g0,[%g1+%lo(b)].l1: or %g0,1,%g2 st %g2,[%g1+%lo(b)].l2 retl Optimized Conditional Example Apparent Anomal in Code int a, b; if (a) { b = 0; else { b = 1; [%g1+%lo(a)],%g1 cmp %g1,0 be.l1 sethi %hi(b),%g1 retl st %g0,[%g1+%lo(b)].l1: or %g0,1,%g2 retl st %g2,[%g1+%lo(b)] int a, b; if (a) { b = 0; else { b = 1; [%g1+%lo(a)],%g1 cmp %g1,0 be.l1 sethi %hi(b),%g1 br.l2 // branch over else part st %g0,[%g1+%lo(b)] // store value into b for then part.l1: or %g0,1,%g2 st %g2,[%g1+%lo(b)].l2 retl Branch appears before store Wh will b get correct value? Concept of Branch Dela Slots In SPARC architecture, instruction after branch executes even if branch is taken! be.l1 sethi %hi(b),%g1 This instruction executes even if the branch is taken! Wh do this? It improved the performance of the initial version of the processor Compiler cou handle the complexit What if there is no instruction to execute?! Instruction Scheduling Branch dela slots are special case of instruction scheduling Instruction scheduling packs instructions together for concurrent/pipelined execution Sophisticated part of compilation Moves work from hardware to compiler Illustrates rarit of direct assembl coding Required for IA-64 to work well 5

6 int a[10]; int n = 10; int i; i = 0; while (i < n) { a[i]++; i++; Implementation of Loops Initialize i to 0 and n to 10 Load i and n Branch to end if i >= n Compute ress of a[i] Load a[i] Increment value Store back into a[i] Increment i Branch back to top if i < n int a[10]; int n = 10; int i; i = 0; while (i < n) { a[i]++; i++; Implementation mov 10,%l0 st %l0,[%fp-8] mov 0,%l0 st %l0,[%fp-12] [%fp-12],%l1 [%fp-8],%l0 cmp %l1,%l0 bge.l18.l16: sll [%fp-12],%l0 %l0,2,%l0 sethi %hi(a),%l1 or %l1,%lo(a),%l1 %l0,%l1,%l0 st %l0,[%fp-16] [%fp-16],%l0 [%l0+0],%l0 %l0,1,%l1 [%fp-16],%l0 st %l1,[%l0+0] [%fp-12],%l0 %l0,1,%l0 st %l0,[%fp-12] [%fp-12],%l1 [%fp-8],%l0 cmp %l1,%l0 bl.l16.l18 Optimizations Keep i and ress of a[i] in registers Compute ress of a[0] before loop bod, increment b 4 in loop bod Don t store n in memor or register, just use 10 whenever ou see it Omit initial branch at top of loop Optimized Implementation int a[10]; int n = 10; int i; i = 0; while (i < n) { a[i]++; i++; %g1,%lo(a),%g1 or %g0,0,%g2 [%g1],%g3.l : %g3,1,%g3 st %g3,[%g1] %g2,1,%g2 %g1,4,%g1 cmp %g2,10 bl,a.l [%g1],%g3.l : Load base ress of a Init i Load a[i] Increment and store a[i] Update i and ptr to a[i] Loop back Load a[i] int a[10]; int n = 10; int i; i = 0; while (i < n) { a[i]++; i++; More Optimizations %g1,%lo(a),%g1 or %g0,0,%g2 [%g1],%g3.l : %g3,1,%g3 st %g3,[%g1] %g2,1,%g2 %g1,4,%g1 cmp %g1,10 a+40 bl,a.l [%g1],%g3.l : Load base ress of a Init i Load a[i] Increment and store a[i] Update i and ptr to a[i] Loop back Load a[i] Procedure Call Protocol between caller and callee Heavil architecture dependent SPARC concepts Caller actions Store parameters in o0-o6 Jump to callee, storing PC in o7 Get return result in o0 Callee actions Get parameters in i0-i6, PC from caller in i7 Put return result in i0 Use PC from caller to return back to caller 6

7 Register Windows Parameter issue Caller puts parameters in o0-06 Callee expects parameters in i0-i6 Return result issue Callee puts return result in i0 Caller expects result in o0 Wh? Register windows! Conceptuall, have an overlapping stack of register windows Visual Register Windows Prev i0-i7 l0-l7 o0-o7 Current i0-i7 l0-l7 o0-o7 Have current window i0-i7 of current window are same as o0-o7 of previous window o0-o7 of current window are same as i0-i7 of next window g0-g7 Next i0-i7 l0-l7 o0-o7 Register Window Instructions save %sp, <num>, %sp Pushes current window on stack Allocates new window (%o0-%o7 become %i0-%i7, new l0-l7 and o0-o7) Sets %sp (%o6) in new window to %sp in o window plus <num> Note that %o6 in o window becomes %i6 in new window (%sp becomes %fp) restore Pops current window (%i0-%i7 become %o0-%o7) Stack and Frame Pointers save %sp, -12, %sp (In practice, need at least btes to O Reg Win leave space for reg saves) %fp = %i6 New Reg Win %sp = %o6 %fp = %i6 %sp = %o6 Procedure Call Example Procedure Example Standard Prologue save st %sp,-104,%sp %i0,[%fp+68] New Reg Win, frame Store param int n; bar() { foo(n); sethi %hi(n),%l0 or %l0,%lo(n),%l0 [%l0+0],%l0 mov %l0,%o0 call foo Load n Set up parameter Call foo (stores PC of call instruction into %o7) int foo(int n) { return n+1; Standard Epilogue [%fp+68],%l0 %l0,1,%l0 st %l0,[%fp-4] Compute result ba.l13.l13: [%fp-4],%l0 mov %l0,%i0 Load result jmp %i7+8 Return to caller restore Restore Reg Win & frame 7

8 int foo(int n) { return n+1; Optimized Leaf Procedure Punt register windows completel Just compute in window from caller jmp %o7+8 %o0,1,%o0 Return to caller Compute result Complex Design Need for separate compilation Must be standard call/return protocol Need for performance Parameters/return value passed in registers Supports efficient caller/callee linkage Protocol supports tailored code generation Caller does not set up register window, frame pointer, or stack pointer for callee Enables leaf procedure optimizations Compiler hides all this from programmer! Objects and Inheritance Ke Consideration: Subtping Object consists of State (fies of object) Behavior (methods) Inheritance Augment base class with new fies Augment behavior of base class with new methods Override some methods of base class If B inherits from A, then Anwhere program declares object of tpe A Must be able to execute with object of tpe B Implementing Object State (Single Inheritance Onl) Extension of structure approach Store fies in contiguous block of memor Fies of extending class stored after fies of base class fies x of B w fies z of A Ke propert - fies from base class stored at same offset in all objects that inherit from base class void p(a) { a.f(); Virtual Function Calls (Single Inheritance Onl) A a = new A(); int i = p(); // p() calls f() in class A B b = new B(); int j = p(); // p() calls f() in class B Different executions of this call site ma invoke different methods Invoked method depends on class of object 8

9 void p(a) { a.f(); Vtable Approach Each object has reference to a vtable One vtable per class Vtable contains pointers to methods for all objects of its class Vtable for A objects Vtable for B objects z x w z vtable ptr vtable ptr A object B object void p(a) { a.f(); Virtual Function Calls Calling convention stas same But call site determines ress of the invoked method dnamicall Generated Code at Call Site [%i0],%o1 [%o1],%o1 call %o1,0 Load vtable ptr Load function ptr Indirect call Summar Compiler responsibilities Data laout and access Global and local variables, parameters Structures, arras, and objects Expression evaluation Flow of control Procedure and method calls Hide low-level machine complexities Optimizations 9