Scribd
Upload
508 views

Subprogram Sequence Control Attributes of Data Control Parameter Passing Explicit Common Environments

The document discusses subprogram control and how subprograms interact by passing data. It covers subprogram sequence control using simple call-return models and stack-based implementations to allow for recursion. It also covers attributes of data control, including local and non-local referencing environments, parameter passing, and static and dynamic scoping rules for associating names and data.

Uploaded by

Sawan Karn
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
508 views

Subprogram Sequence Control Attributes of Data Control Parameter Passing Explicit Common Environments

The document discusses subprogram control and how subprograms interact by passing data. It covers subprogram sequence control using simple call-return models and stack-based implementations to allow for recursion. It also covers attributes of data control, including local and non-local referencing environments, parameter passing, and static and dynamic scoping rules for associating names and data.

Uploaded by

Sawan Karn
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 32

Chapter 9: Subprogram Control

Subprogram Control :
interaction among subprograms
how subprograms pass data among themselves

• Subprogram Sequence Control


• Attributes of Data Control
• Parameter passing
• Explicit Common Environments
Subprogram Sequence Control

Simple subprogram call return


Copy rule view of subprograms:

the effect of a call statement is the


same as if the subprogram were
copied and inserted into the main
program.
Assumptions
 Subprograms cannot be recursive
 Explicit call statements are required
 Subprograms must execute completely at
each call
 Immediate transfer of control at point of call
 Single execution sequence
Simple flow of execution

CALL

RETURN
Simple call-return subprograms

Execution of subprograms

Subprogram definition.

Subprogram activation.
Subprogram definition

The definition is translated into a template,

used to create an activation each time a


subprogram is called.
Subprogram activation
a code segment (the invariant part) -
executable code and constants,

an activation record (the dynamic part) -


local data, parameters.

created anew each time


the subprogram is called,

destroyed when the subprogram returns.


System-defined pointers

 Current-instruction pointer – CIP


address of the next statement to be
executed

 Current-environment pointer – CEP


pointer to the activation record.
On call instruction
• An activation record is created
• Current CIP and CEP are saved in the created
activation record as return point
• CEP is assigned the address of the activation record.
• CIP gets the address of the first instruction in the code
segment
• The execution continues from the address in CIP
On return

• The old values of CIP and CEP are retrieved.

• The execution continues from the address in CIP

Restrictions of the model:


at most one activation of any subprogram
The simplest implementation

Allocate storage for a single activation record


statically as an extension of the code segment.
Used in FORTRAN and COBOL.

The activation record is not destroyed - only


reinitialized for each subprogram execution.

Hardware support - CIP is the program counter,


CEP is not used, simple jump executed on return.
Stack-based implementation
The simplest run-time storage management technique

call statements : push CIP and CEP


return statements : pop CIP and CEP off of the stack.

Used in most C implementations


LISP: uses the stack as an environment.
Recursive Subprograms
Specification
Syntactically - no difference
Semantically - multiple activations of the
same subprogram exist simultaneously at
some point in the execution.

E.G. the first recursive call creates a second


activation within the lifetime of the first
activation.
Implementation
Stack-based -

CIP and CEP are stored in stack, forming


a dynamic chain of links.

A new activation record is created for


each call and destroyed on return.

The lifetimes of the activation records


cannot overlap - they are nested.
Attributes of Data Control
Data control features determine the
accessibility of data at different points during
program execution.

Central problem:
the meaning of variable names, i.e. the
correspondence between names and memory
locations.
Names and Referencing
Environments

Two ways to make a data object available as an


operand for an operation

Direct transmission
Referencing through a named data object
Direct transmission
A data object computed at one point as the
result of an operation may be directly
transmitted to another operation as an operand

Example: x = y + 2*z;

The result of multiplication is transmitted


directly as an operand of the addition operation
Referencing through
a named data object

A data object may be given a name


when it is created,

the name may then be used to designate it


as an operand of an operation.
Program elements that may be
named
To be discussed next
Variables
Formal parameters
Subprograms

resolved at translation time:


Defined types
Defined constants
Labels
Exception names
Primitive operations
Literal constants
Associations and Referencing
Environments

Association: binding identifiers to particular data


objects and subprograms

Referencing environment: the set of identifier


associations for a given subprogram.

Referencing operations during program


execution: determine the particular data object or
subprogram associated with an identifier
Local referencing environment

The set of associations created on entry


to a subprogram
formal parameters,
local variables, and
subprograms defined only within
that subprogram
Non-local referencing environment
The set of associations for identifiers
• used within a subprogram
• not created on entry to it

Global referencing environment:


associations created at the start of execution of the
main program, available to be used in a subprogram

Predefined referencing environments:


predefined associations in the language definition
Associations
Visibility of associations

Associations are visible if they are


part of the referencing environment.
Otherwise associations are hidden

Dynamic Scope of associations

The set of subprogram activations within


which the association is visible
Aliases for Data Objects

Multiple names of a data object


- separate environments - no problem
- in a single referencing environment - called
aliases.

Problems with aliasing


• Can make code difficult to understand
• Implementation difficulties at the optimization
step - difficult to spot interdependent statements -
not to reorder them
Example of aliasing
Program main;
var I: integer;
procedure Sub1 ( var J: integer);
begin
……… (* I and J refer to same data
object *)
end;
begin
…. Sub1(I);
….
end.
Static and Dynamic Scope
The dynamic scope of an association for an
identifier:

• the set of subprogram activations in which the


association is visible during execution.
• tied to the dynamic chain of subprogram
activations.

The static scope of a declaration

the part of the program text where the


declared identifier is used.
Dynamic scope rules
Static scope rules

Dynamic scope rules :


Relate references with associations for
names during program execution

Static scope rules :


relate references with declarations of
names in the program text.
Block structure

Block-structured languages :

 Each program or subprogram is organized as


a set of nested blocks.

 Each block introduces a new local


referencing environment.
Subprogram A

Declaration of X
Declaration of Y

Subprogram B Static scope


Declaration of Y rules for
Declaration of Z block-
Use of Y
structured
programs
Use of X

Use of Z Hidden to A
Local Data and Local Referencing
Environments
Local environment of a subprogram:
various identifiers declared in the subprogram :
variables, parameters, subprogram names.

Static scope rules: implemented by means of a


table of the local declarations

Dynamic scope rules:


Retention - Associations and the bound values
are retained after execution
Deletion - Associations are deleted
Implementation of dynamic scope
rules

By means of a local environment table to associate


names, types and values.

Retention: the table is kept as part of the code


segment

Deletion: the table is kept as part of the activation


record, destroyed after each execution.

You might also like