Mekelle University

Ethiopian institute of technology(EiTM)

School of computing

Principles of compiler design

SENG2042
Million G/her 1
Outline
 Introduction
 Cousins of compiler (Programs related to compiler)
 The translation process
 Analysis
• Lexical analysis
• Syntax analysis
• Semantic analysis
 Synthesis
• IC generator
• IC optimizer
• Code generator
• Code optimizer
• Phases of compiler
• Major data and structures in a compiler
• Compiler construction tools
2
Introduction
What is a compiler?
 a program that reads a program written in one language (the
source language) and translates it into an equivalent
program in another language (the target language).
 Why we design compiler?
 Why we study compiler construction techniques?
• Compilers provide an essential interface between
applications and architectures
• Compilers embody a wide range of theoretical techniques
Source
program
High level
Compiler
Target program
language Error messages Assembly or machine
language
Target program
Input
exe Output
3
Introduction…
 Using a high-level language for programming has a large
impact on how fast programs can be developed.

 The main reasons for this are:

 Compared to machine language, the notation used by
programming languages is closer to the way humans think
about problems.
 The compiler can spot some obvious programming
mistakes.
 Programs written in a high-level language tend to be
shorter than equivalent programs written in machine
language.
 The same program can be compiled to many different
machine languages and, hence, be brought to run on
many different machines.
4
Introduction…
 Since different platforms, or hardware architectures
along with the operating systems (Windows, Macs, Unix),
require different machine code, you must compile most
programs separately for each platform.
program

compiler compiler

compiler

Unix
Win
Mac

5
Phases of a compiler
 A compiler operates in phases, each of
them transform the source program from
one representation to another.
 In practice some of the phases may be
grouped.

6
3-7
 cousins of a compiler
 Pre-processors
 A pre-processor is a separate program that is called by the
compiler before actual translation begins.
 Such a pre-processor:
• Produce input to a compiler
• can delete comments,
• Macro processing (substitutions) :allow user to add short
hands for longer constructs.
• include other files: the preprocessor may include header
files.

8
 Programs related to compilers…
 Interpreter
 Is a program that reads a source program and executes it
 Works by analyzing and executing the source program commands
one at a time
 Does not translate the whole source program into object code

 Interpreter…
 Well-known examples of interpreters:
 Basic interpreter, Lisp interpreter, UNIX shell command interpreter,
SQL interpreter, java interpreter…
 In principle, any programming language can be either
interpreted or compiled:
 Some languages are designed to be interpreted, others are designed
to be compiled

9
E.g., Compiling Java Programs
 The Java compiler produces bytecode not machine code
 Bytecode is converted into machine code using a Java
Interpreter
 You can run bytecode on any computer that has a Java
Interpreter installed

Win

ter
e
r pr
te
Java Program Java bytecode In
Mac
compiler Interpreter

Inte
rpre
ter
Unix

10
Programs related to compiler…
 Assemblers
 Translator for the assembly language.
 Assembly code is translated into machine code
 Output is relocatable machine code.
 Linker
 Links object files separately compiled or
assembled
 Links object files to standard library functions
 Generates a file that can be loaded and executed

11
Programs related to compiler…
 Loader
 Loading of the executable codes, which are the outputs
of linker, into main memory.

12
Programs related to compiler
C or C++ program

Preprocessor

C or C++ program with

macro substitutions and
file inclusions
Compiler

Assembly code
Assembler

Relocatable object
module
Other relocatable Linker
object modules or
library modules Executable code
Loader
Absolute machine code
13
The translation process
 A compiler consists of internally of a number of steps,
or phases, that perform distinct logical operations.

 There are two important parts in compilation process:

 Analysis and
 Synthesis.

14
The translation process…
Source code
Intermediate code
Literal Scanner generator
table
Intermediate
Tokens code
Symbol Intermediate code
table Parser optimizer

Intermediate
Syntax tree code
Error Target code
handler generator
Semantic
analyzer Target
code
Target code
Annotated optimizer
tree
Target
code
15
Analysis and Synthesis
 Analysis (front end)
 Breaks up the source program into constituent pieces and
 Creates an intermediate representation of the source
program.
 During analysis, the operations implied by the source
program are determined and recorded in hierarchical
structure called a tree.
 Synthesis (back end)
 The synthesis part constructs the desired program from the
intermediate representation.

16
Analysis of the source program

 Analysis consists of three phases:

 Linear/Lexical analysis
 Hierarchical/Syntax analysis
 Semantic analysis

17
1. Lexical analysis or Scanning
 The stream of characters making up the source program is
read from left to right and is grouped into tokens.
 A token is a sequence of characters having a collective
meaning.
 A lexical analyzer, also called a lexer or a scanner,
receives a stream of characters from the source program and
groups them into tokens.
 Examples: Source Lexical Streams of
program analyzer tokens
• Identifiers
• Keywords
• Symbols (+, -, …)
• Numbers …
 Blanks, new lines, tabulation marks will be removed during
lexical analysis.

18
Lexical analysis or Scanning…
 Example
position = initial + rate * 60
position identifier
= assignment operator
initial identifier
+ plus operator
rate identifier
* multiplication operator
60 number

 A scanner may perform other operations along with the

recognition of tokens.
• It may enter identifiers into the symbol table, and
• It may enter literals into literal table.
19
Lexical Analysis Tools

The lexical analyzer takes the source program an

produces:

20
2. Syntax analysis or Parsing

 The parser receives the source code in the form of tokens

from the scanner and performs syntax analysis.
 The results of syntax analysis are usually represented by a
parse tree or a syntax tree.
 Syntax tree  each interior node represents an operation
and the children of the node represent the arguments of the
operation.
 The syntactic structure of a programming language is
determined by context free grammar (CFG).

Stream of Syntax Abstract

tokens analyzer syntax tree

21
Syntax analysis or Parsing…
 Ex. Consider again the line of C code: position = initial + rate * 60
 Syntax analyzer produces:

22
 3. Semantic analysis
 The semantics of a program are its meaning as opposed
to syntax or structure
 The semantics consist of:
 Runtime semantics – behavior of program at runtime
 Static semantics – checked by the compiler
 Static semantics include:
 Declarations of variables and constants before use
 Calling functions that exist (predefined in a library or defined by
the user)
 Passing parameters properly
 Type checking.

 The semantic analyzer does the following:

 Checks the static semantics of the language
 Annotates the syntax tree with type information
23
Semantic analysis
 Produces abstract syntax tree.
 Assume we are working with floating point
numbers. So in this phase the number 60
should be converted to float.

3-24
Synthesis of the target program

 Intermediate code generator

 Intermediate code optimizer
 The target code generator
 The target code optimizer

25
 Code Improvement
 Code improvement techniques can be applied to:
 Intermediate code – independent of the target machine
 Target code – dependent on the target machine

 Intermediate code improvement include:

 Constant folding
 Elimination of common sub-expressions
 Improving loops
 Improving function calls
 Target code improvement include:
 Allocation and use of registers
 Selection of better (faster) instructions and addressing
modes

26
Intermediate code generator
 Comes after syntax and semantic analysis
 Separates the compiler front end from its backend
 Intermediate representation should have 2 important
properties:
 Should be easy to produce
 Should be easy to translate into the target program
 Intermediate representation can have a variety of forms:
 Three-address code, P-code for an abstract machine, Tree or
DAG representation

Intermediate code
Abstract syntax Intermediate code
generator

 The IC for the original C expression position = initial + rate * 60 is:

t1=inttofloat(60)
t2 = id3 * t1
t3 =id2+t2 27
IC optimizer
 An IC optimizer reviews the code, looking for ways to reduce:
 the number of operations and
 the memory requirements.
 A program may be optimized for speed or for size.
 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.

Intermediate IC Optimizer Intermediate

code code

28
IC optimizer…
 There are several techniques of optimizing
code and they will be discussed in the
forthcoming chapters.

 Ex. Unnecessary lines of code in loops (i.e.

code that could be executed outside of the
loop) are moved out of the loop.

29
IC optimizer…
 Many optimizations can be performed directly on the tree.
 However, in a number of cases, it is easier to optimize a
linearized form of the tree that is closer to assembly code.
 A standard choice is Three-address code, so called because it
contains the addresses of up to three locations in memory.
 Now the optimizer would improve this code in two steps, first
computing the result of the addition
 position = initial + rate * 60;
t1=id3*60.0
id1 = id2+t1

30
Code generator
 The machine code generator receives the (optimized) intermediate
code, and then it produces either:
 Machine code for a specific machine, or
 Assembly code for a specific machine and assembler.
 Code generator
 Selects appropriate machine instructions
 Allocates memory locations for variables
 Allocates registers for intermediate computations

31
Code generator…
 The code generator takes the IR code and generates code for the
target machine.
 Here we will write target code in assembly language:
position = initial + rate * 60;

LDF R2, id3 ;; load value of id3 to register -> R2

MULF R2, R2, #60.0 ;;multiply the content of R2 by 60.0
LDF R1, id2 ;; load value of id2 in ->R1
ADD R1, R1,R2 ;; add R2 to R1
STF id1, R1 ;; store the content of R1 to id1

32
The target code optimizer
 In this phase, the compiler attempts to improve the
target code generated by the code generator.
 Such improvement includes:
• Choosing addressing modes to improve performance
• Replacing slow instruction by faster ones
• Eliminating redundant or unnecessary operations

33
Grouping of phases
 The discussion of phases deals with the logical organization of a
compiler.
 In practice most compilers are divided into:
 Front end - language-specific and machine-independent.
 Back end - machine-specific and language-independent.

Compiler passes:
 A pass consists of reading an input file and writing an output file.
 Several phases may be grouped in one pass.
 For example, the front-end phases of lexical analysis, syntax
analysis, semantic analysis, and intermediate code generation
might be grouped together into one pass.

34
Grouping of phases…
 Single pass
 is a compiler that passes through the source code of
each compilation unit only once.
 a one-pass compiler does not "look back" at code it
previously processed.
 A one-pass compilers is faster than multi-pass
compilers
 they are unable to generate as efficient programs, due
to the limited scope available.
 Multi pass
 is a type of compiler that processes the source code or
abstract syntax tree of a program several times.
 A collection of phases is done multiple times

35
Major Data and Structures in a Compiler
 Token
 Represented by an integer value or an enumeration
literal
 Sometimes, it is necessary to preserve the string of
characters that was scanned
 For example, name of an identifiers or value of a
literal
 Syntax Tree
 Constructed as a pointer-based structure

 Dynamically allocated as parsing proceeds

 Nodes have fields containing information collected
by the parser and semantic analyzer
36
Major Data and Structures in a Compiler…

 Symbol Table
 Keeps information associated with all kinds of tokens:

• Identifiers, numbers, variables, functions, parameters, types, fields, etc.

 Tokens are entered by the scanner and parser

 Semantic analyzer adds type information and other attributes

 Code generation and optimization phases use the information
in the symbol table
Performance Issues
 Insertion, deletion, and search operations need to be efficient
because they are frequent
 More than one symbol table may be used

37
Major Data and Structures in a Compiler…
 Literal Table
 Stores constant values and string literals in a
program.
 One literal table applies globally to the entire
program.
 Used by the code generator to:
• Assign addresses for literals.
 Avoids the replication of constants and strings.
 Quick insertion and lookup are essential.

38
Compiler construction tools
 Scanner generators
 Tools available to assist writing of lexical analyzers.
 lex - produces C source code (UNIX/linux).
 flex - produces C source code (gnu).
 JLex - produces Java source code
 These tools generate a scanner /lexical analyzer/
if given a regular expression.
 Parser Generators
 Ex. Yacc, Bison, CUP
 These tools produce a parser /syntax analyzer/ if
given a Context Free Grammar (CFG).

39
Compiler construction tools…
 Syntax directed translation engines
 Ex. Cornell Synthesizer Generator
 It produces a collection of routines that walk
the parse tree and execute some tasks.
 Automatic code generators
 Take a collection of rules that define the
translation of the IC to target code and
produce a code generator.
 This completes our brief description of the
phases of compiler.

40