Lecture Notes on
Compiler Design: Overview
15-411: Compiler Design
SUNIL PAL
Lecture 1
August 24, 2009
1 Introduction
This course is a thorough introduction to compiler design, focusing on
more low-level and systems aspects rather than high-level questions such
as polymorphic type inference or separate compilation. You will be building
several complete end-to-end compilers for successively more complex
languages, culminating in a mildly optimizing compiler for a safe variant
of the C programming language to x86-64 assembly language. For the last
project you will have the opportunity to optimize more aggressively, to implement
a garbage collector, or retarget the compiler to an abstract machine.
In this overview we review the goals for this class and give a general
description of the structure of a compiler. Additional material can be found
in the optional textbook [App98, Chapter 1].
2 Goals
After this course you should know how a compiler works in some depth. In
particular, you should understand the structure of a compiler, and how the
source and target languages influence various choices in its design. It will
give you a new appreciation for programming language features and the
implementation challenges they pose, as well as for the actual hardware
architecture
and the runtime system in which your generated code executes.
Understanding the details of typical compilation models will also make
you a more discerning programmer.
LECTURE NOTES AUGUST 24, 2009
L1.2 Compiler Design: Overview
You will also understand some specific components of compiler technology,
such as lexical analysis, grammars and parsing, type-checking, intermediate
representations, static analysis, common optimizations, instruction
selection, register allocation, code generation, and runtime organization.
The knowledge gained should be broad enough that if you are confronted
with the task of contributing to the implementation of a real compiler
in the field, you should be able to do so confidently and quickly.
For many of you, this will be the first time you have to write, maintain,
and evolve a complex piece of software. You will have to program
for correctness, while keeping an eye on efficiency, both for the compiler
itself and for the code it generates. Because you will have to rewrite the
compiler from lab to lab, and also because you will be collaborating with a
partner, you will have to pay close attention to issues of modularity and interfaces.
Developing these software engineering and system building skills
are an important goal of this class, although we will rarely talk about them
explicitly.
3 Compiler Requirements
As we will be implementing several compilers, it is important to understand
