COMPILER DESIGN

ASSIGNMENT- 4

Q1 (a) Explain following:-

❖ Syntax Directed Definitions:

Syntax Directed Definitions (SDDs) are a type of context-free grammar that includes semantic rules
associated with the production rules. An SDD defines the attributes of the non-terminals and how these
attributes are computed from the attributes of the non-terminals that occur in the right-hand side of the
production rule. In other words, SDDs provide a way to associate semantic information with the syntax of a
programming language.

❖ Translation of Expressions:
The translation of an expression refers to the process of converting the abstract syntax tree (AST) of an
expression into executable code. This involves traversing the AST and generating code that performs the
computation specified by the expression. The translation process is typically performed by a compiler or
interpreter.

❖ Type Checking:
Type checking is a process performed by a compiler or interpreter that verifies that the types of operands
used in an expression are compatible with the expected types of the operators. Type checking helps to detect
errors in programs that could lead to runtime errors or incorrect behavior. Type checking is typically
performed during the compilation or interpretation process, but it can also be performed dynamically at
runtime in some languages. Type checking is an important part of ensuring the correctness and safety of a
programming language.

(b) Describe the – Design of a simple Code Generator, and what is Issues in Code Generation.

Answer: Design of a Simple Code Generator:

A code generator is a program that converts an intermediate representation of a program (such as an abstract
syntax tree or bytecode) into executable code. A simple code generator typically consists of the following
components:

1. Front End: The front end of the code generator parses the source code of a program and generates an
intermediate representation, such as an abstract syntax tree.

2. Optimization: The optimization phase performs various optimizations on the intermediate representation,
such as constant folding, dead code elimination, and loop optimization.

3. Code Generation: The code generation phase takes the optimized intermediate representation and
generates executable code for a target platform, such as x86 or ARM.

4. Back End: The back end of the code generator is responsible for managing the generated code, such as
writing it to disk or loading it into memory.

Issues in Code Generation:

Code generation can be a complex process, and there are several issues that can arise during the code
generation phase, including:

1. Register Allocation: The code generator needs to assign registers to variables and intermediate values in
a way that minimizes the number of spills (transfers between registers and memory). Register allocation can
be a challenging problem, especially on architectures with a limited number of registers.

2. Code Size: The code generator needs to produce code that is efficient in terms of both execution time and
code size. This can be a tradeoff, as optimizing for execution time may lead to larger code size, while
optimizing for code size may lead to slower execution.

3. Platform-specific Features: The code generator needs to take into account the specific features and
constraints of the target platform, such as instruction set architecture, memory model, and calling
conventions. Failure to do so can result in code that is inefficient or incorrect.

4. Debugging: The generated code can be difficult to debug, as there may not be a one-to-one
correspondence between the source code and the generated code. This can make it challenging to locate and
fix bugs in the generated code.

(c) Explain the Evaluation Orders for Syntax Directed Definitions.

Answer: Syntax Directed Definitions (SDDs) provide a way to associate semantic information with the
syntax of a programming language. SDDs can be evaluated in different orders depending on the
requirements of the particular application. There are two primary evaluation orders for SDDs:

1. Top-Down Evaluation:
In top-down evaluation, the SDD is evaluated in the same order as the parsing of the input program. That is,
the attributes associated with the non-terminals in the left-to-right order of the production rules. Top-down
evaluation is useful when the SDD is used for code generation or when the semantic information needs to be
computed in a specific order.

2. Bottom-Up Evaluation:
In bottom-up evaluation, the SDD is evaluated in the reverse order of the parsing of the input program. That
is, the attributes associated with the non-terminals are evaluated in the bottom-up fashion, from the leaves to
the root of the parse tree. Bottom-up evaluation is useful when the SDD is used for type checking or when
the semantic information needs to be computed as soon as the relevant parts of the input program have been
parsed.

It is important to note that SDDs can be evaluated in both orders, depending on the specific requirements of
the application. The choice of evaluation order can have a significant impact on the performance and
correctness of the code generated by the SDD. Therefore, it is important to carefully consider the evaluation
order when designing and implementing an SDD.

Q2. Explain the Intermediate Languages: Syntax Tree, Three Address Code, Types and Declarations.

Answer: Intermediate languages are used in the compilation process to represent the program being
compiled in a form that is easier to analyze and transform than the original source code. Three commonly
used intermediate languages are Syntax Trees, Three Address Code, and Types and Declarations.
1. Syntax Tree:
A syntax tree is a data structure that represents the syntactic structure of a program. It is constructed during
the parsing phase of the compilation process and is used as an intermediate language for subsequent phases
of the compiler. The syntax tree represents the structure of the program using nodes that correspond to the
various syntactic constructs in the language, such as statements, expressions, and declarations.

2. Three Address Code:

Three Address Code (TAC) is a low-level intermediate language that represents the program as a sequence
of instructions, where each instruction performs a single operation on three operands. TAC is often used as
an intermediate representation during optimization and code generation phases of a compiler. TAC
instructions are typically simple operations such as assignment, arithmetic operations, and conditional jumps.

3. Types and Declarations:

Types and Declarations is an intermediate language that represents the type and declaration information of
the program being compiled. It is used in the type checking phase of the compiler to ensure that the program
is semantically correct. The Types and Declarations language includes information about the types of
variables and expressions, the scope of variables and functions, and the type signatures of functions.
In summary, intermediate languages play a crucial role in the compilation process by providing a simplified
representation of the program being compiled. Syntax Trees, Three Address Code, and Types and
Declarations are three commonly used intermediate languages that help compilers to analyze and transform
source code efficiently.

Q3. Define the Storage Organization:

Answer:
1. Stack Allocation Space:
Stack allocation space is a portion of the memory used for storing local variables and function call
information. It is organized as a stack data structure where each new function call creates a new stack frame
on top of the previous one. The stack frame contains parameters, return addresses, and local variables of the
function. The stack is automatically managed by the compiler and is typically used for temporary storage of
data.

2. Access to Non-local Data on the Stack:

Non-local data on the stack refers to data that is stored in a previous stack frame, such as variables declared
in a calling function. Accessing non-local data on the stack is typically done using relative addressing or
pointer manipulation. The compiler generates code that adjusts the stack pointer to access the desired data.

3. Heap Management:
The heap is a portion of the memory used for dynamic memory allocation. Heap management refers to the
process of allocating and deallocating memory on the heap. In most programming languages, heap
management is done using functions such as malloc() and free(). The programmer is responsible for
managing the lifetime of the allocated memory to avoid memory leaks or accessing freed memory.

4. Directed Acyclic Graph (DAG):

A DAG is a directed graph that has no cycles. In the context of compilers, DAGs are often used for
optimizing expression evaluation by identifying and removing redundant computation. A DAG represents an
expression as a directed acyclic graph of common subexpressions, where each node represents an operation
and each edge represents a dependence between the operations. The DAG allows the compiler to identify
subexpressions that are repeated and eliminate redundant computations.

In summary, storage organization refers to the way the compiler and the runtime system manage the
memory of a program. Stack allocation space and access to non-local data on the stack are used for
managing local and temporary data, while heap management is used for dynamically allocating memory.
DAGs are a useful intermediate data structure for optimizing expressions.

Q4. What is the Principal Sources of Optimization? Explain the Peep-hole optimization.

Answer: The principal sources of optimization in compilers are the removal of redundant computation, the
minimization of memory accesses, and the reduction of control transfers. These sources of optimization can
be achieved through various techniques such as code motion, loop unrolling, data flow analysis, and
peephole optimization.
Peephole optimization is a local optimization technique that operates on a small sequence of instructions
called a "peephole." The peephole is typically a fixed-size window of instructions that are adjacent in the
code stream. Peephole optimization involves analyzing the instructions in the window and applying
transformations to eliminate redundant computation or improve code quality.

For example, a peephole optimization might replace a sequence of instructions that computes the sum of two
constants with a single instruction that computes the result of the sum. Another example of peephole
optimization is constant folding, where expressions involving constants are evaluated at compile-time, rather
than at runtime.

Peephole optimization is typically performed after other, more complex optimizations have been applied to
the code. It is a fast and simple optimization technique that can be applied quickly to small code sequences.
However, it is limited in its scope and can only optimize code within the window of the peephole.

In summary, the principal sources of optimization in compilers are the removal of redundant computation,
the minimization of memory accesses, and the reduction of control transfers. Peephole optimization is a
local optimization technique that operates on a small sequence of instructions to eliminate redundant
computation and improve code quality.

Q5. Define The following:

Answer:
1. Optimization of Basic Blocks:
Basic blocks are a sequence of instructions with a single-entry point and a single exit point. Optimization of
basic blocks involves analyzing the instructions in the block to identify and eliminate redundant computation,
minimize memory accesses, and improve control flow. Some common techniques used for optimizing basic
blocks include instruction scheduling, register allocation, constant propagation, and loop unrolling.

2. Global Data Flow Analysis:

Global data flow analysis is a technique used by compilers to analyze the flow of data through a program. It
involves analyzing the program's control flow and data dependencies to identify opportunities for
optimization. Global data flow analysis is typically performed at the function level and involves analyzing
all possible paths through the function to identify common sub-expressions and other optimization
opportunities.

3. Efficient Data Flow Algorithm:

Efficient data flow algorithms are algorithms used by compilers to perform data flow analysis efficiently.
These algorithms are designed to minimize the amount of data that needs to be processed while still
accurately identifying all data dependencies in the program. Some common efficient data flow algorithms
include the worklist algorithm, the bit vector algorithm, and the sparse algorithm. These algorithms can be
used for both local and global data flow analysis.

In summary, optimization of basic blocks involves analyzing instructions in a sequence to eliminate

redundant computation, minimize memory accesses, and improve control flow. Global data flow analysis
involves analyzing the flow of data through a program to identify optimization opportunities. Efficient data
flow algorithms are used by compilers to perform data flow analysis efficiently while minimizing the
amount of data that needs to be processed.