Run-Time Organization

Transcription

1 Run-Time Organization Honors Compilers, NYU, Fall,

2 Run-Time Environment Declarations introduce names that denote entities. At execution time, entities are bound to values or to locations. name value (functional) name location value (imperative) Value binding takes place during function invocation. Names are bound to memory locations on scope entry. Locations are bound to values by assignment. Compiler establishes symbolic mapping between names and locations: name offset from run-time pointer. Run-time pointer is stack frame, TOC entry, static link, etc. Honors Compilers, NYU, Fall,

3 Run-Time Organization Each subprogram invocation creates an activation record. Recursion imposes stack allocation (all languages today). Activation record holds actuals, linkage information, saved registers, local entities. Caller: places actuals on stack, return address, linkage information, then transfers control to callee. Prologue: save registers, allocate space for locals. Epilogue: place return value in register or stack position, update actuals, restore registers, then transfer control to caller. Binding of locations: Actuals and locals are at fixed offsets from frame pointers. Complications: Variable number of actuals, dynamic objects. Honors Compilers, NYU, Fall,

4 Activation Record Layout actual actual Frame pointer Return addr Save area local local Stack pointer Handled by Caller Handled by Callee Honors Compilers, NYU, Fall,

5 Save Area Linkage information: Control link: previous value of frame pointer Static link: address of stack frame of lexical parent Return address: in caller Other saved registers Compiler emits prologue code to save frame pointer, increment stack pointer, save registers. Stack[sp] := fp; save frame pointer after actuals fp := sp; new frame starts here Honors Compilers, NYU, Fall,

6 Functions with Variable Number of Parameters printf( this is %d a format %d string,x,y); Within body of printf, needs to locate as many actuals as place-holders in the format string. Solution: place parameters on stack in reverse order. Actuals at positive offset from FP, locals at negative offset from FP. actual n actual n 1 actual 1 (format string) return address Honors Compilers, NYU, Fall,

7 Objects of Dynamic Size declare x : string(1..n); N global non-constant y : string(1..n); begin... where is the start of y in the activation record? Solution 1: use indirection: activation record holds pointers. Simpler accessing, costly dynamic allocation, deallocation Solution 2: local indirection: activation record holds offset into stack. Faster allocation/deallocation, costly accessing Honors Compilers, NYU, Fall,

8 Run-Time Access to Globals procedure outer is recursive global: integer; procedure inner is recursive local: integer; begin if global=local then how do we locate global? Need run-time structure to locate activation record of statically enclosing scopes. Environment includes current activation record AND activation record of parent scopes. Honors Compilers, NYU, Fall,

9 Global Linkage Static chain: pointer to activation record of statically enclosing scope. Display: array of pointers to activation records for all enclosing scopes. Neither works for function values (higher-order functions) functional languages allocate activation records on the heaps. May not work for pointers to functions simpler if there is nesting (C, C++, Java) can check static legality in many cases (Ada) Honors Compilers, NYU, Fall,

10 Static Links Activation record holds pointer to most recent activation record of enclosing scope. Setup as part of the call prologue. To enclosing scope To retrieve entity 3 frames out, perform 3 dereferencing operations (plus appropriate offset). outer outer outer inner inner inner inner Honors Compilers, NYU, Fall,

11 Display Global array of pointers to most recent activation record at each nesting level. outermost To retrieve entity 3 frames out, one indexing operation. display outer outer outer inner inner inner inner Honors Compilers, NYU, Fall,

12 Subprogram Parameters type proc is access procedure(x: integer) procedure Perform(Helper: proc) is begin... Helper(42); end; procedure Action(X: integer) is... procedure Proxy is begin Perform(Action Access); end; Proxy can see (and call) Action, therefore environment of Action (e.g. static link) is known to Proxy. Proxy transmits to Perform both a pointer to the code of Action, and the proper static link for it. Access creates pair (ptr to Action, environment of Action) Simplest implementation if Env is pointer (static link) but can also be display: more efficient to retrieve non-local entities, less efficient for subprogram parameters, because display is array of variable size. Honors Compilers, NYU, Fall,

13 Capturing Previous Environments procedure example(p: procedure); var x: integer; procedure pri; begin print x end; begin x := global; global := global+1; if x=0 then example(pri); p;... end The first value printed is 0 even though the current value of x is 1. Honors Compilers, NYU, Fall,

14 Functions as First-class Values Force Heap Allocation of Activation Records The environment of definition of the function must be preserved until the point of call: activation record cannot be reclaimed if it creates functions. Functional languages require more complex run-time management. Higher-order functions: functions that return (build) functions, are powerful but complex mechanisms. Imperative languages restrict their use. A function that returns a pointer to a function is a higher-order function. Honors Compilers, NYU, Fall,

15 Higher-Order Functions Both arguments and result can be (pointer to) subprograms: type Func is access function(x: integer) return integer; function compose(first, second: Func) return Func is begin function result(x: integer) return integer is begin return (second(first(x))); implicit dereference end; in C++ as well return result access but first and second won t end; exist at the point of call, so illegal in Ada Honors Compilers, NYU, Fall,

16 Restricting Higher-Order Functions C: no nested definitions, so environment is always global. C++: ditto, except for nested classes. Ada: static checks to reject possible dangling references Modula: pointers to function illegal if function not declared at top-level. Lisp: special syntax to indicate capture of environment. ML, Haskell: no restriction: compose is primitive. Honors Compilers, NYU, Fall,

17 Returning Composite Values Historical: (Algol68) two stacks. More efficient: local allocate/free on a special stack. non-static sizes: function conc3(x,y,z: string) return string is begin return x &. & y &. & z; end; Example: string := conc3(this, that, theother); best not to use heap, but still need indirection. Simplest: forbid it (Pascal, C) or use heap automatically (Java) Intermediate problem: functions that return values of Honors Compilers, NYU, Fall,

18 Storage Management Data local to functions: stack Global data: static areas Class information, static members Packages Fortran common blocks Linker establishes array of pointers to static areas (TOC) Dynamic data: heap Honors Compilers, NYU, Fall,

19 Garbage Collection Run-time system manages heap, maintains free list Allocation by first-fit or best-fit (variants with buddy system,etc.). Garbage collector must be able to distinguish data that is live from unreachable data. Garbage collector attaches unreachable data (garbage) to free list. Garbage collector may compact data in use, to improve program locality. Honors Compilers, NYU, Fall,

20 Marking Live Data Data is live if it can be referenced from any active function. Garbage collector must have run-time information on data layout: Pointer data in activation records Pointer data in data structures Making it a graph traversal starting from roots: pointers in the stack. User cannot have control over pointer manipulation: Languages with garbage collectors do not have explicit pointers. Honors Compilers, NYU, Fall,

21 Sweeping and Compacting Garbage Linear pass over the heap: all unmarked data is unreachable, and can be chained into the free list For compaction, rewrite live data contiguously, so that free space is also contiguous Additional pass to adjust pointers: need to compute destination address of each block, and modify all pointers into that block. Needs inverse graph: each block has a chain of references that point to it. After pointers are adjusted, each block is copied to its destination. Honors Compilers, NYU, Fall,