The document summarizes the six main phases of a compiler: 1. The lexical analyzer identifies tokens from the source code and removes whitespace and comments. 2. The syntax analyzer checks that the code follows grammar rules of the language and constructs a parse tree. 3. The semantic analyzer verifies type consistency and checks for semantic errors using the symbol table and parse tree. 4. The intermediate code generator produces machine-independent code in a form that can be optimized and executed. 5. The code optimizer improves performance by removing unused code and variables without altering meaning. 6. The code generator produces machine-specific object code by selecting instructions and registers for the target platform.

1. Name- Suchanda Banerjee
Roll No.- 10800120085
Batch- B
Sem- 5th
Asansol Engineering College

2. PHASES OF COMPILER
PCC – CS 501
Compiler Design

3. Compiler
A compiler is a large program that can read in one language
the source language and translate it into an equivalent
program in another language the target language. It
converts the program written in a high level
language(Source Language) to a low level language(Target
language).

4. Phases of Compiler Design
Compiler operates in various phases each phase transforms the source
program from one representation to another. Every phase takes inputs
from its previous stage and feeds its output to the next phase of the
compiler.
There are 6 phases in a compiler. Each of this phase help in converting
the high-level langue the machine code. The phases of a compiler are:
• Lexical analysis
• Syntax analysis
• Semantic analysis
• Intermediate code generator
• Code optimizer
• Code generator

5. Lexical
Analyzer
Syntax
Analyzer
Semantic
Analyzer
Intermediate
Code
Generator
Code
Optimizer
Code
Generator
High
Level
Language
Assembly
Code
Symbol
Table
Error
Handling

6. Phase – 1: Lexical Analyzer
It is also called a scanner. It takes the output of the preprocessor (which
performs file inclusion and macro expansion) as the input which is in a pure
high-level language. It reads the characters from the source program and groups
them into lexemes (sequence of characters that “go together”). Each lexeme
corresponds to a token. Tokens are defined by regular expressions which are
understood by the lexical analyzer. It also removes lexical errors (e.g., erroneous
characters), comments, and white space.
The primary functions of this phase are:
• Identify the lexical units in a source code.
• Classify lexical units into classes like constants, reserved words, and enter
them in different tables. It will Ignore comments in the source program.
• Identify token which is not a part of the language.

7. Phase – 2: Syntax Analyzer
Syntax analysis is all about discovering structure in code. It determines whether
or not a text follows the expected format. The main aim of this phase is to
make sure that the source code was written by the programmer is correct or
not.
Syntax analysis is based on the rules based on the specific programing language
by constructing the parse tree with the help of tokens. It also determines the
structure of source language and grammar or syntax of the language.
The primary functions of this phase are:
• Obtain tokens from the lexical analyzer.
• Checks if the expression is syntactically correct or not.
• Report all syntax errors.
• Construct a hierarchical structure which is known as a parse tree.

8. Phase – 3: Semantic Analyzer
Semantic analysis checks the semantic consistency of the code. It uses the
syntax tree of the previous phase along with the symbol table to verify that
the given source code is semantically consistent. It also checks whether the code
is conveying an appropriate meaning.
Semantic Analyzer will check for Type mismatches, incompatible operands, a
function called with improper arguments, an undeclared variable, etc.
Functions of Semantic analyses phase are:
• Helps you to store type information gathered and save it in symbol table or
syntax tree.
• Allows you to perform type checking.
• In the case of type mismatch, where there are no exact type correction rules
which satisfy the desired operation a semantic error is shown.
• Collects type information and checks for type compatibility.
• Checks if the source language permits the operands or not.

9. Phase – 4: Intermediate Code Generator
It generates intermediate code, which is a form that can be readily executed by
a machine We have many popular intermediate codes. Example – Three address
codes etc. Intermediate code is converted to machine language using the last
two phases which are platform dependent.
Till intermediate code, it is the same for every compiler out there, but after
that, it depends on the platform. To build a new compiler we don’t need to
build it from scratch. We can take the intermediate code from the already
existing compiler and build the last two parts.
Functions on Intermediate Code generation:
• It should be generated from the semantic representation of the source
program.
• Holds the values computed during the process of translation.
• Helps you to translate the intermediate code into target language.
• Allows you to maintain precedence ordering of the source language.
• It holds the correct number of operands of the instruction.

10. Phase – 5: Code Optimizer
It transforms the code so that it consumes fewer resources and produces more
speed. The meaning of the code being transformed is not altered. Optimization
can be categorized into two types: machine-dependent and machine-independent.
The primary functions of this phase are:
• It helps you to establish a trade-off between execution and compilation speed.
• Improves the running time of the target program.
• Generates streamlined code still in intermediate representation.
• Removing unreachable code and getting rid of unused variables.
• Removing statements which are not altered from the loop.

11. Phase – 6: Code Generator
The main purpose of the Target Code generator is to write a code that the
machine can understand and also register allocation, instruction selection, etc. The
output is dependent on the type of assembler. This is the final stage of
compilation. The optimized code is converted into relocatable machine code which
then forms the input to the linker and loader.