Scribd
Upload
21 views24 pages

Ch09 Subroutines and Control Abstraction 4e

This document discusses subroutines and control abstraction in programming languages. It covers the stack layout for allocation of code, data, and temporary variables. Calling sequences are described, including how parameters are passed between subroutines. Exception handling and coroutines are also summarized. The document provides technical details on implementation strategies for these programming language concepts.

Uploaded by

dohoangtruonghuy
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
21 views24 pages

Ch09 Subroutines and Control Abstraction 4e

This document discusses subroutines and control abstraction in programming languages. It covers the stack layout for allocation of code, data, and temporary variables. Calling sequences are described, including how parameters are passed between subroutines. Exception handling and coroutines are also summarized. The document provides technical details on implementation strategies for these programming language concepts.

Uploaded by

dohoangtruonghuy
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 24

Chapter 9 :: Subroutines and

Control Abstraction

Programming Language Pragmatics, Fourth Edition


Michael L. Scott

Copyright © 2016 Elsevier


Contents

• Review of Stack Layout


• Calling Sequences
• LLVM on ARM
• Parameter Passing
• Exception Handling
• Coroutines (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
Review Of Stack Layout
Review Of Stack Layout

• Allocation strategies (2)


– Stack
• parameters
• local variables
• temporaries
• bookkeeping information
– Heap
• dynamic allocation
Review Of Stack Layout

• Contents of a stack frame


–bookkeeping
•return PC (dynamic link)
•saved registers
•line number
•saved display entries
•static link
–arguments and returns
–local variables
–temporaries
Calling Sequences

• Maintenance of stack is responsibility of


calling sequence and subroutine prolog and
epilog – discussed in Chapter 3
– 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
Calling Sequences

• Common strategy is to divide registers into


caller-saves and callee-saves sets
– caller uses the "callee-saves" registers first
– "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
Calling Sequences
Calling Sequences (LLVM on ARM)

• Caller
– saves into the “local variable and temporaries” area any
caller-saves registers whose values are still needed
– puts up to 4 small arguments into registers r0-r3
– puts the rest of the arguments into the argument build area
at the top of the current frame
– does b1 or b1x, which puts return address into register lr,
jumps to target address, and (optionally) changes
instruction set coding
Calling Sequences (LLVM on ARM)

• In prolog, Callee
– pushes necessary registers onto stack
– initializes frame pointer by adding small constant to the sp placing
result in r7
– subtracts from sp to make space for local variables, temporaries,
and arg build area at top of stack
• In epilog, Callee
– puts return value into r0-r3 or memory (as appropriate)
– subtracts small constant from r7, puts result in sp (effectively
deallocates most of frame)
– pops saved registers from stack, pc takes place of lr from prologue
(branches to caller as side effect)
Calling Sequences (LLVM on ARM)
• After call, Caller
– moves return value to wherever it's needed
– restores caller-saves registers lazily over time,
as their values are needed
• All arguments have space in the stack,
whether passed in registers or not
• The subroutine just begins with some of the
arguments already cached in registers, and
'stale' values in memory
Calling Sequences (LLVM on ARM)

• 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
Calling Sequences (LLVM on ARM)

• 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
Parameter Passing
• Parameter passing mechanisms have four
basic implementations
– value
– value/result (copying)
– reference (aliasing)
– closure/name
• Many languages (e.g. Ada, C++, Swift)
provide value and reference directly
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++)
int& x, int y) {x = x + y }
void proc(

proc(a,b);
Parameter Passing

• Ada goes for semantics: who can do what


– In: callee reads only
– Out: callee writes and can then read (formal not
initialized); actual modified
– In out: callee reads and writes; actual modified
• Ada in/out is always implemented as
– value/result for scalars, and either
– value/result or reference for structured objects
Parameter Passing
• In a language with a reference model of
variables (ML, Ruby), pass by reference
(sharing) is the obvious approach
• It's also 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
Parameter Passing
Exception Handling

• What is an exception?
– a hardware-detected run-time error or
unusual condition detected by software
• Examples
– arithmetic overflow
– end-of-file on input
– wrong type for input data
– user-defined conditions, not necessarily
errors
Exception Handling

• What is an exception handler?


– code executed when exception occurs
– may need a different handler for each type of
exception
• Why design in exception handling facilities?
– allow user to explicitly handle errors in a uniform
manner
– allow user to handle errors without having to
check these conditions explicitly in the program
everywhere they might occur
Coroutines

• Coroutines are execution contexts that exist


concurrently, but that execute one at a time,
and that transfer control to each other
explicitly, by name
• Coroutines can be used to implement
– iterators (Section 6.5.3)
– threads (to be discussed in Chapter 12)
• Because they are concurrent (i.e.,
simultaneously started but not completed),
coroutines cannot share a single stack
Coroutines
Contents

• Review of Stack Layout


• Calling Sequences
• LLVM on ARM
• Parameter Passing
• Exception Handling
• Coroutines (2)

You might also like