1. Introduction to Compiler Construction

2. Objectives
Know how to build a compiler for a (simplified) (programming) language
Know how to use compiler construction tools, such as generators for scanners and parsers
Be familiar with virtual machines, such as the JVM and Java bytecode
Be able to write LL(1), LR(1), and LALR(1) grammars (for new languages)
Be familiar with compiler analysis and optimization techniques
… learn how to work on a larger software project!

3. Compilers and Interpreters
“Compilation”
Translation of a program written in a source language into a semantically equivalent program written in a target language
Input
Compiler
Target
Program
Source
Program
Error messages
Output

4. Compilers and Interpreters (cont’d)
“Interpretation”
Performing the operations implied by the source program
Source
Program
Interpreter
Output
Input
Error messages

5. Compiler
A compiler is a program that reads the program written in one language (Source Language) and translate its into an equivalent program in another language (the target language) . As an important part of this translation process, the compiler reports to its users the presence of errors in in the source program.

6. Source Program
Target Program
Compiler
Error Message

7. Some kind of analysis which performed by software
1) structure editor: takes input as an instruction and build source program, modification, analyses the program text, putting an appropriate hierarchal structure, check input format.
2) Pretty Printer: analyze a program and check format, like comment and instruction;

8. 3)Static Checker: attempts to discover potential bugs without running the program. it can catch logical error.
4) Interpreter: instead of producing a target program as a translation, it performs operation implied by the source program.

9. A language-processing system
Skeletal Source program
processor
Source program
compiler
Target Assembly program
assembler
Relocated machine code
Loader/ link editor
Library relocated object files
Absolute machine code

10. The Analysis-Synthesis Model of Compilation
There are two parts to compilation:
Analysis determines the operations implied by the source program which are recorded in a tree structure
Synthesis takes the tree structure and translates the operations therein into the target program

11. Analysis of source program
Linear Analysis: in which a source program is read from left to write and grouped into tokens that are sequences of characters having a collective meaning.
Hierarchical Analysis. In which characters or tokens are grouped hierarchically into nested collections with collective meanings.
Semantic Analysis: in which certain checks are performed to ensure that the components of the program fit together meaning fully.

12. Intermediate code generator
Phases of compiler
Source program
Lexical Analyzer
Syntax Analyzer
semantic Analyzer
Error handler
Symbol table manager
Intermediate code generator
Code optimizer
code generator
target program

13. The Phases of a Compiler
Output
Sample
Programmer
Source string
A=B+C;
Scanner (performs lexical analysis)
Token string
‘A’, ‘=’, ‘B’, ‘+’, ‘C’, ‘;’ And symbol table for identifiers
Parser (performs syntax analysis based on the grammar of the programming language)
Parse tree or abstract syntax tree
; | = / \ A / \ B C
Semantic analyzer (type checking, etc)
Intermediate code generator
Three-address code, quads, or RTL
int2fp B t t1 C t2 := t A
Optimizer
int2fp B t t1 #2.3 A
Code generator
Assembly code
MOVF #2.3,r1 ADDF2 r1,r2 MOVF r2,A
Peephole optimizer
ADDF2 #2.3,r2 MOVF r2,A

14. The Grouping of Phases Compiler front and back ends: Passes
Analysis (machine independent front end)
Synthesis (machine dependent back end)
Passes
A collection of phases may be repeated only once (single pass) or multiple times (multi pass)
Single pass: usually requires everything to be defined before being used in source program
Multi pass: compiler may have to keep entire program representation in memory

15. Compiler-Construction Tools
Software development tools are available to implement one or more compiler phases
Scanner generators
Parser generators
Syntax-directed translation engines
Automatic code generators
Data-flow engines

16. Outline Ch. 1: Introduction
Ch. 2: A simple One-Pass Compiler for the JVM
Ch. 3: Lexical Analysis and Lex/Flex
Ch. 4: Syntax Analysis and Yacc/Bison
Ch. 5: Syntax-Directed Translation
Ch. 6: Type Checking
Ch. 7: Run-Time Environments
Ch. 8: Intermediate Code Generation
Ch. 9: Code Generation
Ch.10: Code Optimization