1

Visit = Biharengineeringuniversity.com

Compiler Design 2019

1.a-i
b-i c-i
d-iii
e-iii
f-iv
g-iv
h-iii i-iv
j-ii

2.bWhat is an activation record? Explain how they are used to access various local and global
variables

An activation record, also known as a stack frame or activation frame, is a data structure used to
manage the information needed to execute a function or procedure in computer programs.
When a function or procedure is called, an activation record is created and pushed onto the call
stack, which is a region of memory dedicated to managing function calls.

The activation record typically contains information such as:

Return Address: The address in the code to which control should return after the
function or procedure completes.
Parameters: Values passed to the function or procedure.
Local Variables: Variables declared within the function or procedure.
Temporary Variables: Any temporary variables needed for intermediate calculations.
Saved Registers: Values of registers that the function or procedure modifies but needs to
1.
restore before returning.

2.
3.
4.
5.
6. Control Link: A link to the activation record of the calling function or procedure,
establishing a chain of nested function calls.
7. Status Flags: Flags indicating the status of the function or procedure.
The activation record is crucial for managing the flow of control and data during program
execution. When a function is called, a new activation record is created and pushed onto the
stack. When the function completes, its activation record is popped off the stack, and control
returns to the address stored in the return address field.

Now, let's discuss how activation records are used to access various local and global variables in a
pointwise manner:

FOR more solution visit = biharengineeringuniversity.com

2
Visit = Biharengineeringuniversity.com
1. Local Variables:
• Local variables are typically stored within the activation record.
• When a function is called, space is allocated in the activation record for its local
variables.
• Accessing local variables is done by referencing their offset within the activation
record.
2. Global Variables:
• Global variables are typically stored in a separate global data area.
• To access global variables, the function may use a direct reference to the global
data area.
3. Parameter Passing:
• Parameters are passed to a function through the activation record.
• The parameters are stored in the activation record, and the function can access
them by referencing their positions within the record.
4. Return Values:
• Return values are often stored in a designated location within the activation
record.
• The calling function can access the return value when the called function
completes execution.

In a pointwise manner, accessing variables involves using specific addresses or offsets within the
activation record. For example, to access the first local variable, you might use something like
activation_record_base + offset_of_first_local_variable . Similarly, accessing parameters or other variables
follows a similar addressing scheme. The key is to maintain a consistent and welldefined structure
for the activation record to enable efficient and reliable variable access during program
execution.
2.(b) What is bottom-up parsing? Discuss shift reduce parsing technique in brief What is a handle
Bottom-Up Parsing:

Bottom-up parsing is a parsing technique that starts from the input symbols and works its way
up to the start symbol of the grammar. It's also known as shift-reduce parsing because it involves
shifting input symbols onto a stack and then reducing them to higher-level structures according
to the production rules of a grammar.

reduce parsing, the parser operates by shifting input symbols onto a stack until it can
Shift-Reduce
reduce the symbols on the top of the stack to a higher-level construct in the grammar. The two
Parsing:
reduce parsing are:
In shiftmain actions
in shift-
1. Shift
:
• Move the next input symbol onto the top of the stack.
• This operation represents incorporating the next input symbol into the current
partial parse.
2. Reduce:

FOR more solution visit = biharengineeringuniversity.com

3
Visit = Biharengineeringuniversity.com

• Replace a sequence of symbols on the top of the stack with a higher-level

construct according to a production rule.
• This operation represents recognizing a part of the parse tree and replacing it
with a non-terminal symbol.
The parsing process continues with a sequence of shifts and reduces until the entire input is
parsed and reduced to the start symbol, indicating a successful parse. The parsing process may
involve backtracking if the parser encounters an error and needs to try alternative paths. Handle:

In the context of shift-reduce parsing, a handle is a substring of the right-hand side of a

production rule that matches the symbols on top of the stack. During the reduce operation, the
handle is replaced by the non-terminal on the left-hand side of the corresponding production
rule.

Here's a step-by-step explanation:

1. Shift: Move the next input symbol onto the stack.
2. Reduce: If the symbols on the top of the stack form a handle, replace them with the
corresponding non-terminal.

The handle is essential because it represents a portion of the input that can be replaced by a non-
terminal, effectively reducing the complexity of the parse. The parser looks for handles in the
stack and applies reduction whenever a handle is found.

The success of shift-reduce parsing depends on the grammar being LALR(1) (Look-Ahead LR(1)),
meaning it uses a one-symbol look-ahead for making parsing decisions. Popular algorithms like
LR(1) and LALR(1) are used to generate parsers for shift-reduce parsing. Examples of shift-reduce
parsing algorithms include LR parsing and SLR parsing.

3.(b) What is the use of a symbol table? How are the identifiers stored in the symbol table?

A symbol table is a data structure used by compilers and interpreters to store information about
the variables, functions, objects, and other language constructs used in a program. It serves as a
central repository for mapping identifiers (such as variable names) to information about their
properties, types, scope, and memory locations. The primary purposes of a symbol table include:
1. Name Management:
• Keeping track of all identifiers used in the program and ensuring they have unique
names within their respective scopes.
2. Type Checking:
• Associating data types with variables and ensuring that operations are performed
on compatible data types.
3. Scope Management:
• Tracking the scope of variables and ensuring that identifiers are used in the
correct scope.
4. Memory Allocation:

FOR more solution visit = biharengineeringuniversity.com

4
Visit = Biharengineeringuniversity.com

• Assigning memory locations to variables and keeping track of their addresses.

5. Function and Procedure Handling:

• Managing information about functions and procedures, including parameters,
return types, and addresses.
6. Error Detection:
• Detecting and reporting errors related to identifier usage, such as undeclared
variables or conflicting names.
7. Optimizations:
• Providing a basis for compiler optimizations by analyzing the usage of variables
and functions.

Identifiers, such as variable names, are typically stored in the symbol table using an entry for each
identifier. Each entry contains information about the identifier, and the structure of this entry can
include the following components:
1. Name: The actual name of the identifier (e.g., variable name).
2. Type: The data type associated with the identifier (e.g., integer, float).
3. The scope or visibility of the identifier (e.g., local, global).
4. Scope
5. :
6. Memory Location: The address or location where the identifier is stored in memory.
Initialization Status: Whether the identifier has been initialized.
Additional Properties: Other properties specific to the programming language and
compiler requirements.
The symbol table itself can be implemented as a hash table, a linked list, a tree structure, or a
combination of these, depending on the requirements and design choices of the compiler or
interpreter. The goal is to efficiently store and retrieve information about identifiers during the
various stages of the compilation or interpretation process.

4(a).What is the pass of a compiler? Explain how the single and multi-pass compilers work

In the context of compilers, a pass refers to a complete traversal of the source code
by the compiler. Each pass performs a specific set of tasks or analyses on the source
code, and a compiler may consist of one or more passes. The organization of passes
in a compiler can be classified into two main types: single-pass and multi-pass
compilers.

Single-Pass Compiler:

In a single-pass compiler, the entire compilation process is accomplished in a single

pass through the source code. The compiler reads the source code once, performs
lexical analysis, syntax analysis, semantic analysis, code generation, and optimization
in a sequential manner, and produces the final machine code or intermediate code.
Single-pass compilers are relatively simpler in design and require less memory

FOR more solution visit = biharengineeringuniversity.com

5
Visit = Biharengineeringuniversity.com

because they process the source code linearly without the need to store intermediate
results between passes.

However, single-pass compilers have limitations. They cannot handle certain

language features that require a global view of the entire program during
compilation, such as forward references to identifiers. Additionally, optimization
opportunities may be limited due to the lack of a complete understanding of the
program's structure.

Multi-Pass Compiler:

In a multi-pass compiler, the compilation process is divided into multiple passes, each
dedicated to a specific task. The source code is read and analyzed in multiple passes,
with intermediate results stored between passes. The passes are organized such that
each pass refines the information gathered in previous passes. The final pass typically
generates the target code.

The advantages of multi-pass compilers include the ability to handle more complex
language features, perform advanced optimizations, and achieve a better
understanding of the entire program. However, multi-pass compilers are generally
more complex to implement and may require more memory to store intermediate
data structures.

The typical organization of passes in a multi-pass compiler may include:

1. Lexical Identifying and tokenizing the source code.
2. Analysis: Parsing the tokenized code to create a syntax
3. tree.
Syntax
4.
Analysis:

5. Semantic Checking for semantic errors and building a symbol

6. Analysis: table.
Intermediate Code Producing an intermediate representation
Generation: of
the code.
Improving the efficiency of the generated
Code
code.
Optimization:
Generating the final target code.
Code
Generation:

FOR more solution visit = biharengineeringuniversity.com

6
Visit = Biharengineeringuniversity.com

The choice between a single-pass and a multi-pass compiler depends on factors

such as the complexity of the language, the desired level of optimization, and the
available resources. Single-pass compilers are suitable for simpler languages and
environments, while multi-pass compilers are more appropriate for handling
complex languages and generating highly optimized code.
4(b). Explain architecture and algorithm for the non-recursive predictive parser
A non-recursive predictive parser is a type of parser used in compiler construction to analyze the
syntax of a programming language and generate a parse tree for the source code. Unlike
recursive descent parsers, non-recursive predictive parsers use a stack to manage the parsing
process and avoid recursion. They are based on the principles of predictive parsing, where the
next production to apply is predicted based on the current input symbol.

Architecture of Non-Recursive Predictive Parser:

The architecture of a non-recursive predictive parser involves a few key components:

1. Parsing Table:
• A parsing table is a data structure that guides the parser in making decisions
about which production to apply based on the current input symbol. It is typically
implemented as a two-dimensional table where one dimension represents the
non-terminals, and the other represents the terminals (and possibly the end-
ofinput marker).
• Each entry in the table contains the production rule to apply when the parser is in
a particular state (non-terminal) and sees a particular input symbol.
2. Stack:
• The stack is used to maintain the parsing state. It holds a combination of
nonterminals and terminals representing the current position in the parse tree.
• Initially, the stack contains the start symbol of the grammar.
3. Input Buffer:
• The input buffer holds the remaining input symbols to be parsed. It is consumed
as the parsing process progresses.
4. Output:
• The parser produces the parse tree or abstract syntax tree as the output. This tree
represents the hierarchical structure of the input code.
Algorithm for Non-Recursive Predictive Parsing:

The non-recursive predictive parsing algorithm follows these general steps:

1. Initialize:
• Initialize the stack with the start symbol and the input buffer with the source code.
2. Parsing Loop:
• Repeat until the stack is empty or an error is detected:
• Peek at the top of the stack to determine the current non-terminal.
• Look at the current input symbol.
• Consult the parsing table to find the production rule to apply based on
the current non-terminal and input symbol.

FOR more solution visit = biharengineeringuniversity.com

7
Visit = Biharengineeringuniversity.com
•Replace the non-terminal on top of the stack with the right-hand side of
the selected production rule.
• If the right-hand side contains non-terminals, push them onto the stack in
reverse order.
• If the right-hand side is epsilon (empty), pop the non-terminal from the
stack.
3. Acceptance or Error Handling:
• If the stack is empty and the input buffer is empty, the parsing is successful, and
the parse tree is constructed.
• If an error is detected (e.g., mismatched symbol), appropriate error-handling
mechanisms are triggered.

The parsing table is crucial to the success of non-recursive predictive parsing. Constructing the
parsing table involves carefully analyzing the grammar to predict the next production rule based
on the current non-terminal and input symbol. The table should be constructed to handle
nonambiguous grammars.

The non-recursive predictive parsing algorithm is efficient and avoids the issues of left recursion
present in some recursive descent parsers. However, constructing a parsing table can be
challenging for grammars with certain ambiguities or conflicts. Additionally, the grammar must be
LL(1), meaning that it must be left-to-right scanning, leftmost derivation, and have onesymbol
lookahead to work effectively with this parsing technique.
5.(b) What is the syntax directed translation and why are they important?

Syntax-directed translation is a method used in compiler design where the translation of a

programming language's source code into machine code or an intermediate code is guided by
the syntax of the language. This approach associates semantic actions with the production rules
of the grammar to produce a translation scheme. The translation scheme typically includes
embedded code fragments that are executed during the parsing process.

The key components of syntax-directed translation include:

1. Syntax Rules (Production Rules):
• The context-free grammar (CFG) of the programming language defines the syntax
rules. Production rules describe the structure of valid language constructs.
2. Semantic Actions:
• Semantic actions are code snippets or procedures associated with specific
production rules. They specify the actions to be taken when a particular rule is
recognized during parsing.
3. Attributes:
• Attributes are used to pass information between different parts of the translation
scheme. They can be associated with non-terminals and terminals and are often
used to represent the values or properties associated with language constructs.
Syntax-directed translation is important for several reasons:
1. Separation of Concerns:

FOR more solution visit = biharengineeringuniversity.com

8
Visit = Biharengineeringuniversity.com

• Syntax-directed translation allows for a clean separation between the syntax

analysis phase (parsing) and the semantic analysis phase. The translation scheme
can include semantic actions that are executed at specific points in the parsing
process, facilitating a modular and organized approach to compiler design.
2. Automatic Code Generation:
• Syntax-directed translation facilitates automatic code generation by associating
code fragments directly with language constructs. This simplifies the process of
producing target code or intermediate code, as the translation scheme guides the
generation of executable instructions.
3. Efficient Implementation:
• By embedding semantic actions directly into the grammar, syntax-directed
translation can lead to more efficient implementations. The translation process is
closely tied to the parsing process, minimizing the need for additional traversals
of the abstract syntax tree or intermediate representations.
4. Ease of Maintenance and Extension:
• Changes or extensions to the language can be relatively straightforward with
syntax-directed translation. Adding new features or modifying existing ones often
involves updating the associated semantic actions, making the compiler more
maintainable.
5. Facilitates Optimization:
• The translation scheme can include optimizations as semantic actions. This
enables the integration of optimization strategies directly into the compilation
process, improving the efficiency of the generated code.
6. Ease of Understanding:
• Syntax-directed translation provides a clear and structured way to understand the
relationship between the source language and the target language. The semantic
actions serve as documentation for the translation process.

In summary, syntax-directed translation is a powerful technique in compiler design that connects

the syntax of a programming language with the generation of executable code. It enables a
systematic and organized approach to the translation process, promoting modularity, automatic
code generation, and efficient implementation.
6.(a) Explain different phases of compiler

A compiler is a complex software tool that translates high-level source code written in a
programming language into machine code or an intermediate code that can be executed by a
computer. The compilation process is typically divided into several phases, each responsible for
specific tasks. The different phases of a compiler are:

1. Lexical Analysis (Scanner):

• Task: This phase, also known as scanning or tokenization, involves breaking the
source code into tokens. Tokens are the smallest units of meaning in a
programming language, such as keywords, identifiers, operators, and literals.
• Tools Used: Lexical analyzers or scanners are used to implement this phase.
Lexical analysis produces a stream of tokens as output.

FOR more solution visit = biharengineeringuniversity.com

9
Visit = Biharengineeringuniversity.com
2. Syntax Analysis (Parser):
• Task: Syntax analysis, or parsing, checks the structure of the source code based
on the grammar rules of the programming language. It constructs a hierarchical
representation of the program's syntactic structure, such as an abstract syntax
tree (AST).
• Tools Used: Parsers are employed for this phase. The output is a parse tree or an
abstract syntax tree that captures the hierarchical structure of the source code.
3. Semantic Analysis:
• Task: Semantic analysis checks the meaning of the program by examining the
context and relationships between different parts of the code. It enforces
language-specific rules and performs type checking.
• Tools Used: Semantic analyzers are responsible for this phase. The output may
include a symbol table and annotated AST, containing information about
identifiers, types, and other semantic attributes.
4. Intermediate Code Generation:
• Task: This phase generates an intermediate representation of the source code.
The intermediate code is a low-level and language-independent representation
that facilitates further optimization.
• Tools Used: Intermediate code generators produce code in an intermediate
language or representation, such as three-address code or quadruples.
5. Code Optimization:
• Task: Code optimization aims to improve the efficiency of the intermediate
gene code rated in the previous phase. It includes various techniques to reduce
exec theution time, improve memory usage, and enhance the overall performance
g Tools of enerated code.
• Used: Optimizers analyze the intermediate code and apply
to pr
transformations oduce optimized code.
6. Code Generation:
• Task: Code generation translates the optimized intermediate code into the
mach target ine code or another low-level representation specific to the target
• Tools platform.
asse Used: Code generators are responsible for this phase. They produce
mbly code, machine code, or another form of executable code.
7. Code Emission:
Task: • Code emission involves the actual creation of the final executable file or
code. It includes the assembly of generated code, linking with libraries, and
producing the final executable.
• Tools Used: Assemblers, linkers, and other tools are used to perform the tasks of
code emission.
8. Error Handling:
• Task: Throughout all phases, compilers must handle errors gracefully. Error
handling involves identifying and reporting errors to the user, indicating the
location and nature of the issues in the source code.
• Tools Used: Error handling mechanisms are integrated into each phase of the
compiler.

FOR more solution visit = biharengineeringuniversity.com

10
Visit = Biharengineeringuniversity.com
These phases collectively form the compilation process. While the exact steps and tools may vary,
the general structure of a compiler follows these stages to transform high-level source code into
an executable form.
6.(b) Explain how type checking and error reporting are performed in compiler

Type checking and error reporting are crucial aspects of the semantic analysis phase in a compiler.
These processes ensure that the source code adheres to the language's rules regarding variable
types, expressions, and other semantic constraints. Let's explore how type checking and error
reporting are typically performed in a compiler:

Type Checking:
1. Expression Type Inference:
• The compiler determines the data types of expressions in the source code. It
verifies that the operations applied to variables and literals are consistent with the
expected types according to the language's rules.
2. Type Compatibility:
• The compiler checks the compatibility of types in assignments, comparisons, and
other operations. It ensures that operands of binary operations have compatible
types and that assignments are made to variables of compatible types.
3. Function and Procedure Calls:
• Type checking extends to function and procedure calls. The compiler verifies that
the number and types of arguments passed to a function or procedure match the
declared parameters in terms of order and data type.
4. Array Indexing:
• For languages supporting arrays, the compiler checks that array indices are of integer
type and that the index is within the valid range for the array.
5. Pointer and Reference Types:
• If the language includes pointers or references, the compiler ensures that pointer
dereferences and reference assignments are type-safe.
6. Structural Typing:
• Some languages support structural typing, where types are based on the structure
of the data rather than explicit declarations. Type checking in such languages
involves ensuring that structures have compatible structures.
Error Reporting:

1. Location Information:
• When an error is detected, the compiler provides detailed information about the
location of the error in the source code. This information helps programmers
identify and correct the issues.
2. Error Messages:
• The compiler generates informative error messages that describe the nature of
the error. These messages often include suggestions for fixing the problem, aiding
developers in the debugging process.
3. Multiple Errors:

FOR more solution visit = biharengineeringuniversity.com

11
Visit = Biharengineeringuniversity.com
• Compilers are designed to handle multiple errors in a single compilation run. The
compiler attempts to detect and report as many errors as possible in a single pass
through the source code, making it more efficient for programmers to address
issues.
4. Contextual Information:
• Error messages may include contextual information, such as the expected type,
the type found, and the context in which the error occurred. This helps
programmers understand the nature of the error and its surrounding context.
5. Severity Levels:
• Errors are often categorized by severity levels, such as warnings, errors, and fatal
errors. Warnings indicate potential issues that may not prevent compilation, while
errors and fatal errors halt the compilation process.
6. Recovery Mechanisms:
• Some compilers are designed to employ error recovery mechanisms, allowing
them to continue parsing and analyzing the source code after encountering an
error. This helps identify additional errors in subsequent parts of the code.

By integrating thorough type checking and effective error reporting mechanisms, compilers
contribute to the reliability and correctness of software development. These features assist
programmers in identifying and addressing issues early in the development process, ultimately
leading to more robust and maintainable code.

Draw syntax tree and DAG for the a=(a*b+c)^(b+c)*b+c

Creating a syntax tree and directed acyclic graph (DAG) involves representing the syntactic
structure of the given expression. I'll provide textual representations of both structures.

Syntax Tree:
The syntax tree represents the hierarchical structure of the expression:

javascript Copy code

^/\/\/\*+ /\/ \/\/\^+bc/\/\=*/\/ \a+bc/\*+ /\/ \abc

In the syntax tree:

• The operators are represented by internal nodes.
• The operands are represented by leaf nodes.
• The tree is constructed based on the hierarchy of operations in the expression.
Directed Acyclic Graph (DAG):
The DAG represents the same expression with shared subexpressions to avoid redundancy:

FOR more solution visit = biharengineeringuniversity.com

12
Visit = Biharengineeringuniversity.com

^
/\
/ \
/ \
* +
/\ /\
/ \ / \
^ +b c
/\
/ \
= *
/\ / a
+b \
/\

* a c /
b

In the DAG:
• Shared subexpressions are represented only once.
• Each node corresponds to an operation or a value.
• The DAG is acyclic, meaning there are no cycles in the graph.

These representations capture the structure of the given expression, showing the
relationships between different subexpressions. Keep in mind that the actual
visual representation may vary based on the tool or method used for drawing the
tree or DAG.
7.(a). Explain various targets for code optimization with examples
Code optimization is a crucial phase in the compilation process where the compiler aims to
improve the efficiency, speed, and resource utilization of the generated code. Different targets for
code optimization address various aspects of program performance. Here are various targets for
code optimization along with examples:

1. Execution Time:

FOR more solution visit = biharengineeringuniversity.com

13
Visit = Biharengineeringuniversity.com
• Objective: Minimize the total execution time of the program.
• Example: Loop unrolling, which involves replicating the body of a loop to reduce
loop control overhead and improve instruction-level parallelism.
2. Code Size:
• Objective: Minimize the size of the generated code.
• Example: Function inlining, where small functions are replaced with their actual
code at each call site to reduce the overhead of function calls.
3. Memory Usage:
• Objective: Minimize the memory footprint of the program.
• Example: Data flow analysis to identify unused variables and eliminate
unnecessary allocations.
4. Power Consumption:
• Objective: Minimize the power consumption of the program during execution.
• Example: Aggressive register allocation to reduce the frequency of memory
accesses and improve power efficiency.
5. Instruction Throughput:
• Objective: Improve the number of instructions executed per unit time.
• Example: Loop unrolling and software pipelining to increase the overlap of
instruction execution.
6. Cache Performance:
• Objective: Optimize the usage of the CPU cache to reduce cache misses.
• Example: Loop restructuring to enhance spatial locality and reduce cache misses.
7. Parallelism and Concurrency:
• Objective: Exploit parallelism to execute multiple instructions simultaneously.
• Example: Automatic parallelization of loops to execute iterations concurrently on
multiple processors or cores.
8. Reducing Branching Overhead:
• Objective: Minimize the impact of branch instructions on program execution.
• Example: Loop unrolling and predication to reduce the number of branches or
make branches more predictable.
9. Scalar Replacement:
• Objective: Reduce memory access overhead by replacing array elements with
scalar variables.
• Example: Scalar replacement of array elements in hot loops.
10. Global Common Subexpression Elimination (GCSE):
• Objective: Eliminate redundant computations across the entire program.
• Example: Identifying and eliminating common subexpressions that are computed
multiple times.
11. Dead Code Elimination:
• Objective: Remove code that has no impact on the program's output.
• Example: Identifying and removing unreachable code or code whose results are
not used.
12. Strength Reduction:
• Objective: Replace expensive operations with equivalent, less expensive ones.
• Example: Replacing multiplication with shifts or additions when possible.
13. Loop Optimization:
• Objective: Improve the performance of loops, a critical part of many programs.

FOR more solution visit = biharengineeringuniversity.com

14
Visit = Biharengineeringuniversity.com
• Example: Loop unrolling, loop interchange, and loop fusion to optimize loop
structures.
14. Function Specialization:
• Objective: Generate specialized versions of functions for specific argument types.
• Example: Template specialization in C++ or generating different versions of a
function for different types in languages like Ada.

These targets for code optimization represent a broad spectrum of considerations aimed at
enhancing the performance of compiled programs. The choice of optimization targets depends
on factors such as the nature of the application, the target hardware architecture, and the
tradeoffs between execution time, code size, and resource usage.
7.(b) How are CPU registers allocated while creating machine code?
Register allocation is a crucial step in the code generation phase of a compiler. The goal is to map
variables in the source code to a limited number of CPU registers efficiently. Registers are small,
fast storage locations within the CPU, and using them effectively can significantly impact program
performance.

Here's a general overview of how CPU registers are allocated during the process of creating
machine code:

1. Intermediate Code Generation:

• Before register allocation, the compiler generates intermediate code, which is an abstract
representation of the program's functionality.

2. Control Flow and Data Flow Analysis:

• The compiler performs control flow analysis to understand how program control flows
between different parts of the code (e.g., loops, branches).
• Data flow analysis is conducted to track how values flow through the program.

3. Determine Live Ranges:

• For each variable in the program, the compiler determines its live range, which is the
portion of the program's execution during which the variable holds a value.

4. Build Interference Graph:

• An interference graph is constructed to represent relationships between variables. Two
variables are considered interfering if their live ranges overlap.
• Nodes in the graph represent variables, and edges represent interference between
variables.

5. Graph Coloring:
• The interference graph is colored in such a way that no two interfering variables share the
same color (register).
• Graph coloring algorithms are used for this purpose. The number of colors needed
corresponds to the number of available registers.

6. Spill Handling:

FOR more solution visit = biharengineeringuniversity.com

15
Visit = Biharengineeringuniversity.com

• If there are not enough registers to allocate to all variables without interference, the
compiler must handle spills. A spill involves storing a variable temporarily in memory
when it cannot be kept in a register.
• The spill code is inserted at points where a variable's value is spilled to memory or loaded
back into a register.

7. Optimizations:

• Register allocation is often intertwined with various optimization techniques. For

example, the compiler may apply loop unrolling or software pipelining to reduce
register pressure and improve register allocation opportunities.

8. Generate Machine
Code:
• Finally, the compiler generates machine code based on the register allocation
decisions made during the earlier stages.
• The generated code uses the allocated registers for variable storage and
manipulation.
Example:
Consider the following snippet in a hypothetical assembly-like language:

ADD R1, R2, R3 ; R1 = R2 + R3

SUB R4, R1, R5 ; R4 = R1 - R5

In this example, the compiler would perform register allocation for R1 , R2 , R3 , R4 , and
R5 . The live ranges of these registers would be analyzed, and an interference graph
would be constructed. The graph coloring algorithm would then determine which
registers to assign to each variable.

The final machine code might look like:

ADD %rax, %rbx, %rcx ; %rax = %rbx + %rcx

SUB %rdx, %rax, %r8 ; %r8 = %rax - %rdx
Here, %rax , %rbx , %rcx , %rdx , and %r8 are registers used for the corresponding variables, and the
compiler has performed register allocation based on the interference graph and graph coloring.
9.(a) Difference between S-attribute SDT and L-attribute SDT with suitable examples

FOR more solution visit = biharengineeringuniversity.com

16
Visit = Biharengineeringuniversity.com

S-attribute and L-attribute are two classifications of syntax-directed translation (SDT) schemes in
compiler design. Syntax-directed translation refers to the process of associating attributes with
the grammar productions to guide the translation of a source program into a target code. These
attributes are often associated with nodes in the abstract syntax tree (AST). S-attributes and
Lattributes differ in terms of when the attributes are evaluated and synthesized.

S-Attribute SDT (Synthesized Attributes):

In an S-attribute SDT, attributes are synthesized during a bottom-up traversal of the syntax tree.
Synthesized attributes are attributes whose values are determined at the node where they are
associated. The values are synthesized from the attributes of the children of that node. This type
of SDT is well-suited for bottom-up parsing techniques.

Example: Consider a simple grammar for arithmetic expressions:

E -> E + T | T
T -> T * F | F
F -> ( E ) | id

Associated with each production, we have synthesized attributes val for nonterminals
E , T , and F . The attributes represent the values of the corresponding expressions.
• Synthesized Attribute Rules:
• E.val = E1.val + T.val for the production E -> E + T
• E.val = T.val for the production E -> T
• T.val = T1.val * F.val for the production T -> T * F
• T.val = F.val for the production T -> F
• F.val = E.val for the production F -> ( E )
• F.val = id.lexval for the production F -> id

L-Attribute SDT (Inherited Attributes):

In an L-attribute SDT, attributes are inherited during a top-down traversal of the
syntax tree. Inherited attributes are attributes whose values are passed down from
the parent node to its children. This type of SDT is well-suited for top-down parsing
techniques.

Example: Consider the same arithmetic expression grammar:

E -> T E'
E' -> + T E' | ε
T -> F T'
T' -> * F T' | ε

FOR more solution visit = biharengineeringuniversity.com

17
Visit = Biharengineeringuniversity.com
F -> ( E ) | id

Associated with each production, we have inherited attributes inh for non-terminals E , T , E' , T' , and
F . The attributes represent information that needs to be passed down from the parent to its
children.
• Inherited Attribute Rules:
• E'.inh = E.inh
• E.val = E1.val + T.val
• T'.inh = T.inh
• T.val = T1.val * F.val
• F.inh = T'.inh
• F.val = E.val
• E'.val = E'.inh + T.val (Note: Here, E' has both synthesized and inherited attributes)

Summary:
• S-Attribute SDT:
• Synthesized attributes.
• Bottom-up evaluation.
• Suitable for bottom-up parsing.
• Example: Values are synthesized up the syntax tree, starting from the leaves.
• L-Attribute SDT:
• Inherited attributes.
• Top-down evaluation.
• Suitable for top-down parsing.
• Example: Information is inherited down the syntax tree, starting from the root.
9.(b) I explain about lexical phase error

In the context of compiler design, the lexical phase, also known as lexical analysis or scanning, is
the initial stage where the source code is processed to identify and tokenize its basic elements,
such as keywords, identifiers, literals, and operators. A lexical phase error refers to an issue
encountered during this tokenization process. Lexical errors occur when the compiler encounters
sequences of characters in the source code that do not form valid tokens according to the
programming language's syntax rules.

Common examples of lexical errors include:

1. Illegal Characters:
• When the compiler encounters characters that are not part of the language's valid
character set or reserved for specific purposes. For example, using special
characters in an identifier name.
pythonCopy code
# Lexical error: '$' is not a valid character in an identifier illegal$id = 42
2. Unrecognized Tokens:
• When the compiler encounters sequences of characters that do not match any
valid token in the language. This can happen when using undefined or misspelled
keywords.

FOR more solution visit = biharengineeringuniversity.com

18
Visit = Biharengineeringuniversity.com
9.(b).(ii) give note on code generation using dynamic programming
Code generation using dynamic programming is a compiler optimization technique that focuses
on improving the efficiency of the generated code by dynamically analyzing and optimizing the
intermediate representations of the program. Dynamic programming is a method for solving
problems by breaking them down into smaller, overlapping subproblems and solving each
subproblem only once, storing the solutions to subproblems in a table for reuse. In the context of
code generation, dynamic programming is applied to optimize the translation of high-level code
into machine code or intermediate code.

Here are key notes on code generation using dynamic programming:

1. Overview of Dynamic Programming:

• Dynamic programming involves solving a problem by breaking it down into smaller,
overlapping subproblems and solving each subproblem only once.
• Solutions to subproblems are stored in a table (memoization) to avoid redundant
computations.

2. Intermediate Code Optimization:

• Dynamic programming is applied to optimize the intermediate code generated during

the compilation process.
• Intermediate code represents an abstract, platform-independent representation of
the source code and serves as a basis for generating the final machine code.

3. Memoization for Expression

Evaluation:
• In dynamic programming, memoization is often used to optimize the evaluation of
expressions by storing the results of subexpressions.
• Example: If the value of A + B has been computed before, the result is stored in a table,
and future occurrences of A + B reuse the stored result.

4. Subexpression
Elimination:
• Dynamic programming can be used to identify common subexpressions in the
intermediate code and eliminate redundant computation.
• Example: If the expression X * Y has been computed before, the result is stored, and
subsequent occurrences of X * Y reuse the stored result.

5. Instruction Selection
Optimization:
• Dynamic programming is applied to optimize the selection of machine instructions
for translating high-level operations into machine code.
• The goal is to find an optimal sequence of instructions that minimizes the overall cost,
considering factors like execution time and resource utilization.

FOR more solution visit = biharengineeringuniversity.com

19
Visit = Biharengineeringuniversity.com

6. Register
Allocation:
• Dynamic programming can be used to optimize register allocation, determining how
variables are mapped to processor registers during execution.
• The goal is to minimize the number of spills to memory and improve the efficiency of
register usage.

7. Control Flow
Optimization:
• Dynamic programming can optimize control flow constructs, such as loops and
conditionals, by analyzing the program's behavior and making informed decisions
about loop unrolling, loop fusion, and other optimizations.

8. Benefits and
Challenges:
• Benefits: Dynamic programming can lead to more efficient code by reusing computed
results, eliminating redundant computations, and optimizing the allocation of
resources.
• Challenges: Implementing dynamic programming in the context of code generation
requires careful analysis of the program's structure and behavior, as well as
consideration of trade-offs between time complexity and space complexity.

9. Application in Just-In-Time (JIT)

Compilation:
• Dynamic programming is often employed in JIT compilation to optimize the
translation of high-level code into machine code at runtime.
• JIT compilers dynamically analyze the program's behavior and adapt their optimization
strategies based on runtime information.

10. Example: Memoization in Fibonacci

Computation:
• A classic example of dynamic programming is the computation of Fibonacci numbers
using memoization to avoid redundant recursive calls.
9.(b).(iii) Explain Syntax tree
A syntax tree, also known as a parse tree or concrete syntax tree, is a hierarchical tree-like data
structure that represents the syntactic structure of a source code snippet according to the rules
of a formal grammar. Syntax trees are commonly used in the field of compiler design and parsing
to understand the hierarchical relationships between different elements in the source code.

Here are key points about syntax trees:

1. Purpose:

FOR more solution visit = biharengineeringuniversity.com

20
Visit = Biharengineeringuniversity.com

• The primary purpose of a syntax tree is to represent the syntactic structure of a source
code snippet in a way that reflects the grammar of the programming language.

2. Hierarchical Structure:
• Syntax trees have a hierarchical structure that reflects the nested and structured nature of
the programming language constructs.
• Each node in the tree corresponds to a language construct, such as a statement,
expression, or declaration.

3. Nodes and Edges:

• Nodes in the syntax tree represent language constructs, while edges represent the
relationships between these constructs.
• Internal nodes represent non-terminal symbols in the grammar, and leaf nodes represent
terminal symbols (tokens) in the source code.

4. Grammar Rules:
• The structure of the syntax tree is directly derived from the production rules of the formal
grammar defining the programming language.
• Each production rule corresponds to a specific node or subtree in the syntax tree.

5. Example:
• Consider a simple arithmetic expression: 3 + 4 * (5 - 2)
• The corresponding syntax tree might look like:
+
/\
3 *
/\
4 - /\
5 2

FOR more solution visit = biharengineeringuniversity.com