Compiler Design

(CoSc-3112)

Chapter One
Introduction

Dawit Kassahun (MSc.)

Department of Computer Science
Dilla University

Mar 2024
 Objective
At the end of this session students will be able to:
 Understand the basic concepts and principles of Compiler Design

 Understand the term compiler, its functions and how it works.

 Be familiar with the different classification of compilers.

 Be familiar with cousins of compiler: Linkers, Loaders, Interpreters, Assemblers

 Understand the need of studying compiler Design and construction

 Understand the phases of compilation and the steps of compilation

 Outline

• Introduction
• Analysis and Synthesis in compilation
• Various phases in a compilation
• Compiler construction tools
 Introduction to language Processors

 Compiler is an executable program that can read a program in one high-level language

and translate it into an equivalent executable program in machine language.

 A compiler is a computer program that translates an executable program in a source

language into an equivalent program in a target language.

A source program/code is a program/code written in the source language, which is

usually a high-level language.

A target program/code is a program/code written Source Target
program Compiler
program
in the target language, which often is a machine e.g. C++ e.g.
Assembly
language or an intermediate code (Object Code). Error
message
 Cousins of Compilers

A. Interpreter:- is another common kind of language processor and instead of producing a

target program an interpreter appears to directly executes the operations specified in the
source program on inputs supplied by the user.
 It produces output of statement during the translation
 It generally uses one of the following strategies for program execution:
i. Execute the source code directly
ii. Translate source code into some efficient intermediate representation and immediately execute this
iii. Explicitly execute stored precompiled code made by a compiler which is part of the interpreter system

B. Assembler:- is a translator that converts programs written in assembly language into

machine code.
 Translate mnemonic operation codes to their machine language equivalents.
 Assigning machine addresses to symbolic labels.
C. Linker:- is a program that takes one or more objects generated by a compiler and combines
them into a single executable program.
D. Loader:- is the part of an operating system that is responsible for loading programs from
executables (i.e., executable files) into memory, preparing them for execution and then
executing them source program
preprocessor
There are four Language translator phase
modified source program
compiler

target assembly program

assembler

Relocatable machine code

linker/loader Library files
Relocatable object files
target machine code
 Analysis and Synthesis in compilation

There are two parts to compilation: analysis & synthesis.

 During analysis, the operations implied by the source program are determined and

recorded in a hierarchical structure called a tree.

 During synthesis, the operations involved in producing translated code.

 Breaks up source program into constituent pieces
1. Lexical Analysis  Imposes a grammatical structure on these pieces
2. Syntax Analysis
Front

Analysis
End

 Creates intermediate representation of source program

3. Semantic Analysis
 Collects information about the source program and stores it in a symbol
table.

4. Code Generation  Construct target program from intermediate representation

Back

Synthesis
End

5. Optimization
 Takes the tree structure and translates the operations into the target program
Various phases in a compilation
 Analysis
1. Linear/Lexical analysis (Scanning)
 The stream of characters is read from left to right and grouped into tokens.
 A token is a sequence of characters having a collective meaning.
 Token is the basic lexical unit.
 Examples:
• Identifiers are variables
• Keywords
• Symbols (+, -, …)
• Numbers
• Etc…
 Blanks, new lines, tabulation marks will be removed during lexical analysis.
 Example
DIST1 = DIST2 + 5 * 4
<IDENT,1> <ASSIGN> <IDENT,2> <PLUS> <NUMB,3> <MULT> <NUMB,4>
2. Hierarchical/Syntax analysis (Parsing)
 Tokens are grouped hierarchically into nested collections with collective meaning.
 The result is generally a parse tree.
 Most syntactic errors in the source program are caught in this phase.
 Syntactic rules of the source language are given via a Grammar.
 Consider the previous example: DIST1
= DIST2 + 5 * 4
IDENT ASSIGN IDENT PLUS NUMB MULT NUMB
3. Semantic analysis
 Certain checks are performed to make sure that the components of the program fit
together meaningfully.
 Unlike parsing, this phase checks for semantic errors in the source program (e.g.
type mismatch)
 Semantic analysis uses the symbol table.
 Symbol table:- is a data structure with a record for each identifier and its attributes
• Attributes include storage allocation, type, scope, etc
• All the compiler phases insert and modify the symbol table
 The result of semantic analysis is Intermediate Code (IC).
 The IC can be represented using either abstract tree or Three address code
 The previous example in three address code:
TEMP1 = 5 * 4
TEMP2 = inttoreal( TEMP1 )
TEMP3 = IDENT2 + TEMP2
IDENT1 = TEMP3
 Synthesis
Synthesis is composed of two phases:
1. Code optimization
2. Code generation
3. Code optimization
 This phase changes the IC so that the code generator produces a faster and less memory
consuming program.
 The optimized code does the same thing as the original (non-optimized) code but with less cost
in terms of CPU time and memory space.
 There are several techniques of optimizing code and they will be discussed in the last chapter.
 Example
Unnecessary lines of code in loops (i.e. code that could be executed outside of the loop) are moved out
of the loop.
for(i=1; i<10; i++){ x = y+1;
x = y+1; for(i=1; i<10; i++)
z = x+i; z = x+i;
}
2. Code generation
 The final phase of the compiler.
 Generates the target code in the target language (e.g. Assembly)
 The instructions in the IC are translated into a sequence of machine instructions that
perform the same task.
Phase I: Lexical Analysis

 The low-level text processing portion of the compiler

 The source file, a stream of characters, is broken into larger chunks called token.
For example:
void main()
{ It will be broken into 13 tokens as below:
int x;
x=3; void main ( ) { int x ; x = 3 ; }
}
 The lexical analyzer (scanner) reads a stream of characters and puts them together into some meaningful

(with respect to the source language) units called tokens.

 Typically, spaces, tabs, end-of-line characters and comments are ignored by the lexical analyzer.
 To design a lexical analyzer: input a description (regular expressions) of the tokens in the language, and
output a lexical analyzer (a program).
Phase II: Parsing (Syntax Analysis)

A parser gets a stream of tokens from the scanner, and determines if the syntax (structure) of the
program is correct according to the (context-free) grammar of the source language.
 Then, it produces a data structure, called a parse tree or an abstract syntax tree, which describes the

syntactic structure of the program.

 The parser ensures that the sequence of tokens returned by the lexical analyzer forms a
syntactically correct program
 It also builds a structured representation of the program called an abstract syntax tree that is
easier for the type checker to analyze than a stream of tokens
 It catches the syntax errors as the statement below:

if if (x > 3) then x = x + 1
 Context-free grammars will be used (as the input) by the parser generator to describe the syntax of
the compiling language
 Most compilers do not generate a parse tree explicitly but rather go to intermediate code directly as
syntax analysis takes place.
Parse Tree

Is output of parsing that shows the Top-down description of program syntax
Root node is entire program and leaves are tokens that were identified during lexical

analysis

Constructed by repeated application of rules in Context Free Grammar (CFG)

Syntax structures are analyzed by DPDA (Deterministic Push Down Automata)

Example: parse tree for position:=initial + rate*60

Phase III: Semantic Analysis

 It gets the parse tree from the parser together with information about some syntactic elements
 It determines if the semantics (meanings) of the program is correct.
 It detects errors of the program, such as using variables before they are declared, assign an
integer value to a Boolean variable, …

 This part deals with static semantic.

 semantic of programs that can be checked by reading off from the program only.
 syntax of the language which cannot be described in context-free grammar.
 Mostly, a semantic analyzer does type checking (i.e. Gathers type information for subsequent code
generation.)
 It modifies the parse tree in order to get that (static) semantically correct code
 In this phase, the abstract syntax tree that is produced by the parser is traversed, looking for
semantic errors
Contd.
 The main tool used by the semantic analyzer is a symbol table
 Symbol table:- is a data structure with a record for each identifier and its attributes
 Attributes include storage allocation, type, scope, etc
 All the compiler phases insert and modify the symbol table
 Discovery of meaning in a program using the symbol table
 Do static semantics check
 Simplify the structure of the parse tree ( from parse tree to abstract syntax tree (AST) )
Static semantics check
 Making sure identifiers are declared before use
 Type checking for assignments and operators
 Checking types and number of parameters to subroutines
 Making sure functions contain return statements
 Making sure there are no repeats among switch statement labels
Phase IV: Intermediate Code Generation

 An intermediate code generator

 takes a parse tree from the semantic analyzer
 generates a program in the intermediate language.

 In some compilers, a source program is translated into an intermediate code first and then the

intermediate code is translated into the target language.

 In other compilers, a source program is translated directly into the target language.

 Compiler makes a second pass over the parse tree to produce the translated code
 If there are no compile-time errors, the semantic analyzer translates the abstract syntax tree into the

abstract assembly tree

 The abstract assembly tree will be passed to the code optimization and assembly code generation

phase
Contd.

Using intermediate code is beneficial when compilers which translates a single source

language to many target languages are required.

 The front-end of a compiler:- scanner to intermediate code generator can be

used for every compilers.

 Different back-ends:- code optimizer and code generator is required for each

target language.

One of the popular intermediate code is three-address code.

 A three-address code instruction is in the form of x = y op z.

Phase V: Assembly Code Generation

 Code generator coverts the abstract assembly tree into the actual assembly code

 To do code generation

 The generator covers the abstract assembly tree with tiles (each tile represents a small portion of

an abstract assembly tree) and

 Output the actual assembly code associated with the tiles that we used to cover the tree

Phase VI: Machine Code Generation and Linking

 The final phase of compilation coverts the assembly code into machine code and links (by a linker) in

appropriate language libraries

Code Optimization

 Replacing an inefficient sequence of instructions with a better sequence of instructions.

 Sometimes called code improvement.

 Code optimization can be done:

 after semantic analyzing
performed on a parse tree
 after intermediate code generation
performed on a intermediate code
 after code generation
performed on a target code
 Two types of optimization

1. Local
2. Global
Local Optimization

 The compiler looks at a very small block of instructions and tries to determine how it
can improve the efficiency of this local code block

 Relatively easy; included as part of most compilers

Examples of possible local optimizations

1. Constant evaluation

2. Strength reduction

3. Eliminating unnecessary operations

Global Optimization

The compiler looks at large segments of the program to decide how to improve
performance
Much more difficult; usually omitted from all but the most sophisticated and
expensive production- level “optimizing compilers”
Optimization cannot make an inefficient algorithm efficient
 Compiler construction tools

 Modern software development environments containing tools such as language editors,

debuggers, version managers, profilers, test harnesses, and so on.

 More specialized tools have been created to help implement various phases of a compiler.

Some commonly used compiler-construction tools include

 Parser generators:- that automatically produce syntax analyzers from a grammatical

description of a programming language.

 Compiler-construction toolkits:- that provide an integrated set of routines for

constructing various phases of a compiler.
 Cont.…
 Scanner generators:- that produce lexical analyzers from a regular-expression
description of the tokens of a language.
 Syntax-directed translation engines:- that produce collections of routines for
walking a parse tree and generating intermediate code.
 Code-generator:- that produce a code generator from a collection of rules for
translating each operation of the intermediate language into the machine language for
a target machine.
 Data-flow analysis engines: that facilitate the gathering of information about how
values are transmitted from one part of a program to each other part. Data-flow
analysis is a key part of code optimization.