Lectures -- A Short Course in Compilers

A Short Course in Compilers

Course Materials

These lectures are designed for a 10-session class. It is assumed that the students know MATLAB and introductory level college mathematics.

The planned course format is an hour of lecture followed by an hour of in-class lab work. There is not enough time to go into everything in a 10 meeting format. Much of the material is designed for home study. The student is encouraged to read the rest of the material after each class.

The overheads (links below) are designed for a classroom setting. They are useful mostly as bullets which show the order of classroom lecture subtopics. The overheads can be ignored during home study.

If a project is going to be attempted, it should be done simultaneously.

Order of Presentation

Most compilers, including xcom, have a front end and a back end corresponding the analysis and synthesis. This presentation of the front end follows the data flow in the compiler, lex to parse to tree to symbols. The presentation of the back end is in reverse order, assember to emitter to generator. This order is just one example of the old Polish proverb When crossing a swamp, keep one foot on solid ground. At each end of the compiler we have simplicity: ASCII text in, hardware instructions out. The data at each end can be understood on its own. The further we move towards the middle, the more new knowledge is in play.

Both ends to the middle is appropriate for xcom for another reason; the front end components transform inputs into explicit outputs, but the back end does not. In the front end there is a lex pass, a parse pass, a tree building pass, and a symbol table pass. Each front end component leaves behind an intermediate data structure. The back end components run simultaneously, each calling for services in the next component on the fly. This is not fundamental -- intermediate forms could have been invented and the back end could also have proceeded in passes. But it does not.

Lecture 1 (overheads)

(10 min) Hello, Course Objectives, Schedule
(10 min) Getting a personal copy of xcom.
(05 min) OO Programming Model
(25 min) Learning X

Lab 1

(05 min) Students as QE
(10 min) Read the X Reference Manual
(25 min) Practice Writing X and Running xcom
(10 min) Using xcom flags for dumps and traces

Lecture 2 (overheads)

(15 min) Structure of xcom
(40 min) Grammars for programming languages

Lab 2

(10 min) Read about changing the Cfg object
(50 min) Modify a Cfg

Lecture 3 (overheads)

(10 min) Lexing a text.
(10 min) Changing the xcom Lexer
(10 min) Regular Expressions
(20 min) Regular Expression Grammars

Lab 3

(60 min) Examine, test and extend the lexer.
Challenge: Do the exercises for regular expressions (hints).
Challenge: write a faster lexer. Hint: use MATLAB profiler.

Lecture 4 (overheads)

(10 min) Changing the xcom top-down Parser
(40 min) Parsing a programming language

Lab 4

(60 min) Examine, implement and test parsers.
Challenge: Add abs to X (in Parser.m)
Challenge: compare speeds of bottom up vs. top down parsing

Lecture 5 (overheads)

(20 min) Syntax Trees
(20 min) Symbol Tables
(10 min) Changing the xcom symbol table

Lab 5

(60 min) Examine and test syntax trees and symbols tables.
Challenge: Adding abs to X (in Symbols.m)
Challenge: Rewrite Symbols.m so that it uses hash lookup.

Lecture 6 (overheads)

(20 min) Machine Language
(20 min) Runtime
(05 min) Changing Runtime
(05 min) >> xcom -interactive x/pi.x
(05 min) Changing the Intel emulator

Lab 6

(60 min) Examine and test the use of the computing hardware.
Challenge: add abs to X (in AsmX86.m)
Challenge: Implement AsmA64.m

Lecture 7 (overheads)

(10 min) Summary: the Big Picture
(20 min) Emitting CPU Instructions
(30 min) Synthesis of Sequential Semantics

Lab 7

(05 min) Read about changing the xcom code emitter
(05 min) Read about changing the xcom generator
(50 min) Examine and test code selection.
Challenge: Add abs to X (in EmitX86.m and Generator.m)
Challenge: Implement EmitA64.m (Intel 64-bit)

Lecture 8 (overheads)

(50 min) A tiny compiler compiler.

Lab 8

(60 min) Experiment with GEM

Lecture 9 (overheads)

(20 min) Tradeoffs between interpreters, JITs and production compilers
(30 min) Conventional Optimization Strategies

Lab 9

Add an instruction to the mxcom emulator:
```
      >> edit mxcom/m/EmulateX86
```
See the Intel X86 reference for details.
Challenge: Compare the speed of a C compiler at various levels of optimization. Compare the speed of the compiled C code for each.
Challenge: Implement Constant Folding for X as a peephole.