Compiler Design - CS6660

INTRODUCTION TO COMPILERS

LEXICAL ANALYSIS

SYNTAX ANALYSIS

SYNTAX DIRECTED TRANSLATION & RUN TIME ENVIRONMENT

CODE OPTIMIZATION AND CODE GENERATION

LEXICAL ANALYSIS

=> Algorithms for Solving Nonlinear Equations
=> Introduction to Compiling Compilers
=> Analysis of the source program
=> The Phases of a Compiler
=> Cousins of Compiler
=> Grouping of the Phases
=> Compiler Construction Tools
=> Lexical Analysis
=> Input Buffering
=> Specification of Tokens
=> Recognition of Tokens
=> A Language For Specifying Lexical Analyzer
=> Important Short Questions and Answers : Principles of Compiler Design - Lexical Analysis

SYNTAX ANALYSIS and RUN TIME ENVIRONMENTS

=> Syntax Analysis
=> The Role of Parser
=> Context-Free Grammars
=> Writing a Grammar
=> Top down parsing and Bottom up Parsing
=> Constructing SLR(1) Parsing Table
=> Type Checking
=> Specification of a Simple Type Checker
=> Run-Time Environments - Source Language Issues
=> Storage Organization
=> Storage Allocation Strategies
=> Important Short Questions and Answers: Syntax Analysis and Run-Time Environments

INTERMEDIATE CODE GENERATION

=> Intermediate Languages
=> Declarations
=> Assignment Statements
=> Boolean Expressions
=> Case Statements
=> Backpatching
=> Procedure Calls
=> Important Short Questions and Answers: Principles of Compiler Design - Intermediate Code Generation

CODE GENERATION

=> Issues in the design of a code generator
=> Target Machine
=> Run-Time Storage Management
=> Basic Blocks and Flow Graphs of Code Generation
=> A Simple Code Generator
=> Register Allocation and Assignment
=> The Dag Representation For Basic Blocks
=> Generating Code From DAGs
=> Important Short Questions and Answers: Compiler Design - Code Generation

CODE OPTIMIZATION

=> Code Optimization
=> Principal Sources of Optimisation
=> Peephole Optimization
=> Optimization of Basic Blocks
=> Loops in Flow Graph
=> Introduction to Global Dataflow Analysis
=> Code Improvig Transformations
=> Glossary - Principles of Compiler Design
=> Tutorial problems and worked out examples - Principles of Compiler Design
=> Important Short Questions and Answers: Code optimization

Compilers Principles Techniques and Tools by Alfred V Aho Monica S Lam Ravi Sethi Jeffrey D Ullman

Chapter 1 : Introduction

=> Compilers - Principles, Techniques, & Tools
=> Language Processors
=> The Structure of a Compiler
=> The Evolution of Programming Languages
=> The Science of Building a Compiler
=> Applications of Compiler Technology
=> Programming Language Basics

Chapter 2 : Simple Syntax Directed Translator

=> A Simple Syntax-Directed Translator
=> Syntax Definition
=> Syntax-Directed Translation
=> Parsing
=> A Translator for Simple Expressions
=> Lexical Analysis
=> Symbol Table Per Scope and Use of Symbol Tables
=> Intermediate Code Generation

Chapter 3 : Lexical Analysis

=> Lexical Analysis
=> The Role of the Lexical Analyzer
=> Input Buffering: Buffer Pairs, Sentinels
=> Specification of Tokens
=> Recognition of Tokens
=> The Lexical-Analyzer Generator Lex
=> Finite Automata
=> From Regular Expressions to Automata
=> Design of a Lexical-Analyzer Generator
=> Optimization of DFA-Based Pattern Matchers

Chapter 4 : Syntax Analysis

=> Syntax Analysis
=> Context-Free Grammars
=> Writing a Grammar
=> Top-Down Parsing
=> Bottom-Up Parsing
=> Introduction to LR Parsing: Simple LR
=> More Powerful LR Parsers
=> Using Ambiguous Grammars
=> Parser Generators

Chapter 5 : Syntax Directed Translation

=> Syntax-Directed Translation
=> Syntax-Directed Definitions
=> Evaluation Orders for SDD's
=> Applications of Syntax-Directed Translation
=> Syntax-Directed Translation Schemes
=> Implementing L-Attributed SDD's

Chapter 6 : Intermediate Code Generation

=> Intermediate-Code Generation
=> Variants of Syntax Trees
=> Three-Address Code
=> Types and Declarations
=> Translation of Expressions
=> Type Checking
=> Control Flow
=> Backpatching
=> Switch-Statements
=> Intermediate Code for Procedures

Chapter 7 : Run Time Environments

=> Run-Time Environments
=> Storage Organization
=> Stack Allocation of Space
=> Access to Nonlocal Data on the Stack
=> Heap Management
=> Introduction to Garbage Collection
=> Introduction to Trace-Based Collection
=> Short-Pause Garbage Collection
=> Advanced Topics in Garbage Collection

Chapter 8 : Code Generation

=> Code Generation
=> Issues in the Design of a Code Generator
=> The Target Language
=> Addresses in the Target Code
=> Basic Blocks and Flow Graphs
=> Optimization of Basic Blocks
=> A Simple Code Generator
=> Peephole Optimization
=> Register Allocation and Assignment
=> Instruction Selection by Tree Rewriting
=> Optimal Code Generation for Expressions
=> Dynamic Programming Code-Generation

Chapter 9 : Machine Independent Optimizations

=> Machine-Independent Optimizations
=> The Principal Sources of Optimization
=> Introduction to Data-Flow Analysis
=> Foundations of Data-Flow Analysis
=> Constant Propagation
=> Partial-Redundancy Elimination
=> Loops in Flow Graphs
=> Region-Based Analysis
=> Symbolic Analysis

Chapter 10 : Instruction Level Parallelism

=> Instruction-Level Parallelism
=> Processor Architectures
=> Code-Scheduling Constraints
=> Basic-Block Scheduling
=> Global Code Scheduling
=> Software Pipelining Algorithm
=> Scheduling Acyclic Data-Dependence and Cyclic Dependence Graphs
=> Improvements to the Pipelining Algorithms

Chapter 11 : Optimizing for Parallelism and Locality

=> Optimizing for Parallelism and Locality
=> Basic Concepts of Optimizing for Parallelism and Locality
=> Matrix Multiply: An In-Depth Example
=> Iteration Spaces
=> Affine Array Indexes
=> Data Reuse
=> Array Data-Dependence Analysis
=> Finding Synchronization-Free Parallelism
=> Synchronization Between Parallel Loops
=> Pipelining
=> Locality Optimizations
=> Other Uses of Affine Transforms

Chapter 12 : Interprocedural Analysis

=> Interprocedural Analysis
=> Basic Concepts of Interprocedural Analysis
=> Why Interprocedural Analysis?
=> A Logical Representation of Data Flow
=> A Simple Pointer-Analysis Algorithm
=> Context-Insensitive Interprocedural Analysis
=> Context-Sensitive Pointer Analysis
=> Datalog Implementation by BDD's