Compiler characteristics and phases

Translators

• A translator is a general software tool that converts code.
• It can refer to compilers, assemblers, or interpreters.
• Translators convert higher-level code (e.g., Basic, C++, Fortran, Java) into other high-level or lower-level code like assembly or machine code.
• It accomplishes some level of code conversion to a specific target language

Compilers

• Compilers convert high-level code to machine (object) code in one session.
• The translation process can take time as compilers translate high-level code to lower-level machine language all at once.
• This results in saving the executable object code to memory.
• Compilers create machine code for processors with specific Instruction Set Architectures (ISA), which are processor-dependent.
• Code compiled for one architecture (e.g., x86) cannot run on another (e.g., MIPS) without a special compiler
• Compilers are platform-dependent, and can convert code for specific operating systems like Linux.
• Cross-compilers generate code for platforms different from the one they run on.
• For example, A cross-compiler on Windows can generate code for Linux.
• Source-to-source compilers translate code from one language (e.g., Java) to another (e.g., C).
• Choosing a compiler requires knowing the ISA, operating system, and programming language you intend to use.
• Compilers often come with other tools in a package from processor manufacturers.
• Software tools, including compilers, are often free.
• Compilers report errors after compiling.

Interpreters

• Interpreters translate and immediately execute code line by line.
• Interpreters are often used as debugging tools in software development due to their ability to execute single lines of code.
• Compilers translate all code at once, followed by processor execution of the compiled machine language
• If code is changed after compilation, it needs to be recompiled.
• Interpreters skip the initial compilation step.
• They are slower overall compared to executing fully compiled programs.

What is a Compiler?

• A compiler transforms source code in a high-level language into low-level machine language.
• Translates one programming language to another without changing the meaning.
• Compilers optimize the output code for execution time and memory usage
• The compiling process includes translation and error detection
• It goes through lexical, syntax, and semantic analysis at the front end, and code generation and optimization at the back-end.

Features of Compilers

• Correctness
• Compilation speed
• Preservation of code meaning
• Target code speed
• Recognition of legal and illegal program constructs
• Error reporting/handling
• Code debugging help

Types of Compilers

• Single Pass Compilers
• Two Pass Compilers
• Multipass Compilers

Single Pass Compiler

• Transforms source code directly into machine code.
• Pascal is an example language used.

Two Pass Compiler

• Consists of two sections which are the Front end and the Back end
• Front end maps legal code into Intermediate Representation (IR).
• Back end maps IR onto the target machine
• Simplifies the retargeting process and allows multiple front ends.

Multipass Compilers

• Processes source code or syntax trees multiple times
• Divides large programs into smaller parts.
• Generates multiple intermediate codes, taking the output of each pass as input for the next.
• Requires less memory and is known as a 'Wide Compiler'.

Tasks of Compiler

• Break up source programs and impose grammatical structure.
• Construct the target program from intermediate representation and create the symbol table.
• Compiles source code and detects errors.
• Manages storage of variables and codes.
• Supports separate compilation.
• Reads and analyzes the entire program before translating to semantically equivalent code.
• Translates source code into object code based on the machine type.

Phases of a Compiler

• Lexical Analysis
• Syntax Analysis
• Semantic Analysis
• Intermediate Code Generation
• Code Optimization
• Code Generation

Syntax Analysis

• The second stage of translation, also known as parsing.
• Identifies expressions, statements, and declarations using the results of lexical analysis.
• Aided by techniques based on formal grammar of the programming language.

Intermediate Code Generation

• Produces an intermediate representation of the final machine language code.
• Bridges the analysis and synthesis phases of translation.

Code Optimization

• An optional phase to improve the intermediate code.
• Makes the output run faster and take less space.

Code Generation

• The last phase of translation.
• Involves optimizations to reduce the length of the machine language program.
• The output of the code generator is the machine language program for the specified computer.

Table Management (or) Book-keeping

• Retains the names used by the program and their essential information.
• Uses a data structure called a 'Symbol Table'.

Error Handlers

• Invoked when a flaw is detected in the source program.
• The output of Lexical Analysis (LA) is a stream of tokens passed to the syntax analyzer or parser.
• The Syntax Analyzer(SA) groups tokens into syntactic structures called expressions, which combine to form statements.
• The syntactic structure can be regarded as a tree called the parse tree

Parser Functions

• Checks if the tokens from the lexical analyzer fit the permitted patterns for the source language.
• Imposes a tree-like structure on tokens for subsequent compiler phases.

Parse Tree

• It is a graphical representation of the replacement process in a derivation

Syntax Tree

• It is the compact form of a parse tree.

Parse Tree vs Syntax Tree

• Parse trees provide every characteristic information from the real syntax, while Syntax trees do not.
• Parse trees are comparatively less dense than Syntax trees
• In the Parse Tree, each interior node represents a grammar rule.
• In the Parse Tree, each leaf node represents a terminal
• In the Syntax Tree, each interior node represents an operator.
• In the Syntax Tree, each leaf node represents an operand.

Explore compiler characteristics, primary tasks, and phases of compilation. Learn about single-pass, two-pass and multi pass compilers. Identify the data structures used for storing program names.