What are Compilers?

• Translates from one representation of the program to

another

• Typically from high level source code to low level

machine code or object code

• Source code is normally optimized for human readability

– Expressive: matches our notion of languages (and
application?!)
– Redundant to help avoid programming errors

• Machine code is optimized for hardware

– Redundancy is reduced
– Information about the intent is lost
1
High level Low level
Compiler code
program

Compiler as a Translator

2
 Goals of translation
• Good compile time performance
• Good performance for the
generated code
• Correctness
– A very important issue.
–Can compilers be proven to be
correct?
• Tedious even for toy compilers!
Undecidable in general.
–However, the correctness has an
implication on the development cost
3
 How to translate?
• Direct translation is difficult. Why?

• Source code and machine code mismatch in

level of abstraction
– Variables vs Memory locations/registers
– Functions vs jump/return
– Parameter passing
– structs
• Some languages are farther from machine
code than others
– For example, languages supporting Object
Oriented Paradigm
4
 How to translate easily?
• Translate in steps. Each step handles a
reasonably simple, logical, and well defined
task
• Design a series of program representations
• Intermediate representations should be
amenable to program manipulation of
various kinds (type checking, optimization,
code generation etc.)
• Representations become more machine
specific and less language specific as the
translation proceeds 5
 The first few steps
• The first few steps can be understood
by analogies to how humans
comprehend a natural language
• The first step is recognizing/knowing
alphabets of a language. For example
– English text consists of lower and upper
case alphabets, digits, punctuations and
white spaces
– Written programs consist of characters
from the ASCII characters set (normally
9-13, 32-126)
6
 The first few steps
• The next step to understand the sentence
is recognizing words
– How to recognize English words?
– Words found in standard dictionaries
– Dictionaries are updated regularly

7
 The first few steps
• How to recognize words in a
programming language?
– a dictionary (of keywords etc.)
– rules for constructing words (identifiers,
numbers etc.)
• This is called lexical analysis
• Recognizing words is not completely
trivial. For example:
w hat ist his se nte nce?

8
 Lexical Analysis: Challenges
• We must know what the word
separators are

• The language must define rules for

breaking a sentence into a sequence of
words.

• Normally white spaces and

punctuations are word separators in
languages.

9
 Lexical Analysis: Challenges
• In programming languages a character
from a different class may also be
treated as word separator.

• The lexical analyzer breaks a sentence

into a sequence of words or tokens:
– If a == b then a = 1 ; else a = 2 ;
– Sequence of words (total 14 words)
if a == b then a = 1 ; else a =
2 ;

10
 The next step
• Once the words are understood, the next
step is to understand the structure of the
sentence

• The process is known as syntax checking or

parsing
I am going to play

pronoun aux verb adverb

subject verb adverb-phrase

Sentence
11
 Parsing
• Parsing a program is exactly the same
process as shown in previous slide.
• Consider an expression
if x == y then z = 1 else z = 2

if stmt

predicate then-stmt else-stmt

== = =

x y z 1 z 2

12
 Understanding the meaning
• Once the sentence structure is
understood we try to understand the
meaning of the sentence (semantic
analysis)
• A challenging task
• Example:
Prateek said Nitin left his assignment at
home
• What does his refer to? Prateek or Nitin?

13
 Understanding the meaning
• Worse case
Amit said Amit left his assignment at
home
• Even worse
Amit said Amit left Amit’s assignment
at home
• How many Amits are there? Which
one left the assignment? Whose
assignment got left?
14
 Semantic Analysis
• Too hard for compilers. They do not have
capabilities similar to human understanding
• However, compilers do perform analysis to
understand the meaning and catch
inconsistencies
• Programming languages define strict rules to
avoid such ambiguities
{ int Amit = 3;
{ int Amit = 4;
cout << Amit;
}
}

15
 More on Semantic Analysis
• Compilers perform many other checks
besides variable bindings
• Type checking
Amit left her work at home
• There is a type mismatch between her
and Amit. Presumably Amit is a male.
And they are not the same person.

16
 Example from Mahabharat

अश्वथामा हत: इतत नरो वा कुञ्जरो वा

“Ashwathama hathaha iti,
narova kunjarova”

Ashwathama is dead. But, I am not certain

whether it was a human or an elephant
 Compiler structure once again

Compiler
Lexical Syntax Semantic
Analysis Analysis Analysis

Source Token Abstract Unambiguous Target

Syntax Program
Program stream
tree representation Program
Front End Back End
(Language specific)

18
 Code Optimization
• No strong counter part with
English, but is similar to
editing/précis writing

• Automatically modify programs so

that they
–Run faster
–Use less resources (memory,
registers, space, fewer fetches etc.)

23
 Code Optimization
• Some common optimizations
–Common sub-expression elimination
–Copy propagation
–Dead code elimination
–Code motion
–Strength reduction
–Constant folding

• Example: x = 15 * 3 is transformed
to x = 45
24
 Example of Optimizations
A : assignment M : multiplication D : division E : exponent

PI = 3.14159
Area = 4 * PI * R^2
Volume = (4/3) * PI * R^3 3A+4M+1D+2E
--------------------------------
X = 3.14159 * R * R
Area = 4 * X
Volume = 1.33 * X * R 3A+5M
--------------------------------
Area = 4 * 3.14159 * R * R
Volume = ( Area / 3 ) * R 2A+4M+1D
--------------------------------
Area = 12.56636 * R * R
Volume = ( Area /3 ) * R 2A+3M+1D
--------------------------------
X=R*R
Area = 12.56636 * X
Volume = 4.18879 * X * R 3A+4M
25
 Code Generation
• Usually a two step process
– Generate intermediate code from the
semantic representation of the program
– Generate machine code from the
intermediate code

• The advantage is that each phase is

simple

• Requires design of intermediate

language
26
 Code Generation
• Most compilers perform translation
between successive intermediate
representations

• Intermediate languages are generally

ordered in decreasing level of abstraction
from highest (source) to lowest (machine)

27
 Code Generation
• Abstractions at the source level
identifiers, operators, expressions, statements,
conditionals, iteration, functions (user defined,
system defined or libraries)

• Abstraction at the target level

memory locations, registers, stack, opcodes,
addressing modes, system libraries, interface to
the operating systems

• Code generation is mapping from source level

abstractions to target machine abstractions
28
 Code Generation
• Map identifiers to locations
(memory/storage allocation)
• Explicate variable accesses (change
identifier reference to
relocatable/absolute address
• Map source operators to opcodes
or a sequence of opcodes

29
 Code Generation

• Convert conditionals and iterations to a

test/jump or compare instructions
• Layout parameter passing protocols:
locations for parameters, return values,
layout of activations frame etc.
• Interface calls to library, runtime system,
operating systems

30
 Post translation Optimizations

• Algebraic transformations and

reordering
– Remove/simplify operations like
• Multiplication by 1
• Multiplication by 0
• Addition with 0

– Reorder instructions based on

• Commutative properties of operators
• For example x+y is same as y+x (always?)
31
 Post translation Optimizations

Instruction selection
– Addressing mode selection
– Opcode selection
– Peephole optimization

32
 if
boolean
== = int ;

int b 0 a b
int int int

Intermediate code generation

Optimization Code Generation

CMP Cx, 0
CMOVZ Dx,Cx
33
 Compiler structure

Compiler
Lexical Syntax Semantic IL code
Code
Optimizer generator
Analysis Analysis Analysis generator
Optimized
code
Source Abstract Unambiguous Target
Token Syntax IL
Program Program Program
stream tree representation code

Front End Optional Back End

(Language specific) Phase Machine specific

34
 Something is missing
• Information required about the program variables during
compilation
– Class of variable: keyword, identifier etc.
– Type of variable: integer, float, array, function etc.
– Amount of storage required
– Address in the memory
– Scope information
• Location to store this information
– Attributes with the variable (has obvious problems)
– At a central repository and every phase refers to the repository
whenever information is required
• Normally the second approach is preferred
– Use a data structure called symbol table

35
 Final Compiler structure

Symbol Table

Compiler
Lexical Syntax Semantic IL code
Code
Optimizer generator
Analysis Analysis Analysis generator
Optimized
code
Source Abstract Unambiguous Target
Token Syntax IL
Program Program Program
stream tree representation code

Front End Optional Back End

(Language specific) Phase Machine specific
36
 Advantages of the model
• Also known as Analysis-Synthesis model of
compilation
– Front end phases are known as analysis phases
– Back end phases are known as synthesis phases

• Each phase has a well defined work

• Each phase handles a logical activity in the

process of compilation

37
 Advantages of the model …
• Compiler is re-targetable

• Source and machine independent code optimization

is possible.

• Optimization phase can be inserted after the front

and back end phases have been developed and
deployed

38
 Issues in Compiler Design
• Compilation appears to be very simple, but there are
many pitfalls

• How are erroneous programs handled?

• Design of programming languages has a big impact on the

complexity of the compiler

• M*N vs. M+N problem

– Compilers are required for all the languages and all the machines
– For M languages and N machines we need to develop M*N
compilers
– However, there is lot of repetition of work because of similar
activities in the front ends and back ends
– Can we design only M front ends and N back ends, and some how
link them to get all M*N compilers?

39
 M*N vs M+N Problem
Intermediate Language

F1 B1 F1 B1

F2 B2 F2 B2

IL
F3 B3 F3 B3

FM BN FM BN

Requires M*N compilers Requires M front ends

And N back ends

40
 Universal Intermediate Language

• Impossible to design a single intermediate

language to accommodate all programming
languages
– Mythical universal intermediate language sought since
mid 1950s (Aho, Sethi, Ullman)
• However, common IRs for similar languages, and
similar machines have been designed, and are
used for compiler development

41
 How do we know compilers generate
correct code?

• Prove that the compiler is correct.

• However, program proving techniques do

not exist at a level where large and complex
programs like compilers can be proven to
be correct

• In practice do a systematic testing to

increase confidence level
42
• Regression testing
– Maintain a suite of test programs
– Expected behavior of each program is
documented
– All the test programs are compiled using the
compiler and deviations are reported to the
compiler writer

• Design of test suite

– Test programs should exercise every statement
of the compiler at least once
– Usually requires great ingenuity to design such
a test suite
– Exhaustive test suites have been constructed
for some languages
43
 How to reduce development and testing
effort?
• DO NOT WRITE COMPILERS

• GENERATE compilers

• A compiler generator should be able to “generate”

compiler from the source language and target machine
specifications
Source Language
Specification
Compiler Compiler
Target Machine Generator
Specification

44
 Tool based Compiler Development

Source Target
Lexical Parser Semantic IL code Code
Program Analyzer Optimizer generator generator Program
Analyzer

Generator

Generator
Generator

generator
Analyzer

Parser
Lexical

Other phase

Code
Generators

Lexeme Parser
Phase Machine
specs specs
Specifications specifications

45
 Bootstrapping
• Compiler is a complex program and should not be
written in assembly language
• How to write compiler for a language in the same
language (first time!)?
• First time this experiment was done for Lisp
• Initially, Lisp was used as a notation for writing
functions.
• Functions were then hand translated into
assembly language and executed
• McCarthy wrote a function eval[e] in Lisp that
took a Lisp expression e as an argument
• The function was later hand translated and it
became an interpreter for Lisp

46
 Bootstrap

Image By: No machine-readable author provided. Tarquin~commonswiki assumed

(based on copyright claims). - No machine-readable source provided. Own work
assumed (based on copyright claims)., CC BY-SA 3.0,
https://commons.wikimedia.org/w/index.php?curid=105468
 Bootstrapping: Example
• Lets solve a simpler problem first
• Existing architecture and C
compiler:
–gcc-x86 compiles C language to x86
• New architecture:
–x335
• How to develop cc-x335?
– runs on x335, generates code for x335

48
 Bootstrapping: Example
• How to develop cc-x335?
• Write a C compiler in C that
emits x335 code
• Compile using gcc-x86 on x86
machine
• We have a C compiler that
emits x335 code
–But runs on x86, not x355 
49
 Bootstrapping: Example
• We have cc-x86-x335
• Compiler runs on x86, generated code runs
on x355
• Compile the source code of C compiler
with cc-x86-x335
• There it is
• the output is a binary that runs on x335
• this binary is the desired compiler :
cc-x335
 Bootstrapping …
• A compiler can be characterized by three languages: the
source language (S), the target language (T), and the
implementation language (I)

• The three language S, I, and T can be quite different. Such

a compiler is called cross-compiler

• This is represented by a T-diagram as:

S T
I

• In textual form this can be represented as

SIT
51
• Write a cross compiler for a language L in
implementation language S to generate code for
machine N
• Existing compiler for S runs on a different
machine M and generates code for M
• When Compiler LSN is run through SMM we get
compiler LMN

L N L N
S S M M
M EQN TROFF EQN TROFF

C C PDP11 PDP11

PDP11
52
 Bootstrapping a Compiler
• Suppose LNN is to be developed on a machine M where
LMM is available

L N L N
L L M M
M

• Compile LLN second time using the generated compiler

L N L N
L L N N
M

53
 Bootstrapping a Compiler:
the Complete picture

L N L N

L N L L N N

L L M M

54
 Compilers of the 21st Century
• Overall structure of almost all the compilers is similar to
the structure we have discussed

• The proportions of the effort have changed since the early

days of compilation

• Earlier front end phases were the most complex and

expensive parts.

• Today back end phases and optimization dominate all

other phases. Front end phases are typically a smaller
fraction of the total time

55