Lecture 11: Subprograms & their implementation. Subprograms. Parameters

Transcription

1 Lecture 11: Subprograms & their implementation Subprograms Parameter passing Activation records The run-time stack Implementation of static and dynamic scope rules Subprograms A subprogram is a piece of code which can be called by name (a process abstraction). Single entry point, control returned to caller Several (nested) subprograms may be active, but only one executing procedures = a command abstraction, called for an effect functions = expression abstractions, returns a value A header defines name, formal parameters, type of result (signature, interface) Parameters Parameterization of subprograms is accomplished by the interplay between formal and actual parameters Formal parameters are local variables used to transfer data between the subprogram and its environment Actual parameters are the expressions / values bound to formal parameters when the subprogram is called Binding between a.p and f.p; usually position, sometimes name 1

2 Design questions for subprograms Parameter passing method(s)? Type checks formal <=> actual parameters? Is nesting of subprograms allowed? Can subprograms be passed as parameters? Which reference environment will be used? Overloaded subprograms? Generic (polymorphic) subprograms? Functions: Side effects allowed? Allowed types for return values? Parameter passing models A parameter passing model describes the mode of communication between actual parameters and formal parameters. The direction of the data transmission can vary in-mode formal parameter receives data from actual out-mode actual parameter receives data from formal in-out-mode both The main methods of data transfer are Transmission of a value data is copied An access path is transmitted a reference is copied Example program program main var x; procedure P(a,b); a:=a+b; b:=b+x; write(a,b,x) end; x:=5; P(x,x); write(x) end 2

3 Parameter passing methods Pass-by-value The value of a.p. is used to initialize the corresponding f.p. ( in-mode) Normally implemented by copying the value Pass-by-result a.p. (which must be a variable) is updated with the value of f.p. ( out-mode) Normally implemented by copying Problems:» Parameter collision e.g. sub(x,x)» When is the address of the a.p. computed? (e.g. in sub(a[i]) if i is changed in sub)?» What happens if a.p is an expression? Parameter passing methods (cont.) Pass-by-value-result combination of both previous methods ( in-out-mode) Pass-by-reference The formal parameter becomes an alias for the a.p, which must be a variable ( in-out-mode) problems» aliases decreases readability and reliability. The effect of a subprogram cannot be understood without studying the context of the call.» Two types of aliases: per definition (if the parameter is a non-local variable) and by parameter collision Parameter passing methods (cont.) Pass-by-name The a.p is textually substituted for the f.p. ( strange in-out-mode) problems: ineffective, hard to implement, confusing ( not appropriate for general programming languages) in the absence of side effects lazy evaluation, but then usually evaluated only once (call-by-need) 3

4 Other questions Function results - similar to a parameter in out-mode Subprograms as parameters Central in functional languages, allowed in some other lang. Common (in statically scoped languages): The reference environment is passed with the subprogram (deep binding) Overloaded subprograms Several SP with same name in the same reference env. Distinguished by different signature Flexible, but may decrease readability Coroutines Symmetric relation between subprograms Quasi-concurrency Other questions (2) Generic / polymorphic subprograms Can have param:s of different type on different activations Overloading = ad-hoc polymorphism Parametric polymorphism = a type as parameter In OO-lang. still another variant (dynamic binding) Exists e.g in Ada, C++, ML Ex (ML): fun generic_sort precedes itemlist = let fun sort nil = nil sort [x] = [x] sort (x::y::xs) = if precedes (x,y) then... in sort itemlist end; val ascending_int_sort = generic_sort ((op <):(int*int->bool)) Implementing subprograms When a subprogram call occurs: Save the status of the caller Transmit parameter values Save return address Transfer control to the callee When returning Return result (if a function) Restore the status of the caller Transfer control back To do this activation records on the run-time stack is used 4

5 Activation records =subprogram Data needed to handle calls of an SP is stored in activation record [instances] Data usually found in activation records is e.g. Storage for local variables and parameters static and/or dynamic links to other ARI:s Return address (where will execution continue when SP is finished?) Offset for a local variable can be computed at compilation! The run-time stack The run-time stack is used to store activation records which represent the nested calls of active SP:s. When a SP is called a corresponding activation record is placed on the stack. When execution is finished the activation record is removed. The dynamic link points at previous ARI (which belongs to the calling SP) The static link points at the closest ARI of the static parent. Call and return ARI sub n+1 local variables parameters static link dynamic link return address ARI sub n ARI sub 1 ARI main ARI sub n ARI sub 1 ARI main ARI sub n ARI sub 1 ARI main sub n calls sub n+1 sub n+1 terminates 5

6 Recursion Example int factorial(int n) { < if (n <= 1) return 1; else return (n * factorial(n - 1)); < } void main() { int value; value = factorial(3); < } Dynamic links The dynamic link shows where the (previous) activation record instance of the dynamic parent is. It is needed e.g to remove the topmost ARI att return (since its size can vary) The dynamic chain (call chain) consists of all dynamic links, and represents the sequence of calls. Implementing dynamic scope How do you find a non-local variable when the language uses dynamic scope rules? Deep access Follow the call chain until one finds an ARI containing a variable with the right name Easy to implement, fast calls but slow variable access Shallow access (two variants) a) Create a separate stack for each identifier (no variables on the run-time stack) b) Create a separate table for the variables (values for nonlocal variables that becomes hidden at a call can be stored in the ARI of the SP!) constant access time but less effective calls 6

7 Shallow access - implementation Static link The static link points att the ARI that belongs to the (last activation of) the static parent Static link are needed to implement static scope rules Two possibilities: Use the static chain the same way the dynamic chain is used with dynamic scoping. Most common! Save the current static links in a separate table (display); non-accessible links are temporarily saved in the ARI:s Implementation of static scoping The most important concept is the static depth sd(id) of an identifier id sd(id)=0 if id is the main program sd(id)=sd(sub)+1 if id is declared in SP sub The nesting depth of an identifier is the difference between sd of the unit where it is used and the unit where it was declared. Together with the offset it gives a complete address to the value of the identifier in the stack. ((o,d) => Follow the chain d steps, then offset o). Fast access if short chain. 7

8 Example program P; sd(p)=0 bool a,b; procedure A; sd(a)=1 bool a; nesting depth = sd(a) sd(a) = 0 a = true; nesting depth = sd(a) sd(p) = 1 if a b then B end A; procedure B; sd(b)=1 if a then A end B; a = b = false; A end P. Example Pascal Program program MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB1; var A, D : integer; { SUB1 } A := B + C; < end; { SUB1 } procedure SUB2(X : integer); var B, E : integer; procedure SUB3; var C, E : integer; { SUB3 } SUB1; E := B + A: < end; { SUB3 } { SUB2 } SUB3; A := D + E; < end; { SUB2 } { BIGSUB } SUB2(7); end; { BIGSUB } BIGSUB; end. { MAIN_2 } Example program In position 1 in SUB1: A - (0, 3) B - (1, 4) C - (1, 5) In position 2 in SUB3: E - (0, 4) B - (1, 4) A - (2, 3) In position 3 in SUB2: A - (1, 3) D - an error E - (0, 5) 8

9 Maintaining the static chain When a new ARI is created, how do we know where the static link should point? Suppose that sub is declared in sub decl and called in sub cl. By starting at the top ARI (of sub cl ) and following the static chain sd(sub cl ) sd(sub decl ) ("nesting depth") steps we find the ARI that the new static link should point at. Ex: sub3 (sd=3) calls sub1which is declared in bigsub(sd=1) 9