Run-time environments

Transcription

1 Status Genetion Goals and Considetions sis okens eliminates illegal tokens rees eliminates ill-formed parse trees tic analysis ecoted tree with additional information attached eliminates remaining static errors dynamic back-end phases: = we are here tion (at various semantic levels) ion : execution of geneted code must be consistent with s specified dynamic semantics however, these semantics do not completely specify ben to allow compiler to accomplish other goals, such as uce code that executes as quickly as possible, or reliably in timing constints (as in real-time systems) ze size of geneted progm or of runtime data strucize optimization can be conflicting goals Why? speed: especially during development or when using JITs cations in code genetion come from trying to be fast rrect, because this requires attention to special cases 2: CS164: Lecture # : CS164: Lecture #25 4 5: Introduction to Runtime Organization Run-time environments ng code genetion, we need to understand what we are ate e term virtual machine to refer to the compiler s target a bare hardware architecture(small embedded systems) terpreter, as for Java, or an interpreter that does adpilation at execution, as in modern Java JITs a machine whose machine language is another progme such as C, Java, or Javascript ll stick to hardware + conventions for using it (the API: rogmmer s interface) + some runtime-support libry 2: CS164: Lecture # : CS164: Lecture #25 3

2 tivations and Lifetimes (Extents) Activation Records of procedure P is an activation of P of an activation of P is all the steps to execute P, he steps in procedures P calls (extent) of a variable is the portion of execution durt variable exists (whether or not the code currently n reference it) dynamic (run-time) concept, as opposed to scope, which procedure activations and local variables properly nest read), suggesting a stack data structure for maintainime state les have extents that are not coordinated with procereturns tion needed to manage one procedure activation is called n record (AR) or (stack) fme e F (the caller) calls G (the callee), typically G s activacontains a mix of data about F and G: ddress to instructions in F ink to the AR for F save registers needed by F r G s local variables ion needed to find non-local variables needed by G ry space for intermediate results, arguments to and rees from functions that G calls machine status needed to restore F s context (signal oating-point unit pameters) n architecture and compiler, registers typically hold part mes), especially pameters, return values,, and the current stack top and fme 2: CS164: Lecture # : CS164: Lecture #25 8 Subgoals and Constints improving speed and size: nstruction counts structure static, known at compilation (eg, known conets to fields) Contst Java and Python use of registers ( top of the memory hierchy ) improving compilation speed: p analyses as local as possible (single statement, block, ), because their compilation-time cost tends to be nonssumptions about control flow: procedure calls always atements genelly execute in sequence (Where are ted?) Memory Layout of procedure activations and variables give rise to the l data layout for a (single-threaded) progm: Execution stack ( stack segment ) Dynamic data ( heap ) Static data ( data segment(s) ) Highest memory address 2: CS164: Lecture #25 5 Instructions ( text segment(s) ) Lowest memory address 22: CS164: Lecture #25 7

3 Static Stoge hieving Runtime Effects Functions stoge refers to variables whose extent is an entire d whose size is typically fixed before execution y stored in an activation record, but assigned a fixed iables with file scope (declared static in C) and with age ( global ) are in static stoge variables are an odd case: they don t really fit this ) sign and runtime design intect Semantics of funcood example nction features: recursion, no nesting, fixed-sized data with size known er rsion ble-sized unboxed data ting of functions, up-level addressing ction values w/ properly nested accesses only el closures tinuations ween these effects and structure of machines: anguages typically only make it easy to access things at s like R +C, where R is an address in a register and C vely small integer constant e, fixed offsets good, data-dependent offsets bad 2: CS164: Lecture # : CS164: Lecture #25 12 Calling Conventions ns are possible: nge order of fme elements caller/callee responsibilities differently to use an ary-like implementation of the stack: can d list of ARs ion is better if it improves execution speed or simplifies ion must determine, at compile-time, the layout of activaand genete code that correctly accesses locations in n record, it is common to compile procedures sepately and ss of each other s details, which motivates the impong conventions Heap Stoge hose extent is greater than that of the AR in which they can t be kept there: ) { return new Bar(); } oge dynamically allocated ocated out of an area called the heap (confusingly, not the heap used for priority qeues!) 2: CS164: Lecture # : CS164: Lecture #25 11

4 1: Calling conventions ng Sequence when Fme Size is Fixed se function inlining, will need to save return address, ny options Here s one example, from the IBM 360, of on F from G and passing values 3 and 4: F Reserve 2 4-byte words of static stoge */ G R1,GArgs Load Address of arguments into register 1 R0,3 Store 3 and 4 in GArgs+0 and GArgs+4 R0,GArgs R0,4 R0,GArgs+4 R14,F Call ("Bnch and Link") to F, R14 gets return point ontain F F R14,FRet Save return address R2,0(R1) Load first argument nks not really needed lls g calls f, as at right the initial code of g (its crements the stack pointer f g s activation record (its epilogue): s the stack pointer by this he return address, and to address just popped arguments to f g s arguments to g fixed distance Base of 1st fme R14,FRet Get return address R14 Bnch to it 2: CS164: Lecture # : CS164: Lecture #25 16 ecursion, no nesting, fixed-sized data 2: Add recursion of data is bounded, and there is only one instantiation at a time es, return addresses, and return values can go in fixed ded at all d FORTRAN progms in the early days ispense with call instructions altogether: expand funcine Eg, = becomes = x_1 = 3 x_1 *= 42 y_1 = 9 + x_1 g (x_1, y_1) gm may get bigger than you want Typically, one inll, frequently executed functions amount of data is und sevel instantiations of n be active simultaneously e kind of expandable data stack riable sizes still fixed, so activation record (stack ed iable addresses and the mic link are known offsets ointer, which is typically in shows the conventions we a32, where we ll define a as starting after the re- ) arguments to f g s arguments to g fixed distance Base of 1st fme 2: CS164: Lecture # : CS164: Lecture #25 15

5 Add Variable-Sized Unboxed Data 3: Calling sequence for the ia32 ans not on heap all quantities on stack to e ementations have fixedmes st heap allocation, so s also provide for placing data directly on stack ion on the stack ) g ed dynamic link () insure fixed offsets of ame base (fme pointer) lls g, which has variableary (see right) unboxed stoge other local pointer arguments to g Fme pointer Assembly excerpt (GNU opend order): f: / Return address (RA) at SP, x at SP+4, y at SP+8 pushl %ebp / PRO: Save old dynamic link movl %esp, %ebp / PRO: Set ebp to current fme base subl $4, %esp / PRO: Decrement SP to make space for s movl $1, -4(%ebp) / s = 1 L2: cmpl $0, 12(%ebp) / compare 0 with y (now at BP+12) jle L3 movl -4(%ebp), %eax / tmp = s imull 8(%ebp), %eax / tmp *= x movl %eax, -4(%ebp) / s = tmp leal 12(%ebp), %eax / tmp = &y decl (%eax) / *tmp -= 1 jmp L2 L3: movl -4(%ebp), %eax / return s leave / EPI: Restore %esp to %ebp+4, %ebp to 0(%ebp), ret / EPI: and then pop RA and return g: movl $5, 4(%esp) / Put q and 5 on stack (q on top) movl 8(%ebp), %eax / tmp = q movl %eax, (%esp) / top of stack = q call f / bnch to f and push address of next next: 2: CS164: Lecture # : CS164: Lecture # : Calling sequence from ia32 Other Uses of the Dynamic Link { ; Assembly excerpt (GNU opend order): / PRO = Prologue, EPI = Epilogue f: / Return address (RA) at SP, x at SP+4, y at SP+8 subl $4, %esp / PRO: Decrement SP to make space for s movl $1, (%esp) / s = 1 L2: cmpl $0, 12(%esp) / compare 0 with y (now at SP+12) jle L3 movl (%esp), %eax / tmp = s imull 8(%esp), %eax / tmp *= x movl %eax, (%esp) / s = tmp leal 12(%esp), %eax / tmp = &y decl (%eax) / *tmp -= 1 jmp L2 L3: movl (%esp), %eax / return s in EAX addl $4, %esp / EPI: Restore stack pointer so RA on top, ret / EPI: then pop RA and return g: movl $5, 4(%esp) / Put q and 5 on stack (q on top) movl 12(%esp), %eax / tmp = q movl %eax, (%esp) / top of stack = q call f / bnch to f and push address of next next: ynamic link even when size of AR is fixed f same sttegy for all ARs, simplifies code genetion sier to write genel functions that unwind the stack s off, thus returning) 2: CS164: Lecture # : CS164: Lecture #25 19

6 this problem, go nment diagms! had a pointer to sing environment xample from last fme contains a e f fme where efined: the static cal variable, use ointer (or maybe ) bal, use absolute al of nesting functatic link once per levels of nesting Static Links g s fme g s fme g s fme fme Calling sequence for the ia32: f1 eturn s; } 1) { + n1 s + g1 (); s) + f1 (n0) (); to f1 points to: y of n1 tic link f0 s fme */ f1: / Static link to f0 s fme is in %ecx pushl %ebp / PRO movl %esp, %ebp / PRO pushl %esi / PRO: Save %esi pushl %ebx / PRO: Save %ebx subl $32, %esp / PRO movl %ecx, %ebx / Save link to f0 s fme movl 8(%ebp), %eax / Move n1 movl %eax, -16(%ebp) / to new local movl %ebx, -12(%ebp) / Save static link to f0 in local movl 4(%ebx), %edx / Fetch s from f0 s fme movl %edx, (%esp) / And pass to f2 leal -16(%ebp), %ecx / Pass static link to my fme to f2 call f2 movl %eax, %esi / Save f2(s) movl (%ebx), %eax / Fetch n0 from f0 s fme movl %eax, (%esp) / and pass to f1 movl %ebx, %ecx / Also pass on my static link call f1 addl %eax, %esi / Compute f2(s) + f1(n0) movl %ebx, %ecx / Pass same static link to g1 call g1 leal (%esi,%eax), %eax / Compute f2(s)+f1(n0)+g1() addl $32, %esp / EPI popl %ebx / EPI: restore %ebx popl %esi / EPI: restored %esi popl %ebp / EPI ret / EPI 2: CS164: Lecture # : CS164: Lecture #25 24 esting of Functions, Up-Level Addressing Calling sequence for the ia32: f0 ns can be nested, there ses of variable: nction closing function or (c) is easy It s (b) ting ython): Local to f q): 0: return q+y eturn g (n-1, q*2) e any distance away from g s fme g s fme g s fme fme How far??? Enclosing f eturn s; } 1) { + n1 s + g1 (); s) + f1 (n0) (); Assembly excerpt for f0: f0: / Does not need to be passed a static link pushl %ebp / PRO movl %esp, %ebp / PRO subl $40, %esp / PRO movl 8(%ebp), %eax / Fetch n0 movl %eax, -16(%ebp) / Move n0 to new local variable movl -16(%ebp), %eax / Negate n0 negl %eax movl %eax, -12(%ebp) / and store in s leal -16(%ebp), %eax / Compute static link to f0 s fme movl $10, (%esp) / Pass argument 10 movl %eax, %ecx / and static link call f1 / to f1 leave / EPI ret / EPI / Static link into f0 s fme points to: / int n0 / Copy of n0 / int s 2: CS164: Lecture # : CS164: Lecture #25 23

7 alling sequence for the ia32: f2 Using the global display (sketch) turn s; } ) { + n1 + g1 (); ) + f1 (n0) (); Assembly excerpt for f2: f2: / Static link (into f1 s fme) in %ecx pushl %ebp / PRO movl %esp, %ebp / PRO pushl %ebx / PRO: Save %ebx movl %ecx, %eax / Fetch static link to f0 movl 4(%eax), %edx / from f1 s fme movl (%edx), %ecx / to get n0 from f0 s fme movl (%eax), %edx / Fetch n1 from f1 s fme addl %edx, %ecx / Add n0 + n1 movl 4(%eax), %edx / Fetch static link to f0 again movl 4(%edx), %edx / Fetch s from f0 s fme leal (%ecx,%edx), %ebx / And add to n0 + n1 movl 4(%eax), %eax / Fetch static link to f0 movl %eax, %ecx / and pass to g1 call g1 leal (%ebx,%eax), %eax / Add g1() to n0 + n1 + s popl %ebx / EPI: Restore %ebx popl %ebp / EPI ret / EPI eturn s; } 1) { + n1 s + g1 (); s) + f1 (n0) (); f0: movl _DISPLAY+0,%eax / PRO: Save old _DISPLAY[0] movl %eax,-12(%ebp) / PRO: somewhere movl %ebp,_display+0 / PRO: Put my %ebp in _DISPLAY[0] movl -12(%ebp),%ecx / EPI: Restore old _DISPLAY[0] movl %ecx,_display+0 / EPI f1: movl _DISPLAY+4,%eax / PRO: Save old _DISPLAY[1] movl %eax,-12(%ebp) / PRO: somewhere movl %ebp,_display+4 / PRO: Put my %ebp in _DISPLAY[1] likewise for epilogue f2 and g1: no ext code, since they have no nested functions 2: CS164: Lecture # : CS164: Lecture #25 28 alling sequence for the ia32: g1 The Global Display turn s; } ) { + n1 + g1 (); ) + f1 (n0) (); Assembly excerpt for g1: g1: / Static link (to f0 s fme) in %ecx pushl %ebp / PRO movl %esp, %ebp / PRO movl %ecx, %eax / Fetch s from movl 4(%eax), %eax / f0 s fme popl %ebp / EPI ret / EPI first solution to nested function d an ary indexed by call level, static links 1 () : (): g2 () (): g2 () g1 () () f1 () : f1 () enter a function at lexical level k nside k functions), save pointer to e in DISPLAY[k]; restore on exit able at lexical level k through g1 s fme g2 s fme g2 s fme f2 s fme f1 s fme f1 s fme g1 s fme g2 2 g1 1 f0 0 ly on scope rules and proper nesting f0 s fme DISPLAY 2: CS164: Lecture # : CS164: Lecture #25 27

8 Function Value Representation Representing Closures ): (y): f2 (z): turn x + y + z t h1 (f2) (g): g (3) ) om the main progm; e stack when f2 finally see right) s value (as a function) ed, current fme is That is stored in the ed to h1 static links; global disique does not fare as ] f2 s fme h1 s fme f1 s fme f0 s fme Value of g (ie, f2) code for f2 st forbid this case (as guages do): 68 would not allow r to f (last slide) to be ed from incr e could allow it, and do hing ndom when f (ie ta) is called and Python allow it and ght thing t in genel put local (and a static link) in a n the heap, instead of ack temp stoge etc delta, & n Value of incr(2) code for f 2: CS164: Lecture # : CS164: Lecture #25 32 unction Values, Properly Nested Access function nesting al variables are global, and have fixed addresses esent a variable whose value is a function, need only to ress of the function s code sted functions possible, function value must contain n is finally called, must be told what its static link is that access is properly nested: variables accessed only e of their fme sent function with address of code + the address of at contains that function s definition ent diagms again!! 6: Genel Closures ppens when the fme unction value points to y? ed the previous repre- (#5), we d get a danter in this case: ncr (n): lta = n f f (x): return delta + x turn f incr(2) p2(3) incr s fme with delta During execution of incr(2) Value of incr(2) code for f 2: CS164: Lecture # : CS164: Lecture #25 31

9 Representing Closures Could just forbid this case (as some languages do): Algol 68 would not allow pointer to f (last slide) to be returned from incr Or, one could allow it, and do something ndom when f (ie via delta) is called Scheme and Python allow it and do the right thing But must in genel put local variables (and a static link) in a record on the heap, instead of on the stack Now fme can disappear harmlessly delta, & n Value of incr(2) code for f Last modified: Fri Mar 30 13:22: CS164: Lecture #25 32

10 Summary roblem Solution ecursion, no nestzed data with size static variables to hold return Use inline expansion or use mpiler, first-class addresses,, etc es on Need stack variable-sized un- Need to keep both stack pointer and fme pointer lass function values Add static link or global display ctions, up-level ad- on values w/ propccesses: functions tain their link (Global display Static link, function values con- meters only doesn t work so well) al closures: firstons returned from link on heap Store local variables and static stored in variables ations Put everything on the heap 2: CS164: Lecture # : Continuations tion return were not the end? ): return cont c : "a", x, n, ll_with_continuation (f) "b", x, n, -1); print "c", x, n, 1; print; c() # Prints: # a 1 0 b 1 0 c 1 1 c 1 2 # b 2 0 c 2 1 c 2 2 # b 3 0 c 3 1 c 3 2 tion, c, passed to f is the function that does whatever o happen after I return from f o implement exceptions, threads, co-routines ion? Nothingmuchforitbuttoputallactivationfmes ost can do better on special cases like exceptions 2: CS164: Lecture #25 33