NAME: MWANDIHI DAISY

REG N0: DCS/2022/36138

UNIT NAME: INTRODUCTION TO COMPILER DESIGN

UNIT CODE: DIT 3105

1.With the help of a diagram explain the architecture of a compiler design

+-------------------+

| Source Code |

+-------------------+

+-------------------+

| Lexical Analysis|

+-------------------+

+-------------------+

| Syntax Analysis |

+-------------------+

+-------------------+

| Semantic Analysis|

+-------------------+

+-------------------+

| Intermediate |

Daisy mwandihi dcs/2022/36138

| Code Generation |

+-------------------+

+-------------------+

| Optimization |

+-------------------+

+-------------------+

| Target Code |

+-------------------+

 Source Code: This is the input program written in a high-level programming language.
 Lexical Analysis: Also known as scanning, this phase breaks down the source code into a
sequence of tokens. Tokens are the smallest meaningful units of the programming language,
such as keywords, identifiers, operators.
 Syntax Analysis: Also known as parsing, this phase analyzes the structure of the source code
based on a grammar defined for the programming language. It checks if the sequence of tokens
forms a valid program according to the grammar rules.
 Semantic Analysis: This phase checks the meaning of the program by analyzing the types, scope,
and context of the identifiers and expressions used in the source code. It ensures that the
program follows the language's semantic rules.
 Intermediate Code Generation: This phase generates an intermediate representation of the
source code. This representation is usually a lower-level language or an abstract syntax tree
(AST) that is easier to work with for further analysis and optimization.
 Optimization: This phase applies various optimization techniques to improve the efficiency and
performance of the intermediate code. It may include dead code elimination, constant folding,
loop optimization, etc.
 Target Code Generation: This phase translates the optimized intermediate code into the target
language, which could be machine code for a specific hardware platform or a bytecode for a
virtual machine.
 Target Code: The final output of the compiler, which is the executable code that can be run on
the target platform.

2.State and Explain the various classifications of a compiler.

Daisy mwandihi dcs/2022/36138

  Based on number of passes:

Single-Pass Compiler: Processes the source code in a single pass, from start to finish, without revisiting
any part of the code.

Multi-Pass Compiler: Analyzes the source code in multiple passes, where each pass may perform a
specific task such as lexical analysis, syntax analysis, semantic analysis, optimization, and code
generation.

 Based on Execution:

-Ahead-of-time (AOT) Compiler: Translates the entire source code into machine code before execution.
The generated machine code is then executed directly.

-Just-in-time (JIT) Compiler: Translates portions of the source code into machine code as needed during
runtime. This approach is commonly used in languages like Java and .NET.

 Based on Target Language:

Native Compiler: Generates machine code for the target hardware directly.

Cross-Compiler: Generates code for a different platform or architecture than the one on which the
compiler runs.

Bytecode Compiler: Generates an intermediate representation, such as bytecode, which is then

interpreted or compiled further.

 Based on Optimization Levels:

Baseline Compiler: Performs minimal optimization to quickly generate executable code.

Medium-Level Optimizing Compiler: Applies a moderate level of optimization to improve performance

without significantly increasing compilation time.

High-Level Optimizing Compiler: Employs advanced optimization utechniques to generate highly

optimized code, but may have longer compilation times.

 Based on Purpose:

General-Purpose Compiler: Designed to compile programs written in a general-purpose programming

language for various applications.

Special-Purpose Compiler: Tailored for specific tasks or domains, such as scientific computing, graphics
rendering, or database query optimization.

 Based on Structure:

Monolithic Compiler: A single program that performs all phases of compilation.

Modular Compiler: Split into distinct modules, each responsible for a specific phase of compilation.
This allows for better maintenance and reusability.

Daisy mwandihi dcs/2022/36138

3.Explain the various passes as used in compiler design.

 Syntax Analysis: This pass checks the syntax of the source code and ensures that it conforms to
the rules of the programming language. It also builds a parse tree or an abstract syntax tree
(AST) that represents the structure of the code.
 Semantic Analysis: This pass checks the meaning of the source code and ensures that it is
semantically correct. It also performs type checking and resolves any references to variables or
functions.
 Lexical Analysis: This is the first pass in which the source code is scanned and broken down into
tokens. Tokens are the smallest units of the source code that have meaning, such as keywords,
identifiers, operators, and literals.
 Intermediate Code Generation: This pass generates an intermediate representation of the code
that is easier to analyze and optimize. The intermediate code may be in the form of three-
address code, quadruples, or bytecode.

4.Discuss the various types of parsing in compiler design and construction.

 Recursive Descent Parsing: This is a top-down parsing technique where the parser starts at the
root of the parse tree and recursively descends down the tree to parse the input. Each non-
terminal symbol in the grammar is associated with a parsing function that is called to parse that
symbol.
 LL Parsing: is a type of top-down parsing that uses left-to-right scanning of the input and leftmost
derivation of the grammar. LL parsers are typically implemented using a table-driven approach,
such as LL parsing, where a parsing table is used to determine the next action based on the
current input symbol and the top of the parsing stack.
 LR Parsing: LR parsing is a type of bottom-up parsing that uses left-to-right scanning of the input
and rightmost derivation of the grammar. LR parsers are more powerful than LL parsers and can
handle a larger class of grammars. LR parsers are typically implemented using a table-driven
approach, such as LR parsing, where a parsing table is used to determine the next action based
on the current input symbol and the top of the parsing stack.
 LALR Parsing: LALR parsing is a type of LR parsing that uses a more compact parsing table than LR
parsing. LALR parsers are more efficient in terms of memory usage and are commonly used in
practice.
 Shift-Reduce Parsing: Shift-reduce parsing is a type of bottom-up parsing where the parser shifts
input symbols onto the parsing stack until a reduction can be applied. When a reduction is
possible, the parser pops the right-hand side of the production from the stack and pushes the
left-hand side onto the stack.
 Operator Precedence Parsing: Operator precedence parsing is a type of bottom-up parsing that
uses the precedence and associativity of operators to parse expressions. This technique is
commonly used in the parsing of arithmetic expressions.

5.State and Explain the phases that constitute the front end of a compiler.

a.) Lexical Analysis:

Daisy mwandihi dcs/2022/36138

 - In this phase, the source code is broken down into tokens or lexemes.

- Lexical analysis removes whitespace and comments and identifies keywords, identifiers, constants,
and operators.

- The output of this phase is a stream of tokens that serves as input for the next phase.

b.) Syntax Analysis (Parsing):

- Syntax analysis checks the sequence of tokens produced by the lexical analyzer against the rules of
the programming language's grammar.

- This phase builds a parse tree or abstract syntax tree (AST) representing the hierarchical structure of
the source code.

- Syntax analysis ensures that the source code follows the syntax rules of the language.

- Common parsing techniques include recursive descent parsing, LL parsing, LR parsing, etc.

c.) Semantic Analysis:

- Semantic analysis checks the meaning of the source code beyond its syntax.

- This phase enforces semantic rules such as type checking, scope resolution, and ensuring that
variables are declared before use.

- Semantic analysis may also perform optimizations and generate intermediate code.

- Errors detected in this phase are typically related to semantic issues rather than syntax errors.

d.) Intermediate Code Generation:

- Intermediate code generation produces an intermediate representation (IR) of the source code.

- The IR is typically in a form that is closer to the target machine architecture but abstracted enough to
facilitate optimization.

- Common forms of IR include three-address code, quadruples,

6.Define peephole optimization and explain the characteristics in compiler and construction.

Peephole optimization is a technique used in compiler construction to improve the efficiency of

generated code by analyzing and modifying a small window of instructions, known as a "peephole," in
the generated code. In peephole optimization, the compiler examines a sequence of instructions in the
generated code and looks for specific patterns or sequences that can be replaced with more efficient
code. The optimization is performed by replacing the identified patterns with equivalent but more
efficient instructions.

Characteristics of peephole optimization in compiler construction include:

Daisy mwandihi dcs/2022/36138

  Pattern matching: Peephole optimization relies on pattern matching techniques to
identify specific sequences of instructions that can be optimized. These patterns can be
simple, such as replacing a sequence of instructions with a single more efficient
instruction, or more complex, involving multiple instructions and conditions.
 Localized optimization: Peephole optimization focuses on a small window of instructions,
typically a few instructions before and after a given instruction. This localized approach
allows the compiler to target specific patterns and sequences that can be optimized
without affecting the rest of the code.
 Code size reduction: One of the main goals of peephole optimization is to reduce the
size of the generated code. By replacing inefficient or redundant instructions with more
efficient ones, the compiler can generate smaller and more compact code, which can
lead to improved performance and reduced memory usage.
 Performance improvement: Peephole optimization aims to improve the performance of
the generated code by eliminating unnecessary instructions, reducing redundant
computations, and optimizing memory access patterns. These optimizations can result in
faster execution times and improved overall performance of the compiled program.

7. Discuss how the lexical analysis phase of a compiler works during compilation process

The lexical analysis phase, also known as scanning, is the first phase of the compilation process. Its main
task is to break down the source code into a sequence of tokens, which are the smallest meaningful units
of the programming language.

This how the lexical analysis works during compilation process:

 Input: The source code written in a programming language is given as input to the lexical
analyzer.
 Scanning: The lexical analyzer reads the source code character by character and groups them
into tokens. It ignores whitespace and comments.
 Tokenization: The lexical analyzer identifies the type of each token based on predefined rules.
For example, it recognizes keywords, identifiers, constants, operators, and punctuation symbols.
 Symbol Table: As the lexical analyzer encounters identifiers, it adds them to a symbol table. The
symbol table keeps track of all the identifiers used in the source code along with their attributes,
such as data type and memory location.
 Error Handling: If the lexical analyzer encounters an invalid token or an unrecognized character, it
generates an error message and stops the compilation process.
 Output: The lexical analyzer produces a stream of tokens as output. Each token typically consists
of a token type and an optional attribute value.

8.List and explain any four outputs of the preprocessor phase of compilation

 Header File Inclusion:

- One of the most common uses of preprocessor directives is to include header files using `#include`
directives. This allows the contents of external header files to be included in the source code.

Daisy mwandihi dcs/2022/36138

 - For example: `#include <stdio.h>` would include the contents of the standard I/O header file,
`stdio.h`, into the source code.

 Macro Expansion:

- Preprocessor macros are defined using `#define` directives and can be used to create symbolic
constants or to perform text substitution.

- When encountering macro invocations in the source code, the preprocessor expands them by
replacing the macro name with its definition.

- For example: `#define PI 3.14159` would define a macro named `PI`, and its invocations like `PI *
radius * radius` would be expanded to `3.14159 * radius * radius`.

 Conditional Compilation:

- Preprocessor directives like `#ifdef`, `#ifndef`, `#if`, and `#else` are used to conditionally include or
exclude portions of code based on compile-time conditions.

- This allows for platform-specific code or debugging statements to be included or excluded from the
final executable.

- For example: `#ifdef DEBUG` would include certain debug statements only if the `DEBUG` macro is
defined.

 Line Control:

- Preprocessor directives such as `#line` allow for control over line numbering in error messages and
debugging information.

- They can be used to specify the line number and file name for subsequent lines of code, which is
particularly useful when generating code through macro expansions or code generation tools.

- For example: `#line 100 "filename"` would set the line number to 100 and the file name to "filename"
for subsequent lines of code.

9.Identify four reasons of creating intermediate code during compilation as opposed to directly
translating source code to machine code.

 Portability:

- Intermediate code serves as an abstraction layer between the source code and the target machine
architecture. This allows compilers to generate intermediate code that is independent of the specific
characteristics of the target machine.

- With intermediate code, the same source code can be compiled for multiple target platforms by
generating different machine code from the intermediate representation for each platform.

- This portability facilitates cross-platform development and deployment of software.

Daisy mwandihi dcs/2022/36138

  Optimization:

- Intermediate code provides a convenient representation for applying various optimization techniques.

- Compilers can perform high-level optimizations on the intermediate code to improve the efficiency
and performance of the generated machine code.

- Optimization passes can be applied iteratively on the intermediate representation without directly
affecting the source code, allowing for extensive analysis and transformation to produce optimized
machine code.

 Modularity and Abstraction:

- Intermediate code abstracts away the low-level details of the target machine architecture, allowing
compilers to focus on language-specific semantics and optimizations.

- It enables the separation of concerns between different phases of the compilation process. For
example, the frontend can focus on parsing, semantic analysis, and generating intermediate code, while
the backend can focus on translating the intermediate code to machine code for a specific target
architecture.

 Debugging and Analysis:

- Intermediate code can be easier to debug and analyze compared to machine code, as it retains more
of the original structure and semantics of the source code.

- Debugging tools can map intermediate code back to the corresponding source code, allowing
developers to identify and fix issues more efficiently.

- Intermediate code can also be subjected to static analysis techniques to detect potential errors,
security vulnerabilities, or code smells before generating the final machine code.

10.Discuss the process of code optimization during compilation process

 Constant Folding: Evaluating constant expressions at compile-time.

 Dead Code Elimination: Removing unreachable code.
 Common Subexpression Elimination: Identifying and eliminating redundant calculations.
 Loop Optimization: Transforming loops to reduce overhead and improve cache usage.
 Inlining: Replacing function calls with the actual function code to avoid the overhead of a
function call.
 Register Allocation: Assigning variables to registers to minimize memory access.
 Instruction Scheduling: Reordering instructions to minimize pipeline stalls and improve execution
parallelism.
 Data Flow Analysis: Analyzing how data flows through the program to optimize memory access
patterns and reduce dependencies.

11.Describe four optimizations likely to be performed on a piece of code during compilation

Daisy mwandihi dcs/2022/36138

  Loop Unrolling:

- Description: Loop unrolling involves replicating the loop body multiple times to reduce loop overhead
and improve instruction-level parallelism.

- Example: Instead of executing a loop 10 times, the compiler might unroll it to execute the loop body 2
or 3 times without the loop control overhead.

- Benefit: Reduces the number of loop control instructions and improves the potential for instruction
pipelining and parallel execution.

 Common Subexpression Elimination (CSE):

- Description: CSE identifies repeated calculations within a code block and computes them only once,
storing the result in a temporary variable.

- Example: If the same expression `a + b` occurs multiple times within a block, CSE would compute it
once and reuse the result.

- Benefit: Reduces redundant computations, improving both execution speed and code size.

 Inlining:

- Description: Inlining replaces a function call with the actual body of the function, eliminating the
overhead of the function call.

- Example: Instead of calling a small function `add(a, b)`, the compiler might directly insert the addition
operation (`a + b`) at each call site.

- Benefit: Avoids the overhead of function call setup and teardown, potentially improving performance
by enabling further optimizations and reducing code size.

 Register Allocation:

- Description: Register allocation assigns variables to CPU registers whenever possible to minimize
memory access

- Example: If a variable is frequently used within a small code block, the compiler may allocate a
register to hold its value instead of accessing it from memory.

- Benefit: Reduces memory accesses, which are typically slower compared to register access, thereby
improving execution speed and reducing power consumption.

12.Explain how lexemes becomes tokens and consequently highlight the importance of tokens in the
compilation process.

It involves breaking down the source code into lexemes and then assigning them appropriate token
types. For example, if the lexeme is "if", it will be assigned the token type "keyword".

Tokens are important in the compilation process for several reasons:

Daisy mwandihi dcs/2022/36138

  Simplify parsing: Tokens provide a simplified representation of the source code, making it easier
for the parser to analyze the structure and syntax of the program. The parser deals with tokens
rather than individual characters or lexemes, which reduces the complexity of the parsing
process.
 Error detection: Tokens help in detecting errors and reporting them to the programmer. If a
lexeme does not match any valid token type, it indicates a syntax error. The compiler can
generate meaningful error messages based on the token types, making it easier for the
programmer to identify and fix the issues.
 Language specification: Tokens play a crucial role in defining the language specification. The
token types and their corresponding lexemes define the syntax and semantics of the
programming language. By categorizing lexemes into tokens, the compiler ensures that the
source code adheres to the language rules and conventions.
 Code optimization: Tokens can also be used for code optimization. By analyzing the tokens, the
compiler can identify patterns and optimize the generated code. For example, it can recognize
repeated code segments and replace them with more efficient instructions.

13.Discuss the role of symbol table during compilation process.

Its roles are:

 Storage of Symbol Information:

- The symbol table maintains a mapping between symbols and their attributes. Symbols can include
identifiers, labels, constants, and other language constructs.

- For each symbol, the symbol table typically stores information such as its name, type, scope, memory
location and other relevant attributes.

 Scope Management:

- One of the key functions of the symbol table is to manage the scopes of symbols within the program.
Scopes define the visibility and accessibility of symbols in different parts of the program.

- The symbol table tracks the hierarchical nesting of scopes, ensuring that symbols declared within
inner scopes do not conflict with those declared in outer scopes.

- It facilitates the resolution of identifiers to their correct definitions based on scope rules, such as
lexical scoping or block scoping.

 Semantic Analysis:

- During semantic analysis, the compiler uses the symbol table to perform various checks, such as type
checking and declaration verification.

- When encountering identifiers or other symbols in the source code, the compiler consults the symbol
table to ensure that they are declared and used correctly according to the language's rules.

Daisy mwandihi dcs/2022/36138

 - Type information stored in the symbol table helps the compiler enforce type compatibility and detect
type-related errors.

 Code Generation:

- In the code generation phase, the symbol table assists in generating machine code or intermediate
representations.

- It provides information about the memory layout and addressing mode for variables, enabling the
compiler to generate instructions that access variables correctly.

- The symbol table may also be used to resolve symbolic references to memory locations or functions,
associating them with their respective addresses in the generated code.

 Optimizations:

- Some compiler optimizations, such as constant folding, dead code elimination, and register allocation,
rely on information stored in the symbol table.

- The symbol table provides insights into the usage patterns of symbols, enabling optimizations to be
applied more effectively based on the scope and lifetime of variables.

14.Discuss the various error recovery strategies in compilers.

 Panic Mode Recovery:

- When a syntax error is encountered, the compiler enters panic mode, discarding input tokens until it
finds a synchronization point or recovers to a state where parsing can resume.

- This strategy helps prevent cascading errors and allows the compiler to continue parsing and
analyzing subsequent parts of the code.

 Phrase-Level Recovery:

- In this approach, the compiler attempts to identify and correct errors at the level of syntactic phrases
or constructs within the source code.

- When an error is detected within a particular construct, the compiler applies heuristic rules to recover
from the error and continue parsing.

- Examples of phrase-level recovery techniques include inserting missing tokens, deleting extraneous
tokens, or substituting incorrect tokens with plausible alternatives based on context.

 Deferred Error Reporting:

- Instead of immediately halting the compilation process upon encountering an error, the compiler may
choose to defer error reporting until a later stage, such as after parsing or semantic analysis.

Daisy mwandihi dcs/2022/36138

 - Deferred error reporting allows the compiler to detect and collect multiple errors within a single pass,
providing more comprehensive diagnostic information to the user.

 Interactive Error Recovery:

- In interactive development environments or integrated development environments (IDEs), compilers

may offer interactive error recovery features that assist the programmer in correcting errors in real-time.

- These features often include syntax highlighting, code suggestions, automatic indentation, and
interactive error messages that guide the user towards resolving syntax or semantic issues as they write
code.

Daisy mwandihi dcs/2022/36138