CSE-361:Compiler Design
TA H S I N A H A S H E M
Lecturer
CSE,JU
TEXTBOOK
Compilers: Principles, Techniques, and Tools
Aho, Lam, Sethi, Ullman
Modern Compiler Implementation in C (The Tiger Book).
Andrew W. Appel
GRADING POLICY
Attendance 10%
Assignment 5%
Class Test 20% (Best two of three)
(includes exercises and lecture materials)
Surprise test 5%
(at the end or starting of lecture)
==========================================================
Total 40%
Final Exam 60%
(includes exercises and lecture materials)
LANGUAGE PROCESSOR
A computer understands instructions in machine code, i.e. in the form of 0s and 1s. It is a tedious
task to write a computer program directly in machine code.
The programs are written mostly in high level languages like Java, C++, Python etc. and are
called source code. These source code cannot be executed directly by the computer and must be
converted into machine language to be executed.
Hence, a special translator system software is used to translate the program written in high-level
language into machine code is called Language Processor and the program after translated into
machine code (object program / object code).
The language processors can be any of the following three types:
1. Compiler
2. Interpreter
3. Assembler
LANGUAGE PROCESSOR: COMPILER
A compiler is a program that reads the whole program written in a source
language/high level language as a whole in one go and translates it into an
equivalent program in a target language.
LANGUAGE PROCESSOR: INTERPRETER
An interpreter is another common kind of language processor.
Instead of producing a target program as a translation, an interpreter appears to
directly execute the operations specified in the source program on inputs
supplied by the user.
Source program
Interpreter Output
Input
Error messages
COMPILER VS. INTERPRETER
HYBRID COMPILER
Java language processors combine compilation and interpretation.
HYBRID COMPILER
A Java source program may first be compiled into an intermediate
form called bytecodes.
The bytecodes are then interpreted by a virtual machine.
A benefit of this arrangement is that bytecodes compiled
on one machine can be interpreted on another machine,
perhaps across a network.
In order to achieve faster processing of inputs to outputs,
some Java compilers, called just-in-time compilers,
translate the bytecodes into machine language
immediately before they run the intermediate program to
process the input.
LANGUAGE PROCESSOR: ASSEMBLER
The Assembler is used to translate the program written in Assembly language into
machine code. Assembly language is machine dependent yet mnemonics that are
being used to represent instructions in it are not directly understandable by
machine and high level language is machine independent.
Assembler
OTHER LANGUAGE PROCESSORS:
COMPILATION TASK IS FULL OF VARIETY
??
Thousands of source languages
• Fortran, Pascal, C, C++, Java, ……
Thousands of target languages
• Some other lower level language (assembly language), machine language
Compilation process has similar variety
• Single pass, multi-pass, load-and-go, debugging, optimizing….
Variety is overwhelming……
Good news is:
Few basic techniques is sufficient to cover all variety
Many efficient tools are available
JOB OF COMPILER
We will study compilers that take as input programs in a high-level
programming language and give as output programs in a low-level assembly
language.
Such compilers have 3 jobs:
TRANSLATION
VALIDATION
OPTIMIZATION
WHY STUDY COMPILER?
To be more effective users of compilers ... instead of treating a compiler as a
“black box”.
To apply compiler techniques to typical SE tasks that require reading input and
taking action.
To see how your core CS courses fit together, giving you the knowledge to
construct a compiler.
To participate in R&D of high-level programming languages and optimizing
compilers.
CHALLENGES OF COMPILER
CONSTRUCTION
Compiler construction poses challenging and interesting problems:
Compilers must process large inputs, perform complex algorithms, but also run quickly
Compilers have primary responsibility for run-time performance
Compilers are responsible for making it acceptable to use the full power of the
programming language
Computer architects perpetually create new challenges for the compiler by building
more complex machine
Compilers must hide that complexity from the programmer
A successful compiler requires mastery of the many complex interactions between
its constituent parts
COMPILER AND OTHER AREAS
Compiler construction involves ideas from different parts of computer science
Artificial intelligence: Greedy algorithms, Heuristic search techniques
Algorithms: Graph algorithms, Dynamic programming
Theory of Automata: DFAs & PDAs, pattern matching, regular expressions
Architecture: Pipelining and Instruction set use
REQUIREMENT
In order to translate statements in a language, one needs to understand both
• Structure of the language: the way “sentences" are constructed in the language
• Meaning of the language: what each “sentence" stands for.
Terminology:
Structure ≡ Syntax
Meaning ≡ Semantics
ANALYSIS-SYNTHESIS MODEL OF
COMPILATION
Two major parts --
Analysis: an intermediate representation is created from the given source
program.
Lexical Analyzer, Syntax Analyzer and Semantic Analyzer
Synthesis: the equivalent target program is created from this intermediate
representation
Intermediate Code Generator, Code Optimizer, and Code Generator
PHASES OF COMPILER
COMPILATION STEPS/PHASES
Lexical Analysis: Generates the “tokens” in the source program
Syntax Analysis: Recognizes “sentences" in the program using the syntax of the
language
Semantic Analysis: Infers information about the program using the semantics of the
language
Intermediate Code Generation: Generates “abstract” code based on the syntactic
structure of the program and the semantic information
Optimization: Refines the generated code using a series of optimizing transformations
Final Code Generation: Translates the abstract intermediate code into specific
machine instructions
LEXICAL ANALYSIS
Convert the stream of characters representing input program into a meaningful sequences called lexemes.
For each lexeme, the lexical analyzer produces as output
A token of the form:
< token-name, attribute-value >
token-name an abstract symbol that is used during syntax analysis
attribute-value points to an entry in the symbol table for this token
Example:
Input: “*x++" Output: three tokens “*", “x", “++"
Input: “static int" Output: two tokens: “static" , “int"
Removes the white spaces, comments
LEXICAL ANALYSIS
Input: result = a + b * 10
Tokens :
‘result’, ‘=‘, ‘a’, ‘+’, ‘b’, ‘*’, ‘10’
identifiers operators
LEXICAL ANALYSIS
Input:
Output: Sequence of tokens
• In this representation, the token names =, +, and * are abstract symbols for
the assignment, addition, and multiplication operators, respectively.
SYNTAX ANALYSIS (PARSING)
Build a tree called a parse tree that reflects the structure of the input sentence.
A syntax tree in which each interior node represents an operation and the children of
the node represent the arguments of the operation.
Example:
The Phrase : x = +y
Four Tokens “x", “=“ ,“+" and “y“
Structure x = (x+(y)) i.e., an assignment expression
SYNTAX ANALYSIS: GRAMMARS
Expression grammar
Exp Exp ‘+’ Exp
| Exp ‘*’ Exp
| ID
| NUMBER
SYNTAX ANALYSIS: SYNTAX TREE
Input: result = a + b * 10
SEMANTIC ANALYSIS
Check the source program for semantic errors
It uses the hierarchical structure determined by the syntax-analysis phase to
identify the operators and operands of expressions and statements
Performs type checking
Operator operand compatibility
Example:
The compiler must report an error if a floating-point number is used to index an array.
SEMANTIC ANALYSIS
The language specification may permit some type conversions
called coercions.
Example:
The compiler may convert or coerce
the integer into a floating-point number.
INTERMEDIATE CODE GENERATION
Translate each hierarchical structure decorated as tree into intermediate code
A program translated for an abstract machine
Properties of intermediate codes
Should be easy to produce
Should be easy to translate into the target program
Intermediate code hides many machine-level details, but has instruction-level
mapping to many assembly languages
Main motivation: portability
One commonly used form is “Three-address Code”
INTERMEDIATE CODE GENERATION
We consider an intermediate form called “three-address code”.
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.
CODE OPTIMIZATION
Apply a series of transformations to improve the time and space efficiency of
the generated code.
Peephole optimizations: generate new instructions by combining/expanding on
a small number of consecutive instructions.
Global optimizations: reorder, remove or add instructions to change the
structure of generated code
Consumes a significant fraction of the compilation time
Optimization capability varies widely
Simple optimization techniques can be vary valuable
CODE OPTIMIZATION
CODE GENERATION
Map instructions in the intermediate code to specific machine instructions.
Memory management, register allocation, instruction selection, instruction
scheduling, …
Generates sufficient information to enable symbolic debugging.
CODE GENERATION
For example, using registers R1 and R2, the intermediate code might get
translated into the machine code
SYMBOL TABLE
Records the identifiers used in the source program
Collect information about various attributes of each identifier
Variables: type, scope, storage allocation
Procedure: number and types of arguments, method of argument passing
It’s a data structure containing a record for each identifier
Different fields are collected and used at different phases of compilation
When an identifier in the source program is detected by the lexical analyzer, the
identifier is entered into the symbol table
SYMBOL TABLE
It is built in lexical and syntax analysis phases and It is used by compiler to achieve compile
time efficiency.
The information is collected by the analysis phases of compiler and is used by synthesis phases
of compiler to generate code.
Items stored in Symbol table:
Variable names and constants
Procedure and function names
Literal constants and strings
Compiler generated temporaries
Labels in source languages
SYMBOL TABLE
Information used by compiler from Symbol table:
Data type and name
Declaring procedures
Offset in storage
If structure or record then, pointer to structure table.
For parameters, whether parameter passing by value or by reference
Number and type of arguments passed to function
Base Address
SYMBOL TABLE
It is used by various phases of compiler as follows :-
Lexical Analysis: Creates new table entries in the table, example like entries about token.
Syntax Analysis: Adds information regarding attribute type, scope, dimension, line of reference, use,
etc in the table.
Semantic Analysis: Uses available information in the table to check for semantics i.e. to verify that
expressions and assignments are semantically correct(type checking) and update it accordingly.
Intermediate Code generation: Refers symbol table for knowing how much and what type of run-
time is allocated and table helps in adding temporary variable information.
Code Optimization: Uses information present in symbol table for machine dependent optimization.
Target Code generation: Generates code by using address information of identifier present in the
table.
ERROR DETECTION, RECOVERY AND
REPORTING
Each phase can encounter error.
The tasks of the Error Handling process are to detect each error, report it to the
user, and then make some recover strategy and implement them to handle error.
Specific types of error can be detected by specific phases
Lexical Error : int abc, 1num ;
Syntax Error: total = capital + rate year;
Semantic Error: value = myarray [realIndex];
Should be able to proceed and process the rest of the program after an error detected
Should be able to link the error with the source program
ERROR DETECTION, RECOVERY AND
REPORTING
Types or Sources of Error –
There are two types of error: Run-time and Compile-time error:
A Run-time error is an error which takes place during the execution of a program, and
usually happens because of adverse system parameters or invalid input data.
The lack of sufficient memory to run an application or a memory conflict with
another program
Logical error is another example. Logic errors, occur when executed code does not
produce the expected result. Logic errors are best handled by meticulous program
debugging.
ERROR DETECTION, RECOVERY AND
REPORTING
Types or Sources of Error –
There are two types of error: Run-time and Compile-time error:
A Compile-time error rises at compile time, before execution of the program. Syntax error
or missing file reference that prevents the program from successfully compiling is the
example of this.
Classification of Compile-time error –
Lexical : This includes misspellings of identifiers, keywords or operators
Syntactical : missing semicolon or unbalanced parenthesis
Semantical : incompatible value assignment or type mismatches between operator and operand
Logical : code not reachable, infinite loop.
REVIEWING THE ENTIRE PROCESS
REVIEWING THE ENTIRE PROCESS
COMPILER CONSTRUCTION TOOLS
1) Parser generators: It produces syntax analyzers (parsers) from the input that is
based on a grammatical description of programming language or on a context-
free grammar.
2) Scanner generators: It generates lexical analyzers from the input that consists
of regular expression description based on tokens of a language. It generates a
finite automaton to recognize the regular expression.
3) Syntax-directed translation engines: It generates intermediate code with three
address format from the input that consists of a parse tree. These engines have
routines to traverse the parse tree and then produces the intermediate code.
COMPILER CONSTRUCTION TOOLS
4) Code-generator: It generates the machine language for a target machine.
5) Data-flow analysis engines: A key part of the code optimization that gathers
the information, that is the values that flow from one part of a program to
another.
6) Compiler-construction toolkits: It provides an integrated set of routines
that aids in building compiler components or in the construction of various
phases of compiler.
Reading Materials
Chapter -1 of your Text book:
Compilers: Principles, Techniques, and Tools
https://www.geeksforgeeks.org/compiler-design-tutorials/
THE END
