Lecture Schedule

Week 1

• Lecture 1.1: What is a Compiler?
• Lecture 1.2: Types of Compilers
• Lecture 1.3: Phases of a Compiler
• Lecture 1.4: Structure of a Compiler
• Lecture 1.5: What is a Regular Language?
• Lecture 1.6: Regular Expression Syntax

Week 2

• Lecture 2.1: Finite Automata
• Lecture 2.2: Building NFA
• Lecture 2.3: From NFA to DFA
• Lecture 2.4: Minimization
• Lecture 2.5: Regex Engines
• Lecture 2.6: Parsing Overview
• Lecture 2.7: Why Aren’t Regular Expressions Enough?
• Lecture 2.8: Context-Free Grammars

Week 3

• Lecture 3.1: Parsing
• Lecture 3.2: Recursive Descent
• Lecture 3.3: First and Follow Sets
• Lecture 3.4: Putting the Pieces Together
• Lecture 3.5: When LL(1) Fails
• Lecture 3.6: Parser Generator
• Lecture 3.7: Bottom-Up Parsing
• Lecture 3.8: Configuration and CFSM

Week 4

• Lecture 4.1: Semantic Actions
• Lecture 4.2: Actions in ANTLR
• Lecture 4.3: Symbol Tables
• Lecture 4.4: Abstract Syntax Trees
• Lecture 4.5: ASTs for Expressions
• Lecture 4.6: Generating Code
• Lecture 4.7: Code Generation Example

Week 5

• Lecture 5.1: ASTs for Control Structures
• Lecture 5.2: Generating Code for Conditionals
• Lecture 5.3: Generating Code for Loops
• Lecture 5.4: Generating Code for Switch Statements

Week 6

• Lecture 6.1: Function Basics
• Lecture 6.2: Calling a Function
• Lecture 6.3: Function Calling Conventions
• Lecture 6.4: Symbols in Functions
• Lecture 6.5: Stack Organization
• Lecture 6.6: Code Generation for Functions
• Lecture 6.7: Saving Registers

Week 7

• Lecture 7.1: What are Types?
• Lecture 7.2: Dynamic Type Checking
• Lecture 7.3: Static Types
• Lecture 7.4: Static Type Checking
• Lecture 7.5: Implementing Type Checking

Week 8

• Lecture 8.1: Optimization Overview
• Lecture 8.2: Intermediate Representation
• Lecture 8.3: Peephole Optimization
• Lecture 8.4: Local Optimization
• Lecture 8.5: Common Subexpression Elimination
• Lecture 8.6: CSE Example
• Lecture 8.7: Aliasing
• Lecture 8.8: Live and Dead Code
• Lecture 8.9: Liveness Analysis
• Lecture 8.10: Finding Dead Code

Week 9

• Lecture 9.1: Register Allocation
• Lecture 9.2: Local Register Allocation
• Lecture 9.3: Register Allocation Details
• Lecture 9.4: Global Register Allocation
• Lecture 9.5: Graph Coloring
• Lecture 9.6: Graph Coloring Theory
• Lecture 9.7: Dealing with Spills

Week 10

• Lecture 10.0: What Have We Learned
• Lecture 10.1: Basic Blocks
• Lecture 10.2: Control Flow Graphs
• Lecture 10.3: Pointers
• Lecture 10.4: Code Generation for Pointers
• Lecture 10.5: Pointer Codegen example
• Lecture 10.6: Memory Allocation
• Lecture 10.7: Arrays
• Lecture 10.8: Desugaring Arrays

Week 11

• Lecture 11.1: Dataflow Analysis
• Lecture 11.2: Constant Propagation
• Lecture 11.3: Symbolic Evaluation
• Lecture 11.4: Loops and Fixpoints
• Lecture 11.5: Lattice Theory
• Lecture 11.6: Functions over Domains
• Lecture 11.7: Fixpoint Theorem
• Lecture 11.8: Lattices

Week 12

• Lecture 12.1: More Dataflow Analyses
• Lecture 12.2: Liveness Example
• Lecture 12.3: Bitvector Analyses
• Lecture 12.4: More Analyses
• Lecture 12.5: What is Pointer Analysis?
• Lecture 12.6: Flow-Sensitive Pointer Analysis
• Lecture 12.7: Flow-Insensitive Pointer Analysis

Week 13

Happy Thanksgiving!

Week 14

• Lecture 14.1: Loop Optimizations
• Lecture 14.2: Loop Invariant Code Motion
• Lecture 14.3: Strength Reduction
• Lecture 14.4: High-Level Loop Optimization
• Lecture 14.5: Example Loop Optimizations
• Lecture 14.6: Dependence Analysis
• Lecture 14.7: Representing Dependencies
• Lecture 14.8: Loop Parallelization
• Lecture 14.9: Other Loop Parallelization