chapter 9 subprograms specification: name, signature, actions signature: number and types of input...
Post on 16-Dec-2015
219 Views
Preview:
TRANSCRIPT
Chapter 9 Subprograms
• Specification: name, signature, actions
• Signature: number and types of input arguments, number and types of output results–Book calls it protocol
Subprograms
• Actions: direct function relating input values to output values; side effects on global state and subprogram internal state
• May depend on implicit arguments in form of non-local variables
Subprogram As Abstraction
• Subprograms encapsulate local variables, specifics of algorithm applied–Once compiled, programmer cannot
access these details in other programs
Subprogram As Abstraction
• Application of subprogram does not require user to know details of input data layout (just its type)–Form of information hiding
Subprogram Parameters
• Formal parameters: names (and types) of arguments to the subprogram used in defining the subprogram body
• Are types checked?• Is number of arguments fixed?• Actual parameters: arguments
supplied for formal parameters when subprogram is called
Establishing the correspondence
• positional - good for small lists • Keyword parameters
Example: (Ada) SUB(Y=>ACT_Y, MAX=>100)Disadvantage is that the caller must know names is callee
• May be default values (Ada, C++) if no parameter is supplied
Subprogram Parameters
• Parameters may be used to:– Deliver a value to subprogram – in
mode– Return a result from subprogram – out
mode– Both – in out mode
• Most languages use only in mode• Ada uses all
Parameter Passing
• Aliases may be created
• a formal parameter is a nonlocal variable
• the same data object passed for two parameters CALL S(X,X)
• With aliasing, interesting problems in optimizations occur.
Parameter Passing (In Mode)
• Pass-by-value: Subprogram makes local copy of value (r-value) given to input parameter
• Assignments to parameter not visible outside program
• Most common in current popular languages
• If pass array by value, entire array does not get copiedC is not consistent here
• transmission by constant value - as in C++(make it by reference for speed, but don’t allow changes)
• no assignment to param is allowed OR is allowed, but only changes local copy
• For protection, then the formal parameter may not be transmitted to another subprogram except as a constant value parameter
• May be implemented as transmission by value or reference
• costly to pass by value if parameter is large - storage and time
Parameter Passing (In Mode)
• Pass-by-name: text for argument is passed to subprogram and expanded in each place parameter is used– Roughly same as using macros – Note, you can’t evaluate late without
having “code” to execute– You also need to know a context for
evaluating non-local variables• Achieves late binding
Pass-by-name Example
integer INDEX= 1;integer array ARRAY[1:2]procedure UPDATE (PARAM);
integer PARAMbegin
PARAM := 3; INDEX := INDEX + 1; PARAM := 5;
endUPDATE(ARRAY[INDEX]);
Pass-by-name Example
• Previous code puts 3 in ARRAY[1] and 5 in ARRAY[2]
• How is this accomplished if the compiled code must work for ANY argument that is passed?
• PARAM can be x, x+y, 2*t[6*x]+7• How can you generate code for
UPDATE when you don’t know what is passed?
• New interest in functional languages means more interest in delayed evaluation.
• Very flexible, but inefficient. Difficult to implement. Confusing to read/write.
• Some simple operations are not possible with pass by name. • Lazy evaluation is another form of late binding. Only evaluate when
it becomes necessary. • Substitute name or expression (in calling environment) for formal
parameter• The name location binding is delayed until (and established fresh
each time) the formal parameter is encountered. • Implemented by passing parameter-less subprograms (thunks)
rather than variable name. An expression needs to be evaluated IN the proper environment. Don't have mechanism to do that other than thru procedure call.
• Whenever formal parameter is referenced, a call is made to thunk, which evaluates the parameter in the proper (caller) environment and returns proper resulting value (or location)
• Example: procedure R(var i,j: integer); begin var m:boolean; m := true; i := i + 1; j := j + 1; write(i,j); end; m := 2; for(i=0;i<10;i++) c[i]=10*i; R(m,c[m]); • pass by reference: adds 1 to m and c[2]
Pass by name: adds 1 to m and c[3]
Example for Call by Name
b1: begin real x,y; y := 0.0;
procedure G(t): name t; begin integer w; integer x; w := 10; y := 20; x := 50 print t x:= 0; print t end G;
b2: begin real y; y := 0.5; x := 1.0; call G(y-x) end
end thunk() return(y-x) end;
• If name parameter is on left hand side, thunk would have to return the address of the element (rather than the value).
• Not a problem for in–only parameters
IN OUT parameters
• transmission by reference formal parameter is local object of type pointerIf expression is passed as an in/out parameter: a temporary location may be passed(and then the copy is changed, not the original)
• Disadvantages: – access slower as is indirect (always follow a pointer to
access), but passing is fast (only copy a pointer, not a whole structure)
– may make inadvertent changes to parameters (if out only was desired)
IN OUT parameters
– Value-restore. Copy value in on call Copy changed value back on return.
– Used to save cost of indirect access.– aliases may be problematic - especially likely
if pass same parameter twice. Then if arguments are changed, original values may be changed differently depending on order of change (if value-restore)
Value-restore• value copied at time of call and copied back at
time of return has the same as call by reference if – the subprogram terminates normally, and – the called subprogram cannot also access the actual
parameter through an alias– parameters are names for same argument doit(X,X).
• Need to know order arguments are copied back. • Need to know whether address is computed
again before copying back. XX(i,a[i])
OUT only parameters
• formal parameter is a local variable with no initial value
• copied back at termination of subprogram Pass by result
• Explicit function Values: may be considered an extra OUT parameter
• return(expr) • value to be returned by assignment to function
name • if return is an address (e.g., list[index]), when is
it evaluated? time of call? time of return?
Subprogram Implementation
• Subprogram definition gives template for its execution–May be executed many times with
different arguments
Subprogram Implementation
• Template holds code to create storage for program data, code to execute program statements, code to delete program storage when through, and storage for program constants
• Layout of all but code for program statements called activation record
Actions to pass parameters:
• Point of call: parameters evaluated and list of parms is set up
• Perform type checking and promotion (if needed)
• point of entry: prologue of called routine completes association by copying pointers into locations or copying entire contents
• point of exit: epilogue of called routine must copy result values into actual parameters transmitted by result or value-result
Subprogram Implementation
• Code segment Activation RecordCode to create activation record instProgram codeCode to delete activation record instconst 1
const n
Return point
Static link
Dynamic link
Result data
Input parameters
Local parameters
Activation Records
• Code segment generated once at compile time
• Activation record instances created at run time
• Fresh activation record instance created for each call of subprogram– Usually put in a stack (runtime stack)– “return point” inserted first
Activation Records
• Static link – pointer to bottom of activation record instance of static parent– Used to find non-local variables
• Dynamic link – pointer to end of activation record instance of the caller– Used to delete subprogram activation
record instance from runtime stack at completion (by resetting stack pointer)
Subprograms as parameters:
• Corresponding formal parameter is of type subprogram name • Problems • static type checking: cannot determine if number of arguments is correct
Needs not just name, but full procedure specification: type returned, number order and type of args.
• nonlocal references (free variables) – variables without bindings assume same nonlocal environment as if inline
expansion were used usually not what was intended – nonlocal reference means the same thing during execution of the subprogram
passed as a parameter as it would if the subprogram were invoked at the point where it appears as an actual parameter in the parameter list
• Need to create the correct nonlocal environmentfairly straightforward with static chain methoddetermine correct static chain pointer for the subprogram parameter and pass that along as part of the information transmitted with a subprogram parameter
• As in passing labels as parameters, need an (ip, ep) (instruction pointer, environment pointer) pair
Are three choices of environment for evaluating unbound variables of function
passed as parameter
1. the environment of the subprogram to which it is passed (shallow binding) Not appropriate for block structures languages because of static binding of variables
2. the environment of the subprogram which is passed (deep binding)
3. the environment of the subprogram which passes the subprogram (ad hoc) not used
top related