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)

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 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