Post on 18-Dec-2015
(1)
ICS 313:Programming Language
TheoryChapter 10:
Implementing Subprograms
(2)
Objectives To understand the guts of subprogram calls•basic procedure of subprogram linkage
•activation records•static and dynamic chaining•deep and shallow access
(3)
General issues When calling: •Save state of calling procedure •Determine parameter-passing mechanism for each parameter and arrange access appropriately
•Allocate storage for local variables•Initialize local variable values•Arrange transfer of control to procedure
•Arrange return of control to calling procedure
•Arrange access to visible non-local variables
(4)
General issues (cont.) When Returning:•Move final parameter values back to calling arguments (when pass by result)
•Deallocate storage used for local variables
•Undo access to visible non-local variables
•Return control to calling procedure
(5)
Activation Records Programs consist of Code, Data, and book-keeping
Noncode part is organized in an Activation Record
Activation record instances can include•Parameter definitions•Local variables•Functional value•Return address•Other data to be discussed
(6)
Fortran 77 A simple situation: •Actual code is fixed at compile time•Local variables/data are also of fixed size
•Subprograms cannot be recursive A simple solution: •Local variables statically allocated (static activation records)
•All referencing of non-local variables is through COMMON: a globally accessible static memory space
(7)
Fortran 77 Procedure call:•Save the execution status of current procedure
•Carry out parameter-passing•Pass return address to callee•Transfer control to callee
(8)
Fortran 77 (cont.) Procedure return:•If using pass-by-value-result, final values of parameters are moved to arguments
•If subprogram is a function, final value is moved back
•Execution status of the caller is restored
•Control is transferred back to caller
(9)
Fortran77 Activation Records
No more than one can exist for a procedure
AR Instances can be statically allocated Either separate or interleave code and data
Code
Return address
Local variables
Code
Main
Procedure A
Parameters
Local variables
Common
(10)
Algol-like Languages New complexities over Fortran 77•Parameters can be passed in different ways (value or reference)
•Subprogram variables may be dynamically allocated
•Recursion legal: multiple activation records may exist simultaneously
•Scope rules (usually static) determine visibility of non-local variables
(11)
Algol-like Languages Activation records•Format and size is known at compile time since all local variables and their size is statically fixed
•Instances of activation records are dynamically generated at run-time
(12)
Contents of Activation Records
Return address•Pointer to code segment of caller and offset address of instruction
Static link:•A pointer to the activation record of static parent
•Used to support non-local variable access Dynamic link:
•A pointer to activation record of caller•Used in static scoped languages to support procedure return (indicates how much of stack to remove)
•Used in dynamic scoped languages for non-local variable access
(13)
Activation Records (continued)
Parameters:• Either values or addresses provided by caller
Local variables:•Scalars stored directly within activation record
•Non-scalars (structures) stored elsewhere•References to locals can be via offset from beginning of record: known at compile time
Functional Value (if a function)•Place to put the returned value of the function
•(In some languages the function name can be treated like a local variable)
(14)
procedure sub (var tot: real); var sum : real; begin : end;
A new activation record is created each time sub is called
Run-time Stack holds activation records •Stack discipline is appropriate for conventional procedures
•But not for co-routines
Activation Record Example
Return Address
Local
Parameter
Dynamic Link
Static Link
sumtot
Start of record
Offset of sum}
(15)
Factorial Example
Return (main)
Functional: ? Parameter n=3 Dynamic Link
Static Link
Local value = ?
Return (main)
Functional: ? Parameter n=3 Dynamic Link
Static Link
Local value = ?
Return (fact)
Functional: ? Parameter n=2 Dynamic Link
Static Link
Return (fact)
Functional: ? Parameter n=1 Dynamic Link
Static Link
Return (main)
Functional: ? Parameter n=3 Dynamic Link
Static Link
Local value = ?
Return (fact)
Functional: ? Parameter n=2 Dynamic Link
Static Link
(16)
Factorial Example
Return (main)
Functional: 6 Parameter n=3 Dynamic Link
Static Link
Local value = ?Return (main)
Functional: ? Parameter n=3 Dynamic Link
Static Link
Local value = ?
Return (fact)
Functional: 2 Parameter n=2 Dynamic Link
Static Link
Return (fact)
Functional: 1 Parameter n=1 Dynamic Link
Static Link
Return (main)
Functional: ? Parameter n=3 Dynamic Link
Static Link
Local value = ?
Return (fact)
Functional: ? Parameter n=2 Dynamic Link
Static Link
(17)
Non-local references Reference to a non-local variable requires a two step process:•Find the activation record instance where the variable was allocated
•Use local offset to access the variable within the record
Finding the ARI (under static scoping) is not straightforward
(18)
Non-local references program Prog; int i=0; procedure A; int i=1; B(); end; procedure B; int i=2; C(); end; procedure C; i=3; end; A(); end;
Show the set of activation records in existence when the statement ‘i=3’ is encountered.
Which declaration of ‘i’ will be updated?
Following the dynamic chain will find the wrong ‘i’!
(19)
Static Chains A link from each procedure’s activation record to its parent’s activation record with respect to static scope
The static chain is different from the dynamic chain:•The static parent of C is Prog.•The dynamic parent of C is B.
(20)
Static Chains (continued) No need to search for variable: number of static links is known at compile time (why?) •Static Depth: nesting level of scope•Chain Offset (Nesting Depth): difference between static depth of reference environment and static depth of declaration environment
•References represented as (chain_offset, local_offset)
•Locals can be handled with chain_offset=0
(21)
Maintaining Static Chains At subprogram call: •Correct parent known at compile time•Must find most recent activation record of parent
•Avoid search of dynamic chain by using existing static chain to find parent (treat procedure reference like variable
At return: just remove record from stack
(22)
Cost of Static Chains Static chains allow references to non-local variables to be resolved, but at a cost:•References to non-local variables “above” parent are slow
•Time to resolve a reference is difficult to predict, and sensitive to source code changes
(23)
Displays: an alternativeStatic links are in a separate array
•One element per static depth•Exactly two steps per reference: (display_offset, local_offset)
•When a subprogram at a given static depth is called, save and replace the link at that depth
Efficiency compared to Static Chains:•Deeply nested references more efficient•Maintenance of subprogram calls less efficient
Yet most programs are not deeply nested (three in practice)
(24)
Display Example
Static Depth 0
Display
Static Depth 3 Static Depth 2 Static Depth 1
Sub1
Sub2
MAIN
Static Depth 0
Display
Static Depth 3 Static Depth 2 Static Depth 1
Sub1
Sub5
Sub4
Sub3
Sub2
MAIN
(25)
Dynamic Scoping Deep Access (NOT same as deep binding): •References to non-local variables are be resolved by following dynamic links
•Easy to implement •Search down call chain may be slow•Activation records must store variable names
Shallow Access:•Maintain for each variable a stack of its bindings, and reference the top-most one
(26)
Implementing Subprogram Parameters
Passing Subprograms with Static Chaining •Defining parent must be on stack•Pass link to static parent and use this to initialize activation record
With Displays•May need to access multiple static ancestors
•Some implementations copy and pass the entire display for use by subprogram
Correct referencing environment may not be apparent: see example