This document provides an introduction to compilers, including definitions of key terms like source code, target code, and compiler phases. It describes the main stages in compilation: scanning, parsing, semantic analysis, intermediate code generation, code optimization, and code generation. It also discusses important data structures like symbol tables, literal tables, and parse trees. Finally, it reviews the history of compilers from the 1930s to the 1970s and development of technologies like assemblers, recursive descent parsing, and LR parsing.

1. Chapter 1 2301373: Introduction 1
Introduction

2. Chapter 1 2301373: Introduction 2
What is a Compiler?
• A compiler is a computer
program that translates a
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 in the
target language, which often is
a machine language or an
intermediate code.
compiler
Source
program
Target
program
Error
message

3. Chapter 1 2301373: Introduction 3
Process of Compiling
scanner
parser
Semantic analyzer
Intermediate code generator
Code optimization
Code generator
Code optimization
Stream of characters
Stream of tokens
Parse/syntax tree
Annotated tree
Intermediate code
Intermediate code
Target code
Target code

4. Chapter 1 2301373: Introduction 4
Some Data Structures
• Symbol table
• Literal table
• Parse tree

5. Chapter 1 2301373: Introduction 5
Symbol Table
• Identifiers are names of variables,
constants, functions, data types, etc.
• Store information associated with identifiers
– Information associated with different types of
identifiers can be different
• Information associated with variables are name, type,
address,size (for array), etc.
• Information associated with functions are name,type
of return value, parameters, address, etc.

6. Chapter 1 2301373: Introduction 6
Symbol Table (cont’d)
• Accessed in every phase of compilers
– The scanner, parser, and semantic analyzer put
names of identifiers in symbol table.
– The semantic analyzer stores more information
(e.g. data types) in the table.
– The intermediate code generator, code
optimizer and code generator use information in
symbol table to generate appropriate code.
• Mostly use hash table for efficiency.

7. Chapter 1 2301373: Introduction 7
Literal table
• Store constants and strings used in program
– reduce the memory size by reusing constants
and strings
• Can be combined with symbol table

8. Chapter 1 2301373: Introduction 8
Parse tree
• Dynamically-allocated, pointer-based
structure
• Information for different data types
related to parse trees need to be stored
somewhere.
– Nodes are variant records, storing
information for different types of data
– Nodes store pointers to information stored
in other data structure, e.g. symbol table

9. Chapter 1 2301373: Introduction 9
Scanning
• A scanner reads a stream of characters and
puts them together into some meaningful
(with respect to the source language) units
called tokens.
• It produces a stream of tokens for the next
phase of compiler.

10. Chapter 1 2301373: Introduction 10
Parsing
• 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.

11. Chapter 1 2301373: Introduction 11
Semantic analysis
• It gets the parse tree from the parser together with
information about some syntactic elements
• It determines if the semantics or meaning of the
program is correct.
• 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.
• It modifies the parse tree in order to get that
(static) semantically correct code.

12. Chapter 1 2301373: Introduction 12
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.

13. Chapter 1 2301373: Introduction 13
Intermediate code generation (cont’d)
• 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.

14. Chapter 1 2301373: Introduction 14
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

15. Chapter 1 2301373: Introduction 15
Code generation
• A code generator
– takes either an intermediate code or a parse
tree
– produces a target program.

16. Chapter 1 2301373: Introduction 16
Error Handling
• Error can be found in every phase of
compilation.
– Errors found during compilation are called static
(or compile-time) errors.
– Errors found during execution are called
dynamic (or run-time) errors
• Compilers need to detect, report, and
recover from error found in source programs
• Error handlers are different in different
phases of compiler.

17. Chapter 1 2301373: Introduction 17
• a compiler which generates target code for
a different machine from one on which the c
ompiler runs.
• A host language is a language in which the
compiler is written.
– T-diagram
• Cross compilers are used very often in
practice.
Cross Compiler
S
H
T

18. Chapter 1 2301373: Introduction 18
Cross Compilers (cont’d)
• If we want a compiler from
language A to language B on a
machine with language E,
– write one with E
– write one with D if you have a
compiler from D to E on some ma
chine
• It is better than the former approach
if D is a high-level language but E is
a machine language
– write one from G to B with E if we
have a compiler from A to G
written in E
A
E
B
D
?
E
A
D
B
G
E
BA
E
G

19. Chapter 1 2301373: Introduction 19
Porting
• Porting: construct a compiler between a
source and a target language using one
host language from another host language
A
A
K
A
H
H A
H
K
A
A
K
A
H
K A
K
K

20. Chapter 1 2301373: Introduction 20
Bootstrapping
• If we have to implement, from
scratch, a compiler from a high
-level language A to a machine,
which is also a host, language,
– direct method
– bootstrapping
A
H
H
A
A1
H
A1
A2
H
A2
A3
H
A3
H
H

21. Chapter 1 2301373: Introduction 21
Cousins of Compilers
• Linkers
• Loaders
• Interpreters
• Assemblers

22. Chapter 1 2301373: Introduction 22
History (1930’s -40’s)
• 1930’s
– John von Neumann invented the concept of
stored-program computer.
– Alan Turing defined Turing machine and
computability.
• 1940’s
– Many electro-mechanic, stored-program
computers were constructed.
• ABC (Atanasoff Berry Computer) at Iowa
• Z1-4 (by Zuse) in Germany
• ENIAC (programmed by a plug board)

23. Chapter 1 2301373: Introduction 23
History : 1950
• Many electronic, stored-program computers were
designed.
– EDVAC (by von Neumann)
– ACE (by Turing)
• Programs were written in machine languages.
• Later, programs are written in assembly languages
instead.
– Assemblers translate symbolic code and memory
address to machine code.
• John Backus developed FORTRAN (no recursive
call) and FORTRAN compiler.
• Noam Chomsky studied structure of languages
and classified them into classes called Chomsky
hierarchy.
0A 1F 83 90 4B
op code, address,..
LDI B, 4
LDI C, 3
LDI A, 0
ST: ADI A, C
DEC B
JNZ B, ST
STO 0XF0, A
Grammar

24. Chapter 1 2301373: Introduction 24
History (1960’s)
• Recursive-descent parsing was introduced.
• Nuar designed Algol60, Pascal’s ancestor,
which allows recursive call.
• Backus-Nuar form (BNF) was used to
described Algol60.
• LL(1) parsing was proposed by Lewis and
Stearns.
• General LR parsing was invented by Knuth.
• SLR parsing was developed by DeRemer.

25. Chapter 1 2301373: Introduction 25
History (1970’s)
• LALR was develpoed by DeRemer.
• Aho and Ullman founded the theory of LR
parsing techniques.
• Yacc (Yet Another Compiler Compiler) was
developed by Johnson.
• Type inference was studied by Milner.