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 copied C 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 PARAM begin PARAM := 3; INDEX := INDEX + 1; PARAM := 5; end UPDATE(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 pointer If 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)

Parameter Passing (In Out Mode) Same effect can be had in pass-by- value by passing a pointer

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 Record Code to create activation record inst Program code Code to delete activation record inst const 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 environment fairly straightforward with static chain method determine 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