Compiler Construction

The Context of a Compiler
• In addition to a compiler; several other
programs may be required to create an
executable target program.
• A source program may be divided into
modules stored in separate files.
• The task of collecting the source program is
sometimes entrusted to a distinct program
called a preprocessor.

The Context of a Compiler
• The target program created by compiler
may require further processing before it can
be run.
• The compiler creates assembly code that is
translated by an assembler into machine
code and then linked together with some
library routines into the code that actually
runs on the machine.

Preprocessors, Compilers,
Assemblers, and Linkers
Preprocessor
Compiler
Assembler
Linker
Skeletal Source Program
Source Program
Target Assembly Program
Relocatable Object Code
Absolute Machine Code
Libraries and
Relocatable Object Files
5

Analysis of the source program
Linear analysis:
• In which the stream of characters making
up the source program is read from left to
right and grouped into tokens that are
sequences of characters having a collective
meaning.
• In compiler, linear analysis is also called
LEXICAL ANALYSIS or SCANNING

Hierarchical Analysis:
• In which characters or tokens are grouped
hierarchically into nested collections with
collective meaning.
• In compiler, hierarchical analysis is called
parsing or syntax analysis.

Semantic analysis:
• In which certain checks are performed to
ensure that the components of a program fit
together meaningfully.

Semantic Analysis – Complications
• Handling ambiguity
– Semantic ambiguity: “I saw the Habib Bank Plaza
flying into Karachi”

Lexical Analysis
• For example in lexical analysis the characters in the
assignment statement
position := initial + rate * 60
would be grouped into the following tokens.
1. The identifier position
2. The assignment symbol :=
3. The identifier initial
4. The plus + sign
5. The identifier rate
6. The multiplication sign *
7. The number 60

Syntax Analysis
• It involves grouping the tokens of the
source program into grammatical phrases
that are tied by the compiler to synthesize
output.
• Usually the grammatical phrases of the
source program are represented by a parse
tree.

Parse tree
:=
identifier
identifier
identifier
+
*
60
Assignment
statement
position : = initial + rate * 60
position
expression
expression
expression
expression
initial
expression
rate
number

Parse tree tokens
• In expression position: = initial + rate * 60
the phrase rate * 60 is a logical unit.
• As multiplication is performed before addition.
• The expression initial + rate is followed by a *, it
is not grouped into a single phrase by itself.

Rules to identify an expression
Rule 1. Any identifier is an expression
Rule 2. Any number is an expression
Rule 3. If expression1 and expression2 are
expressions, then so are
expression1 + expression2
expression1 * expression2

Explanation of rules
• Rule (1) and (2) are (non-recursive) basic rules,
while (3) defines expression in terms of operators
applied to other expressions.
• By Rule (1), initial and rate are expressions
• By Rule (2), 60 is an expression
• By Rule (3), we can first infer that rate*60 is an
expression & finally that initial + rate * 60 is an
expression

Rule to identify a statement
• If identifier1 is an identifier, and expression2
is an expression then
identifier1 : = expression2
is a statement

Context free grammar
• Lexical constructs do not require recursion,
while syntactic constructs often do.
• Context free grammars are a
formalization of recursive rules that can be
used to guide syntactic analysis.

Context free grammar
• For example recursion is not required to recognize
identifiers, which are typically strings of letters and digits
beginning with a letter.
• We would normally recognize identifiers by a simple scan
of the input stream, waiting until a character that was
neither a letter nor a digit was found
• And then grouping all the letters and digits found up to
that point into an identifier token.
• The characters so grouped are recorded in a table called a
symbol table, and remove from the input so that
processing of the next token can begin.

Phases of Compiler
Syntax Analyzer
Lexical Analyzer
Semantic Analyzer
Intermediate code generator
Code optimizer
Code generator
Target Program
Source Program
Symbol table
Manger
Error Handler

Symbol table Management
• An essential function of a compiler is to
record the identifiers used in the source
program and collect information about
various attributes of each identifier.
• These attributes may provide information
about the storage allocated for an identifier,
its type, its scope (where in the program it is
valid) etc

Symbol table
• A symbol table is a data structure containing a
record for each identifier, with fields for the
attributes of the identifier.
• The data structure allow us to find the record for
each identifier quickly and to store or retrieve data
from that record quickly.
• When an identifier in the source program is
detected by the lexical analyzer, the identifier is
entered into the symbol table.

Error detection and Reporting
• Each phase can encounter errors.
• After detecting an error, a phase must
somehow deal with that error, so that
compilation can proceed, allowing further
errors in the source program to be detected.
• A compiler that stops when it finds the first
error is not as helpful as it could be.

• The syntax and semantic analysis phases usually
handle a large fraction of the errors detectable by
the compiler.
• The lexical phase can detect errors where the
characters remaining in the input do not form any
token of the language.
• Errors where the token stream violates the
structure rules (Syntax) of the language are
determined by the syntax analysis phase.

• During semantic analysis the compiler tries
to detect constructs that have the right
syntactic structure but no meaning to the
operation involved.
• For example if we try to add two identifiers,
one of which is the name of an array and
the other the name of a procedure.

The Analysis Phase
position : = initial + rate * 60
• The lexical analysis phase reads the characters in
the source program and groups them into a stream
of tokens in which each token represents a
logically cohesive sequence of characters, such as
an identifier, a keyword (if, while etc), a
punctuation character or a multi-character operator
like :=
• The character sequence forming a token called the
lexeme for the token.

The Analysis Phase (Cont..)
• Certain tokens will be augmented by a
“lexical value”.
• For example when an identifier like rate is
found, the lexical analyzer not only
generates token, say id, but also enters the
lexeme rate into the symbol table, if it is not
already there.

Intermediate code generation
• After syntax and semantic analysis, some
compilers generate an explicit intermediate
representation of the source program.
• This intermediate representation has two
important properties;
– It should be easy to produce
– Easy to translate into the target machine

• The intermediate representation can have a
variety of forms.
• It may called as “three address code”,
which is like the assembly language for a
machine in which every memory location
can act like a register.

• Three address code consists of a sequence of
instructions, each of which has at most three
operands.
• The source program might appear in three address
code as
temp1 := inttoreal (60)
temp2 := id3 * temp1
temp3 := id2 + temp2
id1 := temp3

:=
+
*
id 1
id 2
id 3
nu

• The intermediate form has several
properties.
• First each three address instruction has at
most one operator in addition to the
assignment.
• Thus when generating these instructions,
the compiler has to decide on the order in
which operations are to be done.

• In our example the multiplication precedes the
addition in the source program.
• Second the compiler must generate a temporary
name to hold the value computed by each
instruction.
• Third, some “three address” instructions have
fewer than three operands for example the first
and last instruction in our example.

Code Optimization
• The code optimization
phase attempts to
improve the
intermediate code, so
the faster running
machine code will
result.

Code Optimization
temp1 := id3 * 60.0
Id1 := id2 + temp1
• There is nothing wrong with this simple algorithm; since the problem
can be fixed during the code optimization phase.
• The compiler can deduced that the conversion of 60 from integer to
real representation can be done once and for all at compile time; so the
inttoreal operation can be eliminated.
• Besides temp3 is used only once, to transmit its value to id1.
• It then becomes safe to substitute id1 for temp3, whereupon the last
statement of intermediate code is not needed and the optimized code
results.

Code Optimization
• There is a great variation in the amount of
code optimization different compiler
performs.
• In those that do the most, called “optimizing
compilers”
• A significant fraction of the time of the
compiler is spent on this phase

Code generation
• The final phase of the compiler
is the generation of target code,
consisting normally of
relocatable machine code or
assembly code.
• Memory locations are selected
for each of the variables used
by the program.
• Intermediate instructions are
each translated into a sequence
of machine instructions that
perform the same task.
• A crucial aspect is the
assignment of variable to
register.

Code generation
• The first and second
operands of each
instruction specify a
source and destination
respectively.
• The F in each
instruction tells us that
instructions deal with
floating point numbers

Code optimization & Code
generation

Compiler Construction

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Compiler Construction

Similar to Compiler Construction (20)

More from Sarmad Ali

More from Sarmad Ali (12)

Recently uploaded

Recently uploaded (20)

Compiler Construction