COMPILER DESIGN - RUN-TIME ENVIRONMENT

http://www.tutorialspoint.com/compiler_design/compiler_design_runtime_environment.htm
Copyright © tutorialspoint.com

A program as a source code is merely a collection of text code, statementsetc. and to make it alive, it
requires actions to be performed on the target machine. A program needs memory resources to
execute instructions. A program contains names for procedures, identifiers etc., that require
mapping with the actual memory location at runtime.

By runtime, we mean a program in execution. Runtime environment is a state of the target

Runtime support system is a package, mostly generated with the executable program itself and
facilitates the process communication between the process and the runtime environment. It takes
care of memory allocation and de-allocation while the program is being executed.

Activation Trees
A program is a sequence of instructions combined into a number of procedures. Instructions in a
procedure are executed sequentially. A procedure has a start and an end delimiter and everything
inside it is called the body of the procedure. The procedure identifier and the sequence of finite
instructions inside it make up the body of the procedure.

The execution of a procedure is called its activation. An activation record contains all the
necessary information required to call a procedure. An activation record may contain the following
units dependinguponthesourcelanguageused.

Temporaries Stores temporary and intermediate values of an expression.

Local Data Stores local data of the called procedure.

Machine Status Stores machine status such as Registers, Program Counter etc., before
the procedure is called.

Control Link Stores the address of activation record of the caller procedure.

Access Link Stores the information of data which is outside the local scope.

Actual Parameters Stores actual parameters, i.e., parameters which are used to send input
to the called procedure.

Return Value Stores return values.

Whenever a procedure is executed, its activation record is stored on the stack, also known as
control stack. When a procedure calls another procedure, the execution of the caller is suspended
until the called procedure finishes execution. At this time, the activation record of the called
procedure is stored on the stack.

We assume that the program control flows in a sequential manner and when a procedure is called,
its control is transferred to the called procedure. When a called procedure is executed, it returns
the control back to the caller. This type of control flow makes it easier to represent a series of
activations in the form of a tree, known as the activation tree.

To understand this concept, we take a piece of code as an example:

. . .
printf(“Enter Your Name: “);
scanf(“%s”, username);
show_data(username);
printf(“Press any key to continue…”);
. . .
int show_data(char *user)
{
printf(“Your name is %s”, username);
return 0;
}
. . .

Below is the activation tree of the code given.

Now we understand that procedures are executed in depth-first manner, thus stack allocation is
the best suitable form of storage for procedure activations.

Storage Allocation
Runtime environment manages runtime memory requirements for the following entities:

Code : It is known as the text part of a program that does not change at runtime. Its memory
requirements are known at the compile time.

Procedures : Their text part is static but they are called in a random manner. That is why,
stack storage is used to manage procedure calls and activations.

Variables : Variables are known at the runtime only, unless they are global or constant.
Heap memory allocation scheme is used for managing allocation and de-allocation of
memory for variables in runtime.

Static Allocation
In this allocation scheme, the compilation data is bound to a fixed location in the memory and it
does not change when the program executes. As the memory requirement and storage locations
are known in advance, runtime support package for memory allocation and de-allocation is not
required.

Stack Allocation
Procedure calls and their activations are managed by means of stack memory allocation. It works
in last-in-first-out LIFO method and this allocation strategy is very useful for recursive procedure
calls.
Heap Allocation
Variables local to a procedure are allocated and de-allocated only at runtime. Heap allocation is
used to dynamically allocate memory to the variables and claim it back when the variables are no
more required.

Except statically allocated memory area, both stack and heap memory can grow and shrink
dynamically and unexpectedly. Therefore, they cannot be provided with a fixed amount of
memory in the system.

As shown in the image above, the text part of the code is allocated a fixed amount of memory.
Stack and heap memory are arranged at the extremes of total memory allocated to the program.
Both shrink and grow against each other.

Parameter Passing
The communication medium among procedures is known as parameter passing. The values of the
variables from a calling procedure are transferred to the called procedure by some mechanism.
Before moving ahead, first go through some basic terminologies pertaining to the values in a
program.

r-value
The value of an expression is called its r-value. The value contained in a single variable also
becomes an r-value if it appears on the right-hand side of the assignment operator. r-values can
always be assigned to some other variable.

l-value
The location of memory address where an expression is stored is known as the l-value of that
expression. It always appears at the left hand side of an assignment operator.

For example:

day = 1;
week = day * 7;
month = 1;
year = month * 12;

From this example, we understand that constant values like 1, 7, 12, and variables like day, week,
month and year, all have r-values. Only variables have l-values as they also represent the memory
location assigned to them.

For example:

7 = x + y;

is an l-value error, as the constant 7 does not represent any memory location.

Formal Parameters
Variables that take the information passed by the caller procedure are called formal parameters.
These variables are declared in the definition of the called function.

Actual Parameters
Variables whose values or addresses are being passed to the called procedure are called actual
parameters. These variables are specified in the function call as arguments.

Example:

fun_one()
{
int actual_parameter = 10;
call fun_two(int actual_parameter);
}
fun_two(int formal_parameter)
{
print formal_parameter;
}

Formal parameters hold the information of the actual parameter, depending upon the parameter
passing technique used. It may be a value or an address.

Pass by Value
In pass by value mechanism, the calling procedure passes the r-value of actual parameters and
the compiler puts that into the called procedure’s activation record. Formal parameters then hold
the values passed by the calling procedure. If the values held by the formal parameters are
changed, it should have no impact on the actual parameters.

Pass by Reference
In pass by reference mechanism, the l-value of the actual parameter is copied to the activation
record of the called procedure. This way, the called procedure now has the address memorylocation
of the actual parameter and the formal parameter refers to the same memory location. Therefore,
if the value pointed by the formal parameter is changed, the impact should be seen on the actual
parameter as they should also point to the same value.

Pass by Copy-restore
This parameter passing mechanism works similar to ‘pass-by-reference’ except that the changes
to actual parameters are made when the called procedure ends. Upon function call, the values of
actual parameters are copied in the activation record of the called procedure. Formal parameters
if manipulated have no real-time effect on actual parameters asl − valuesarepassed, but when the
called procedure ends, the l-values of formal parameters are copied to the l-values of actual
parameters.

Example:

int y;
calling_procedure()
{
y = 10;
copy_restore(y); //l-value of y is passed
printf y; //prints 99
}
copy_restore(int x)
{
x = 99; // y still has value 10 (unaffected)
y = 0; // y is now 0
}

When this function ends, the l-value of formal parameter x is copied to the actual parameter y.
Even if the value of y is changed before the procedure ends, the l-value of x is copied to the l-value
of y making it behave like call by reference.

Pass by Name
Languages like Algol provide a new kind of parameter passing mechanism that works like
preprocessor in C language. In pass by name mechanism, the name of the procedure being called
is replaced by its actual body. Pass-by-name textually substitutes the argument expressions in a
procedure call for the corresponding parameters in the body of the procedure so that it can now
work on actual parameters, much like pass-by-reference.
Loading [MathJax]/jax/output/HTML-CSS/jax.js