Lecture 01 introduction to compiler
32 likes21,031 views
This document provides an introduction to compilers, including: - What compilers are and their role in translating programs to machine code - The main phases of compilation: lexical analysis, syntax analysis, semantic analysis, code generation, and optimization - Key concepts like tokens, parsing, symbol tables, and intermediate representations - Related software tools like preprocessors, assemblers, loaders, and linkers
![Error Detection, Recovery and Reporting
• Each phase can encounter 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](https://image.slidesharecdn.com/lecture01introductiontocompiler-150916050140-lva1-app6892/85/Lecture-01-introduction-to-compiler-20-320.jpg)
Lecture 01 introduction to compiler
- 2. What is a compiler? • Programming problems are easier to solve in high-level languages – Languages closer to the level of the problem domain, e.g., • SmallTalk: OO programming • JavaScript: Web pages • Solutions are usually more efficient (faster, smaller) when written in machine language – Language that reflects to the cycle-by-cycle working of a processor • Compilers are the bridges: – Tools to translate programs written in high-level languages to efficient executable code
- 3. What is a compiler? A program that reads a program written in one language and translates it into another language. Source language Target language Traditionally, compilers go from high-level languages to low-level languages.
- 4. 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, optimizing…. • Variety is overwhelming…… • Good news is: – Few basic techniques is sufficient to cover all variety – Many efficient tools are available
- 5. Requirement • In order to translate statements in a language, one needs to understand both – the structure of the language: the way “sentences" are constructed in the language, and – the meaning of the language: what each “sentence" stands for. • Terminology: Structure ≡ Syntax Meaning ≡ Semantics
- 6. Analysis-Synthesis model of compilation Front End – language specific Back End – machine specific Source Language Target Language Intermediate Language • Two parts – Analysis • Breaks up the source program into constituents – Synthesis • Constructs the target program
- 7. Software tools that performs analysis • Structure Editors – Gives hierarchical structure – Suggests keywords/structures automatically • Pretty Printer – Provides an organized and structured look to program – Different color, font, indentation are used • Static Checkers – Tries to discover potential bugs without running – Identify logical errors, type-checking, dead codes identification etc • Interpreters – Does not produce a target program – Executes the operations implied by the program
- 8. Compilation Steps/Phases Scanner (lexical analysis) Parser (syntax analysis) Code Optimizer Semantic Analysis (IC generator) Code Generator Symbol Table Source language tokens Syntactic structure Intermediate Language Target language Intermediate Language
- 9. Compilation Steps/Phases • Lexical Analysis Phase: Generates the “tokens” in the source program • Syntax Analysis Phase: Recognizes “sentences" in the program using the syntax of the language • Semantic Analysis Phase: Infers information about the program using the semantics of the language • Intermediate Code Generation Phase: Generates “abstract” code based on the syntactic structure of the program and the semantic information from Phase 2 • Optimization Phase: Refines the generated code using a series of optimizing transformations • Final Code Generation Phase: Translates the abstract intermediate code into specific machine instructions
- 10. Lexical Analysis • Convert the stream of characters representing input program into a sequence of tokens • Tokens are the “words" of the programming language • Lexeme – The characters comprising a token • For instance, the sequence of characters “static int" is recognized as two tokens, representing the two words “static" and “int" • The sequence of characters “*x++" is recognized as three tokens, representing “*", “x" and “++“ • Removes the white spaces • Removes the comments
- 11. Lexical Analysis • Input: result = a + b * 10 • Tokens: ‘result’, ‘=‘, ‘a’, ‘+’, ‘b’, ‘*’, ‘10’ identifiers operators
- 12. Syntax Analysis (Parsing) • Uncover the structure of a sentence in the program from a stream of tokens. • For instance, the phrase “x = +y", which is recognized as four tokens, representing “x", “=“ and “+" and “y", has the structure =(x,+(y)), i.e., an assignment expression, that operates on “x" and the expression “+(y)". • Build a tree called a parse tree that reflects the structure of the input sentence.
- 13. Syntax Analysis: Grammars • Expression grammar Exp ::= Exp ‘+’ Exp | Exp ‘*’ Exp | ID | NUMBER Assign ::= ID ‘=‘ Exp
- 14. Syntax Tree Assign result + a * b 10 Input: result = a + b * 10
- 15. Semantic Analysis • Concerned with the semantic (meaning) of the program • Performs type checking – Operator operand compitability
- 16. 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 generate – Should be easy to translate • 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”
- 17. 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
- 18. 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.
- 19. Symbol Table • Records the identifiers used in the source program – Collects various associated information as attributes • Variables: type, scope, storage allocation • Procedure: number and types of arguments method of argument passing • It’s a data structure with collection of records – Different fields are collected and used at different phases of compilation
- 20. Error Detection, Recovery and Reporting • Each phase can encounter 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
- 21. Error Detection, Recovery and Reporting Scanner (lexical analysis) Parser (syntax analysis) Code Optimizer Semantic Analysis (IC generator) Code Generator Symbol Table Source language tokens Syntactic structure Target language Error Handler
- 22. Translation of a statement Lexical Analyzer result = a + b * 10 Syntax Analyzer id1 = id2 + id3 * 10 Assign id1 + id2 * id3 10 …….b …….a …….result Symbol Table
- 23. Translation of a statement Assign id1 + id2 * id3 10 Semantic Analyzer Assign id1 + id2 * id3 INTTOREAL 10
- 24. Translation of a statement Intermediate Code Generator temp1 := INTTOREAL (10) temp2 := id3 * temp1 temp3 := id2 + temp2 Id1 := temp3 Code Optimizer temp1 := id3 * 10.0 Id1 := id2 + temp1 Code Generator MOVF id3, R2 MULF #10.0, R2 MOVF id2, R1 ADDF R2, R1 MOVF R1, id1
- 25. Syntax Analyzer versus Lexical Analyzer • Which constructs of a program should be recognized by the lexical analyzer, and which ones by the syntax analyzer? – Both of them do similar things; But the lexical analyzer deals with simple non-recursive constructs of the language. – The syntax analyzer deals with recursive constructs of the language. – The lexical analyzer simplifies the job of the syntax analyzer. – The lexical analyzer recognizes the smallest meaningful units (tokens) in a source program. – The syntax analyzer works on the smallest meaningful units (tokens) in a source program to recognize meaningful structures in our programming language.
- 26. Cousins of the Compiler • Preprocessor – Macro preprocessing • Define and use shorthand for longer constructs – File inclusion • Include header files – “Rational” Preprocessors • Augment older languages with modern flow-of-control or data-structures – Language Extension • Add capabilities to a language • Equel: query language embedded in C
- 27. Assemblers Compiler Assembler Source program Assembly program Relocatable machine code Loader/link-editor Absolute machine code
- 28. Two-Pass Assembly • Simplest form of assembler • First pass – All the identifiers are stored in a symbol table – Storage is allocated • Second pass – Translates each operand code in the machine language MOV a, R1 ADD #2, R1 MOV R1, b Identifier Address a 0 b 4 0001 01 00 00000000 * 0011 01 10 00000010 0010 01 00 00000100 * Source After First Pass After 2nd Pass Instruction code Register Addressing Mode Address Relocation bit
- 29. Loaders and Link-Editors • Convert the relocatable machine code into absolute machine code – Map the relocatable address • Place altered instructions and data in memory • Make a single program from several files of relocatable machine code – Several files of relocatable codes – Library files 0001 01 00 00000000 * 0011 01 10 00000010 0010 01 00 00000100 * 0001 01 00 00001111 0011 01 10 00000010 0010 01 00 00010011 Address space of data to be loaded starting at location L=00001111
- 30. Multi Pass Compilers • Passes – Several phases of compilers are grouped in to passes – Often passes generate an explicit output file – In each pass the whole input file/source is processed Syntax Analyzer Lexical Analyzer Intermediate Code Generator • Semantic analysis
- 31. How many passes? • Relatively few passes is desirable – Reading and writing intermediate files take time – It may require to keep the entire file in memory • One phase generate information in different order than that is needed by the next phase • Memory space is not trivial in some cases • Grouping into same pass incurs some problems – Intermediate code generation and code generation in the same pass is difficult • e.g. Target of ‘goto’ that jumps forward is now known • ‘Backpatching’ can be a remedy
- 32. Issues Driving Compiler Design • Correctness • Speed (runtime and compile time) – Degrees of optimization – Multiple passes • Space • Feedback to user • Debugging
- 33. Other Applications • In addition to the development of a compiler, the techniques used in compiler design can be applicable to many problems in computer science. – Techniques used in a lexical analyzer can be used in text editors, information retrieval system, and pattern recognition programs. – Techniques used in a parser can be used in a query processing system such as SQL. – Many software having a complex front-end may need techniques used in compiler design. • A symbolic equation solver which takes an equation as input. That program should parse the given input equation. – Most of the techniques used in compiler design can be used in Natural Language Processing (NLP) systems.