Unit 1: Introduction to Compiler

1.1 Understanding Compilers

A compiler is a program that translates high-level source code written in languages like C,
Java, or Python into machine code that computers understand. It ensures the program can be
executed efficiently on the target system.
Phases of Compilation
A compiler processes the source code through multiple phases:
1. Lexical Analysis – Breaks the input into tokens (small meaningful units like keywords,
operators, and identifiers).
o Purpose: To simplify the input for further processing by identifying meaningful
units.
o Tools Used: Regular expressions and finite state machines.
2. Syntax Analysis – Ensures the structure follows the grammar rules.
o Purpose: To create a parse tree that represents the syntactic structure of the code.
o Tools Used: Context-free grammars and parsing algorithms like LL and LR
parsers.
3. Semantic Analysis – Checks for logical correctness.
o Purpose: To ensure the code adheres to the rules of the programming language.
o Tools Used: Symbol tables and type checking mechanisms.
4. Intermediate Code Generation – Converts the parsed code into an intermediate
format.
o Purpose: To create a platform-independent representation of the code.
o Tools Used: Three-address code and abstract syntax trees.
5. Optimization – Improves code efficiency.
o Purpose: To reduce resource usage and improve performance.
o Tools Used: Loop unrolling, constant folding, and dead code elimination.
6. Code Generation – Produces machine-level instructions.
o Purpose: To translate the intermediate code into executable machine code.
o Tools Used: Instruction selection and register allocation algorithms.
7. Error Handling – Detects and manages errors.
1|Page
 o Purpose: To provide meaningful feedback to the programmer.
o Tools Used: Error reporting and recovery techniques.

1.2 Passes in a Compiler

• Single-pass Compiler: Processes the source code in one go.
o Advantages: Faster compilation and simpler implementation.
o Disadvantages: Limited optimization capabilities.
• Multi-pass Compiler: Breaks compilation into multiple scans for better efficiency and
optimization.
o Advantages: Allows for advanced optimizations and error checking.
o Disadvantages: Slower compilation and increased complexity.
Example: A single-pass compiler is used in early versions of Pascal, whereas a multi-pass
compiler is common in optimizing languages like C++.

1.3 Bootstrapping
Bootstrapping refers to the technique of writing a compiler in the programming language it is
meant to compile.
• Purpose: To create a self-hosting compiler that can compile its own source code.
• Process:
1. Write a simple version of the compiler in another language.
2. Use the simple compiler to compile a more advanced version written in the target
language.
3. Repeat the process until the compiler is fully self-hosting.
Example: Writing a C compiler in C itself.

1.4 Finite State Machines (FSM) and Regular Expressions

Lexical analysis relies on Finite State Machines (FSMs) to recognize patterns, using regular
expressions for token identification.
• Finite State Machines:
o Definition: A mathematical model used to represent and control execution flow.
o Components: States, transitions, and input symbols.
2|Page
 o Applications: Token recognition, pattern matching, and parsing.
• Regular Expressions:
o Definition: A sequence of characters defining a search pattern.
o Applications: Identifying keywords, operators, and identifiers.
Example: The identifier int in C is recognized using the regular expression [a-zA-Z_][a-zA-
Z0-9_]*.

I’ll continue with Optimization of DFA-Based Pattern Matchers and LEX compiler next.
Let me know if you have any preferences for structure or additional explanations!

3|Page
 Unit 2: Basic Parsing Techniques

1. Introduction to Parsing
Parsing is the process of analyzing a sequence of tokens (generated by a lexical analyzer) to
determine its syntactic structure. A parser checks whether the syntax follows the rules defined
in a formal grammar.
There are two main types of parsing techniques:
• Top-Down Parsing: Starts from the root of the parse tree and builds it downwards.
• Bottom-Up Parsing: Starts from the leaves and works upwards to construct the parse
tree.

2. Shift-Reduce Parsing
Shift-Reduce Parsing is a bottom-up parsing method that uses a stack to hold grammar
symbols while shifting tokens from input and reducing them using production rules.
Steps in Shift-Reduce Parsing
1. Shift: Move the next token from input onto the stack.
2. Reduce: Replace a set of stack symbols with a non-terminal according to a production
rule.
3. Accept: If the stack contains only the start symbol and input is empty, parsing is
successful.

Example:
Given Grammar:
E → E + E | E * E | (E) | id
Input: id + id

Step Stack Input Action

1 id • id Shift id

2 E • id Reduce (E → id)

3 E+ id Shift '+'

4 E + id Shift id

4|Page
5 E+E Reduce (E → id)

6 E Reduce (E → E + E)

Successfully parsed!

3. Operator Precedence Parsing

This parsing method is used for expression grammars, where operators have defined
precedence. It resolves ambiguity by following precedence and associativity rules.
Rules for Operator Precedence Parsing
• Operators must have precedence (e.g., * > +).
• Associativity decides evaluation order (Left-to-right or right-to-left).
• No two consecutive non-terminals should exist in the grammar.

Example:
Expression: id+id*id
Precedence: * > +
Associativity: Left-to-right
Parsing follows precedence to ensure multiplication is evaluated first.

4. Top-Down Parsing
Predictive Parsing
Predictive parsing (LL parsing) uses lookahead symbols to make parsing decisions without
backtracking.
Steps:
1. Use a FIRST and FOLLOW table for guidance.
2. Apply recursive descent parsing or a table-driven approach.

Example:
Grammar:
E → TE'
E' → + TE' | ε

5|Page
T → FT'
T' → * FT' | ε
F → (E) | id
For input id + id * id, the predictive parser follows rule selection using FIRST and FOLLOW
sets.

5. Automatic Construction of Efficient Parsers

LR Parsers (Bottom-Up) LR parsing is powerful and used for many programming languages.
Types of LR Parsers
1. Simple LR (SLR)
2. Canonical LR (CLR)
3. Look-Ahead LR (LALR)

Example:
Constructing an LR(0) Parsing Table for:
S → aSb | ε
State Action (for a) Action (for b) Action (for $)

0 Shift 1 • Accept
Each LR parser builds a parse table to make decisions efficiently.

6. Handling Ambiguous Grammars

An ambiguous grammar has multiple parse trees for the same string. A common solution is:
• Using operator precedence
• Applying associativity rules
• Converting ambiguous grammar to unambiguous form

Example:
Ambiguous Grammar:
E → E + E | E * E | id

6|Page
For id + id * id, two trees exist.
✔ Solution: Define precedence (* > +) for unambiguous parsing.

Summary
• Shift-Reduce Parsing: Uses stack-based reduction (bottom-up).
• Operator Precedence Parsing: Resolves ambiguity in expressions.
• Predictive Parsing: Efficient top-down technique with no backtracking.
• LR Parsers: Powerful bottom-up parsing used in compilers.
• Handling Ambiguous Grammars: Requires precedence and associativity rules.
This study material gives a structured, clear explanation with examples to aid easy
understanding. Let me know if you need additional diagrams or a quiz!

7|Page
 Unit 3: Syntax-Directed Translation

Syntax-directed translation (SDT) is a method used in compilers to associate semantic rules

with syntax structures. This unit focuses on different translation techniques, representations,
and applications in compiler design.

1. Syntax-Directed Translation Schemes

SDT schemes provide a structured approach to assigning meanings to programming constructs
using grammar-based rules. These schemes guide the translation process while ensuring
consistency between syntax and semantics.
Detailed Explanation:
Syntax-directed translation schemes are integral to compiler design as they bridge the gap
between syntax and semantics. By associating grammar rules with semantic actions, SDT
schemes enable systematic translation of programming constructs.
Applications:
• Used in defining the structure of programming languages.
• Facilitates error detection and correction during compilation.
• Enhances the readability and maintainability of code.

2. Implementation of Syntax-Directed Translators

Syntax-directed translators use parse trees to convert source code into intermediate
representations. These translators follow predefined rules to process and evaluate expressions
systematically.
Key Features:
• Uses annotated parse trees to perform translation.
• Helps in defining attribute values linked to grammar symbols.
• Enables systematic transformations from high-level language to intermediate code.
Detailed Explanation:
The implementation of syntax-directed translators involves several steps:
1. Parse Tree Construction:
o Parse trees represent the syntactic structure of source code.

8|Page
 o Annotated parse trees include additional information for semantic analysis.
2. Attribute Evaluation:
o Attributes are values associated with grammar symbols.
o Synthesized attributes are computed from child nodes, while inherited attributes
are passed down from parent nodes.
3. Intermediate Code Generation:
o Intermediate code serves as a bridge between high-level and machine-level
languages.
o Ensures portability and optimization of code.

3. Intermediate Code Forms

Intermediate code serves as a bridge between high-level programming languages and machine
code, enhancing portability and optimization.
Common Intermediate Representations:
• Postfix Notation: A sequential form that eliminates the need for parentheses.
• Syntax Trees & Parse Trees: Structural representations of programming constructs.
• Three-Address Code (TAC): A format that simplifies computation.
• Quadruples & Triples: Representations used for efficient evaluation in optimization
processes.
Detailed Explanation:
Intermediate code forms are crucial for compiler design as they provide a platform for
optimization and machine code generation.
Advantages:
• Enhances code portability across different platforms.
• Simplifies the process of code optimization.
• Serves as a foundation for advanced compiler techniques.

4. Translation of Assignment Statements

Assignment statements are fundamental in programming and require efficient conversion
techniques for execution. SDT defines structured transformations to ensure correct
computation.

9|Page
Key Translation Techniques:
• Associating grammar symbols with transformation rules.
• Breaking expressions into smaller components for efficient processing.
• Using systematic evaluation approaches to improve computational accuracy.
Detailed Explanation:
The translation of assignment statements involves:
1. Grammar Rule Association:
o Grammar rules define the structure of assignment statements.
o Semantic actions are associated with these rules to perform translation.
2. Expression Evaluation:
o Expressions are broken down into smaller components.
o Each component is evaluated systematically to ensure accuracy.
3. Intermediate Code Generation:
o Intermediate code represents assignment statements in a machine-readable
format.
o Ensures efficient execution during runtime.

5. Boolean Expressions & Control Flow Statements

Boolean expressions influence decision-making structures like if statements and loops.
Efficient translation ensures correct logical flow.
Importance in Compiler Design:
• Boolean expressions direct conditional executions.
• Control flow statements define structured program behavior.
• Optimized translation improves runtime efficiency.
Detailed Explanation:
Boolean expressions and control flow statements are essential for structured programming.
Key Aspects:
• Boolean Expressions:
o Represent logical conditions in programming.
o Used in decision-making structures like if statements and loops.
10 | P a g e
 • Control Flow Statements:
o Define the sequence of program execution.
o Include constructs like loops, conditional statements, and case statements.

6. Postfix Translation & Top-Down Parsing

Postfix notation provides an efficient alternative for expression evaluation by eliminating
hierarchical dependencies.
Advantages:
• Simple execution without explicit precedence markers.
• Direct representation of computation order.
• Reduces parsing complexity for arithmetic expressions.
Detailed Explanation:
Postfix translation and top-down parsing are techniques used in compiler design to simplify
expression evaluation.
Key Techniques:
• Postfix Translation:
o Converts expressions into postfix notation for efficient evaluation.
o Eliminates the need for parentheses and precedence markers.
• Top-Down Parsing:
o Parses expressions from the top of the parse tree to the bottom.
o Ensures systematic evaluation of expressions.

7. Translation of Arrays, Procedures & Case Statements

Arrays and procedures demand specialized translation methods to handle indexing, function
calls, and conditional execution.
Key Aspects:
• Array references ensure correct memory allocation.
• Procedure calls enable structured function execution.
• Case statements define multiple branching possibilities.
Detailed Explanation:

11 | P a g e
The translation of arrays, procedures, and case statements involves:
1. Array Translation:
o Handles indexing and memory allocation.
o Ensures efficient access to array elements.
2. Procedure Translation:
o Manages function calls and parameter passing.
o Enables structured execution of procedures.
3. Case Statement Translation:
o Defines multiple branching possibilities.
o Ensures correct execution of conditional statements.

Summary:
Syntax-directed translation plays a vital role in compiler design, supporting structured
translation methods and efficient execution. It facilitates systematic transformations, ensuring
the proper conversion of programming constructs into intermediate forms.
Detailed Summary:
Syntax-directed translation is a cornerstone of compiler design, enabling systematic
conversion of programming constructs into intermediate representations.
Key Benefits:
• Enhances code portability and optimization.
• Supports structured programming and efficient execution.
• Provides a foundation for advanced compiler techniques.

12 | P a g e
 Unit 4: Symbol Tables, Run-Time Administration, and Error
Detection & Recovery

1. Symbol Tables
A symbol table is a data structure used by a compiler to keep track of identifiers, variables,
functions, and other symbols within a program. It plays a crucial role in managing scope and
bindings of variables and functions.
Purpose of Symbol Tables
• Store and retrieve names efficiently.
• Track attributes like data type, scope, and location in memory.
• Facilitate semantic analysis and optimization during compilation.
Data Structure for Symbol Tables
Different structures are used for symbol tables based on efficiency needs:
• Hash Tables: Fast lookup, insertion, and deletion operations using hashing techniques.
• Binary Search Trees (BSTs): Allow ordered storage and fast search operations.
• Linked Lists: Simpler, but slower when searching for symbols.
Example of a Symbol Table Representation
Symbol Data Type Scope Memory Address

x int Global 0x1001

y float Local 0x1002

add() func Global 0x2001

Symbol tables are essential for ensuring that the compiler can efficiently manage and resolve
references to variables and functions throughout the program. They also play a key role in
detecting errors related to undeclared variables or type mismatches.

2. Representing Scope Information

Scope refers to the visibility of a variable or function in different parts of a program. The
compiler maintains scope information using symbol tables.
• Global Scope: Variables/functions accessible from anywhere in the program.
• Local Scope: Limited to specific functions or blocks.
13 | P a g e
Scope management is critical for ensuring that variables and functions are used correctly
within their defined contexts.

3. Run-Time Administration
The run-time system is responsible for memory management while executing a compiled
program.
Simple Stack Allocation Scheme
The stack is used to manage function calls and local variables. It follows the Last-In, First-
Out (LIFO) principle.
• When a function is called, its local variables and return address are pushed onto the
stack.
• When the function exits, its stack frame is popped off, freeing memory.
Storage Allocation in Block Structured Language
Block-structured languages (like C, Java) require efficient memory management:
• Static Allocation: Memory allocated at compile time. (Example: global/static
variables).
• Stack Allocation: Used for function calls and local variables.
• Heap Allocation: Used for dynamically allocated memory (malloc(), new in C/C++).
Efficient run-time administration ensures that memory is allocated and deallocated correctly,
preventing issues like memory leaks or segmentation faults.

4. Error Detection & Recovery

Errors in compilation need to be identified and handled gracefully to allow smooth
execution.
Types of Errors in Compilation:
1. Lexical Errors: Occur during tokenization (misspelled keywords, invalid characters).
o Example: int num@ = 10; (Invalid character @)
2. Syntactic Errors: Occur during parsing (incorrect syntax).
o Example: if (x > 10 { (Missing closing parenthesis)
3. Semantic Errors: Occur when meaning is incorrect (type mismatches, undeclared
variables).
o Example: float x = 10 / "hello"; (Cannot divide a number by a string)
14 | P a g e
Error Recovery Strategies
To prevent abrupt termination, compilers implement recovery methods:
• Panic-mode Recovery: Skip invalid tokens and continue parsing.
• Phrase-level Recovery: Replace incorrect tokens with likely correct ones.
• Error Productions: Modify grammar to handle common mistakes.
Error detection and recovery are vital for ensuring that the compiler can provide meaningful
feedback to developers and continue processing code despite encountering issues.

Summary
Unit 4 focuses on symbol tables, scope management, run-time memory allocation, and
error handling in compilers. Understanding these components is crucial for designing
efficient and error-free compilers.

15 | P a g e
 Unit 5: Code Generation and Optimization

1. Introduction to Code Generation

What is Code Generation?
• Code generation is the phase in a compiler where intermediate code is translated into
target machine code.
• It involves addressing design challenges such as optimization, instruction selection, and
register allocation.
Design Issues in Code Generation
Some important concerns in code generation include:
• Efficiency – Generated code should be optimized for speed and space.
• Correctness – The code should correctly implement the semantics of the source
program.
• Target Machine Dependence – Code must be compatible with the architecture and
instruction set of the target machine.
• Optimization – The generated code should be optimized to reduce redundant operations
and unnecessary calculations.

2. Target Language and Addressing

Target Language
• The target language is the final output of the compiler, usually machine code or
assembly language.
• Examples: x86 Assembly, ARM Assembly
Addresses in Target Code
• Variables and instructions need memory addresses for execution.
• Common addressing modes include:
o Immediate Addressing – Uses constants.
o Register Addressing – Uses CPU registers.
o Direct and Indirect Addressing – Access memory locations directly or via
pointers.
o Indexed Addressing – Used for arrays.
16 | P a g e
3. Basic Blocks and Flow Graphs
Basic Block
• A basic block is a sequence of instructions with:
o No jumps into the block except at the beginning.
o No jumps out except at the end.
Theory of Basic Block
A basic block is a straight-line code sequence with no branches except at the entry and exit. It
is used to simplify the analysis and optimization of code.
Flow Graph
• A flow graph represents control flow between basic blocks.
• Nodes represent basic blocks, and edges represent possible execution paths.
Theory of Flow Graph
Flow graphs are used to represent the control flow of a program. They help in understanding
the execution paths and dependencies between different parts of the code.

4. Optimization of Basic Blocks

Machine-Independent Optimization
Machine-independent optimizations improve performance without considering specific
hardware.
Techniques:
1. Constant Folding – Compute constant expressions at compile time.
o Theory: Constant folding reduces runtime computation by evaluating constant
expressions during compilation.
2. Common Subexpression Elimination (CSE) – Remove repeated calculations.
o Theory: CSE identifies and eliminates duplicate expressions to save computation
time.
3. Dead Code Elimination – Remove unused variables and statements.
o Theory: Dead code elimination removes code that does not affect the program's
output, improving efficiency.

17 | P a g e
5. Code Generation
Process of Code Generation
1. Intermediate Code Selection
2. Instruction Selection
3. Register Allocation
4. Optimization
5. Final Code Emission
Theory of Code Generation
Code generation involves translating intermediate representations into target machine code. It
includes selecting appropriate instructions, allocating registers, and optimizing the final
output.

6. Code Optimization Techniques

Loop Optimization
Loops are critical for performance. Optimizations include:
1. Loop Unrolling – Reduces loop overhead.
o Theory: Loop unrolling minimizes the number of iterations by executing multiple
iterations in a single loop cycle.
2. Loop-Invariant Code Motion – Moves computations outside the loop.
o Theory: Loop-invariant code motion reduces redundant calculations inside loops
by moving them outside.
DAG Representation of Basic Blocks
• Directed Acyclic Graph (DAG) helps optimize repeated calculations.
• It allows detection of common subexpressions and dead code elimination.
Theory of DAG Representation
DAGs are used to represent expressions and optimize computations by identifying common
subexpressions and eliminating redundant operations.
Value Numbering & Algebraic Laws
1. Value Numbering – Assigns unique numbers to expressions to detect redundancy.
2. Algebraic Simplifications – Uses mathematical identities to reduce calculations.

18 | P a g e
 o Theory: Algebraic simplifications apply mathematical rules to simplify
expressions and improve efficiency.

7. Global Data-Flow Analysis

• Determines the flow of variables and expressions across functions.
• Identifies unreachable code, redundant calculations, and security vulnerabilities.
Theory of Data Flow Analysis
Data flow analysis examines the flow of data within a program to identify optimization
opportunities and ensure correctness.

Summary
• Code Generation transforms intermediate code into machine code.
• Optimization improves speed and efficiency.
• Techniques such as basic block optimization, loop unrolling, DAG representation,
and global data-flow analysis help optimize the process.
• Efficient code generation leads to better-performing applications.
I hope this study material is helpful! Let me know if you need specific examples or diagrams
for any topic.

19 | P a g e