Chapter 8 :: Subroutines and

Control Abstraction

Programming Language Pragmatics

Michael L. Scott

Adapted from Scott, 2006 1

Subroutines/Methods/Functions

• Subroutines are the primary control abstraction

– c.f., data abstraction
– Subroutine performs a well defined operation
• Formal Parameters
– Specified in the subroutine signature
• Actual Parameters == Arguments
– Values passed to the subroutine
• Function is a subroutine that returns something
• Procedure is a subroutine that returns nothing

Adapted from Scott, 2006 2

 Review Of Stack Layout

• Allocation strategies -- static

• Code
• Globals
• Own variables
• Explicit constants (including strings, sets, other
aggregates)
• Small scalars may be stored in the instructions
themselves

Adapted from Scott, 2006 3

 Review Of Stack Layout

• Allocation strategies (2)

– Stack
• arguments
• local variables
• temporaries
• bookkeeping information like the return address
– Heap
• dynamic allocation

Adapted from Scott, 2006 4

 Review Of Stack Layout

frame pointer

Static links point to lexically

surrounding routine

Dynamic links point

to calling context
(saved value of the
frame pointer)

Adapted from Scott, 2006 5

 Review Of Stack Layout
• Contents of a stack frame
– bookkeeping
• return PC (dynamic link)
• saved registers
• static link
– arguments and returns
– local variables

Adapted from Scott, 2006 6

 Calling Sequences
• Maintenance of stack is responsibility of
calling sequence and subroutine prolog
and epilog
– space is saved by putting as much in the prolog
and epilog as possible
– time may be saved by putting stuff in the caller
instead, where more information may be known
• e.g., there may be fewer registers IN USE at the
point of call than are used SOMEWHERE in the
callee
• Goal is to save only those registers needed by both
caller and callee
Adapted from Scott, 2006 7
 Calling Sequences
• Common strategy is to divide registers into
caller-saves and callee-saves sets
– callee uses the "callee-saves" registers first
– callee uses "caller-saves" registers if necessary
• Local variables and arguments are assigned
fixed OFFSETS from the stack pointer or
frame pointer at compile time
– some storage layouts use a separate arguments
pointer
• the VAX architecture encouraged this
Adapted from Scott, 2006 8
 Calling Sequences

Adapted from Scott, 2006 9

 Calling Sequences (C on MIPS)
• Caller
1. saves into the temporaries and locals area any
caller-saves registers whose values will be
needed after the call
2. puts up to 4 small arguments into registers $4-$7
(a0-a3)
• it depends on the types of the parameters and the order
in which they appear in the argument list
3. puts the rest of the arguments into the arg build
area at the top of the stack frame
4. does jal, which puts return address into register
ra and branches
Adapted from Scott, 2006 10
 Calling Sequences (C on MIPS)

• In prolog, Callee
– allocates a frame by subtracting framesize from sp
– saves callee-saves registers used anywhere inside
callee
• In epilog, Callee
– puts return value into registers (memory if large)
– restores saved registers using sp as base
– adds to sp to deallocate frame
– does jra
Adapted from Scott, 2006 11
 Calling Sequences (C on MIPS)
• After call, Caller
– moves return value from register to wherever
it's needed (if appropriate)
– restores caller-saves registers lazily over time,
as their values are needed

Adapted from Scott, 2006 12

 Calling Sequences (C on MIPS)

• This is a normal state of affairs; optimizing

compilers keep things in registers whenever
possible, flushing to memory only when
they run out of registers, or when code may
attempt to access the data through a pointer
or from an inner scope

Adapted from Scott, 2006 13

 Calling Sequences (C on MIPS)
• Many parts of the calling sequence,
prologue, and/or epilogue can be omitted in
common cases
– particularly LEAF routines (those that don't call
other routines)
• leaving things out saves time
• simple leaf routines don't use the stack - don't even
use memory – and are exceptionally fast

Adapted from Scott, 2006 14

 Parameter Passing
• Parameter passing mechanisms
– value (copying in)
– reference (aliasing)
– value/result (copying in and copying out)
– closure/name (reference to subroutine &
context)
• Many languages (e.g., Pascal) provide value
and reference directly

Adapted from Scott, 2006 15

 Parameter Passing
• C/C++: functions
– parameters passed by value (C)
– parameters passed by reference can be simulated
with pointers (C)
void proc( int* x,int y ){*x = *x+y }
…
proc( &a, b );
– or directly passed by reference (C++)
void proc( int& x,int y ){x = x + y }
…
proc( a, b );

Adapted from Scott, 2006 16

 Parameter Passing
• Ada and PL/SQL go for semantics: who can do what
– In: callee reads only
– call by value
– Out: callee writes and can then read
– formal not initialized)
– actual modified
– call by result
– In out: callee reads and writes
– actual modified
– call by value/result
• Ada in/out is always implemented as
– value/result for scalars, and either
– value/result or reference for structured objects

Adapted from Scott, 2006 17

 Parameter Passing
• In a language with a reference model of variables
(Lisp, Smalltalk), pass by reference (sharing) is the
obvious approach
• Pass by reference is the only option in Fortran
• If you pass a constant, the compiler creates a temporary
location to hold it
• If you modify the temporary, who cares?
• Call-by-name is an old Algol technique
• Think of it as call by textual substitution (procedure with
all name parameters works like macro) - what you pass are
hidden procedures called THUNKS
Adapted from Scott, 2006 18
 Parameter Passing

Adapted from Scott, 2006 19