{"id":2823,"date":"2025-06-07T15:02:55","date_gmt":"2025-06-07T15:02:55","guid":{"rendered":"https:\/\/diznr.com\/?p=2823"},"modified":"2025-06-07T15:02:55","modified_gmt":"2025-06-07T15:02:55","slug":"six-phases-of-compiler-lexical-syntax-semantic-intermediate-code-generation-optimization-code","status":"publish","type":"post","link":"https:\/\/www.reilsolar.com\/pdf\/six-phases-of-compiler-lexical-syntax-semantic-intermediate-code-generation-optimization-code\/","title":{"rendered":"Six Phases of compiler – Lexical \/Syntax \/Semantic \/Intermediate code generation\/code optimization"},"content":{"rendered":"

Six Phases of compiler – Lexical \/Syntax \/Semantic \/Intermediate code generation\/code optimization<\/p>\n

[fvplayer id=”131″]<\/p>\n

\u00a0Six Phases of Compiler<\/strong><\/h3>\n

A compiler<\/strong> translates high-level code<\/strong> into machine code<\/strong> through six main phases<\/strong>:<\/p>\n

Lexical Analysis<\/strong>
Syntax Analysis<\/strong>
Semantic Analysis<\/strong>
Intermediate Code Generation<\/strong>
Code Optimization<\/strong>
Code Generation<\/strong><\/p>\n

\u00a0Lexical Analysis (Scanning)<\/strong><\/h3>\n

Input<\/strong>: Source Code (High-level language)
Output<\/strong>: Tokens
Purpose<\/strong>: Converts the source code into tokens<\/strong> (smallest units of the program).
Performs<\/strong>:
\u00a0Removes whitespaces, comments<\/strong>
\u00a0Identifies keywords, identifiers, operators, symbols<\/strong>
\u00a0Stores tokens in Symbol Table<\/strong><\/p>\n

Example:<\/strong>
Input:<\/strong> int x = 10;<\/code>
Output:<\/strong><\/p>\n

\n
TOKEN<\/span>( int ), TOKEN<\/span>( x ), TOKEN<\/span>( = ), TOKEN<\/span>( 10<\/span> ), TOKEN<\/span>( ; )
\n<\/code><\/div>\n<\/div>\n

\u00a0Syntax Analysis (Parsing)<\/strong><\/h3>\n

Input<\/strong>: Tokens from Lexical Analysis
Output<\/strong>: Parse Tree (Syntax Tree)
Purpose<\/strong>: Checks if the code follows the grammar rules<\/strong> (using parsing techniques like LL(1), LR(1)).
Performs<\/strong>:
\u00a0Builds Parse Tree<\/strong>
\u00a0Detects Syntax Errors<\/strong><\/p>\n

Example:<\/strong>
Input:<\/strong> int x = 10;<\/code>
Output:<\/strong> Parse Tree<\/strong><\/p>\n

\n
Assignment
\n\/ | \\
\nint<\/span> x 10<\/span>
\n<\/code><\/div>\n<\/div>\n

\u00a0If we write int = x 10;<\/code>, the compiler will show a syntax error<\/strong>.<\/p>\n

\u00a0Semantic Analysis<\/strong><\/h3>\n

Input<\/strong>: Parse Tree
Output<\/strong>: Annotated Parse Tree
Purpose<\/strong>: Checks meaning<\/strong> and correctness<\/strong> of the program.
Performs<\/strong>:
\u00a0Type Checking (int x = “hello”; is invalid<\/strong>)
\u00a0Variable declaration checking<\/strong>
\u00a0Function parameter matching<\/strong><\/p>\n

Example:<\/strong>
Code:<\/strong><\/p>\n

\n
int<\/span> x = \"hello\"<\/span>; \/\/ Error: String assigned to integer<\/span>
\n<\/code><\/div>\n<\/div>\n

Error:<\/strong> Type Mismatch<\/strong><\/p>\n

\u00a0Intermediate Code Generation<\/strong><\/h3>\n

Input<\/strong>: Annotated Parse Tree
Output<\/strong>: Intermediate Code (3-address code, AST)
Purpose<\/strong>: Generates a machine-independent representation<\/strong> of the program.
Performs<\/strong>:
\u00a0Converts code to Intermediate Representation (IR)<\/strong>
\u00a0Uses Three-Address Code (TAC)<\/strong><\/p>\n

Example:<\/strong>
Code:<\/strong><\/p>\n

\n
a = b + c * d;
\n<\/code><\/div>\n<\/div>\n

TAC Output:<\/strong><\/p>\n

\n
t1<\/span> = c * d
\nt2<\/span> = b + t1
\na<\/span> = t2
\n<\/code><\/div>\n<\/div>\n

\u00a0Code Optimization<\/strong><\/h3>\n

Input<\/strong>: Intermediate Code
Output<\/strong>: Optimized Intermediate Code
Purpose<\/strong>: Makes the code faster and memory-efficient<\/strong>.
Performs<\/strong>:
Constant Folding<\/strong> \u2192 5 + 3<\/code> \u2192 8<\/code>
Dead Code Elimination<\/strong> \u2192 Removes unreachable code<\/strong>
Loop Optimization<\/strong> \u2192 Moves invariant expressions out of loops<\/strong><\/p>\n

Example:<\/strong>
Before Optimization:<\/strong><\/p>\n

\n
int<\/span> x = 2<\/span> * 10<\/span>; \/\/ Multiplication every time<\/span>
\n<\/code><\/div>\n<\/div>\n

After Optimization:<\/strong><\/p>\n

\n
int<\/span> x = 20<\/span>; \/\/ Precomputed at compile-time<\/span>
\n<\/code><\/div>\n<\/div>\n

\u00a0Code Generation<\/strong><\/h3>\n

Input<\/strong>: Optimized Intermediate Code
Output<\/strong>: Target Machine Code (Assembly\/Binary)
Purpose<\/strong>: Converts IR to actual machine code<\/strong> for execution.
Performs<\/strong>:
Register Allocation<\/strong>
Instruction Selection<\/strong>
Machine-specific code generation<\/strong><\/p>\n

Example:<\/strong>
IR:<\/strong><\/p>\n

\n
t1<\/span> = c * d
\nt2<\/span> = b + t1
\na<\/span> = t2
\n<\/code><\/div>\n<\/div>\n

Assembly Code (x86):<\/strong><\/p>\n

\n
MOV R1, c
\nMUL R1, d
\nADD R1, b
\nMOV a, R1
\n<\/code><\/div>\n<\/div>\n

\u00a0Summary of Compiler Phases<\/strong><\/h3>\n
\n\n\n\n\n\n\n\n\n\n\n
Phase<\/strong><\/th>\nInput<\/strong><\/th>\nOutput<\/strong><\/th>\nPurpose<\/strong><\/th>\n<\/tr>\n<\/thead>\n
Lexical Analysis<\/strong><\/td>\nSource Code<\/td>\nTokens<\/td>\nTokenization<\/td>\n<\/tr>\n
Syntax Analysis<\/strong><\/td>\nTokens<\/td>\nParse Tree<\/td>\nGrammar Checking<\/td>\n<\/tr>\n
Semantic Analysis<\/strong><\/td>\nParse Tree<\/td>\nAnnotated Parse Tree<\/td>\nType Checking<\/td>\n<\/tr>\n
Intermediate Code Generation<\/strong><\/td>\nAnnotated Parse Tree<\/td>\nIntermediate Code<\/td>\nMachine Independence<\/td>\n<\/tr>\n
Code Optimization<\/strong><\/td>\nIntermediate Code<\/td>\nOptimized Code<\/td>\nFaster Execution<\/td>\n<\/tr>\n
Code Generation<\/strong><\/td>\nOptimized Code<\/td>\nMachine Code<\/td>\nFinal Execution<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n

\u00a0Final Notes<\/strong><\/h3>\n

Lexical, Syntax, and Semantic Analysis<\/strong> \u2192 Detect errors.<\/strong>
Intermediate Code & Optimization<\/strong> \u2192 Improve efficiency.<\/strong>
Code Generation<\/strong> \u2192 Final machine-executable code.<\/strong><\/p>\n

\u00a0Would you like a detailed example on any specific phase?<\/strong><\/p>\n

Six Phases of compiler – Lexical \/Syntax \/Semantic \/Intermediate code generation\/code optimization<\/a><\/h3>\n
\n
\n
\n

Module 1 Compiler Phases of a Compiler ( Structure of …<\/h3>\n

Phases of Compiler<\/a><\/h3>\n
\n
\n

Here\u2019s a comprehensive overview of the six phases of a compiler<\/strong>, crucial for understanding how source code is translated into executable code:<\/p>\n

\n

\ud83d\udee0\ufe0f Six Phases of a Compiler<\/strong><\/h2>\n

Each phase takes the output of the previous phase and refines it toward machine code. The main phases are:<\/p>\n

\n

1. \ud83d\udd24 Lexical Analysis (Scanner)<\/strong><\/h3>\n