Building an Optimizing Compiler

Rating:
Summary: a code-free approach to *optimizing* compilers
Review: Most students who have taken a semester course in compiler would agree that a semester is too short even for just building a compiler, not to include the time used to learn the basics like parsing. This book is a good start at where your course left off. It covers many interesting and modern topics on building an _optimizing_ compiler, a compiler that generates compact and speedy code.

As a comparison to the Muchnick one, this book is slightly less advanced but contains sufficient details to start one in this field. This book also excels in its clear and informative explanations.

An interesting feature of this book (and also Muchnick) is that no concrete code/implementation is included. The focus is on the concepts of building an optimizing compiler and the theory behind code optimization, not exactly on how to build one (from scratch) using whatever programming language. The reader must come up with the implementation side of the story if she wants to apply the techniques to her own compiler.

As a final note, this is not an introductory book on compilers. If you want one, go find the classic Dragon book (by Aho, Sethi, Ullman) or the newly written work by Appel.

Rating:
Summary: Excelent complete overview of an optimizing compiler
Review: This book just has it all. As the title suggests, this book is all about compiler optimizations. Don't expect to find anything about lexical analysis or parsing here, but that is exactly why I like this book so much. It is aimed at people who are familiar with the basic structure of a compiler and with data structures and algorithms.

The book describes the various phases the intermediate language of a compiler goes through before the final assembly or object file is written. It discusses such things as SSA form, lazy code motion and its application to load and store motion, scheduling, register allocation, etc. Important concepts, including (but not limited to) correctness, dominance, control dependence, and availability, are discussed and explained in detail. Algorithms and data flow equations are given with a proof and a clear explantaion. But this is not an algorithms cook book like Muchnick, the best part of this book is the synthesis of all the algorithms and ideas.

There are only 3 drawbacks of this book. First of all, Morgan assumes that the target is a RISCy machine with a reasonably orthogonal register and instruction set. Second, the framework he presents is sometimes a bit unconventional. For example, his discussion about register allocation presents Chow&Hennesey priority bases graph coloring, but it forgets to give a proper comment on Chaitin/Briggs style coloring. Finally, the book exclusively describes intraprocedural optimizations.

That said, the basic ideas presented in the book will give you enough references and back ground to understand the differences between Morgan's approach and other approaches to building optimizing compilers.