Browse Books

Reviewer: Uwe Kastens

Compiler construction courses are an important part of the computer science curriculum of many universities. Although only a few of the students in these courses will later work in compiler development, these courses provide valuable insights into programming language principles, language design issues, and the implementation of domain-specific languages. The methods used in compiler construction demonstrate how practical software engineering techniques, combined with well-understood theoretical models, lead to modularized software systems of significant functionality and size. This book is intended to be a textbook for a one- or two-semester course. The one-semester course would cover Part 1 of the book (chapters 1 through 12), presenting compiler construction fundamentals, accompanied by a practical compiler implementation project. A second course could cover the advanced material presented in Part 2 of the book (chapters 13 through 21). Compared to the first edition, this second edition of the book has been extensively rewritten. The example language, "Tiger," that was previously used in the practical compiler project has been replaced by "MiniJava," a subset of Java. More object-oriented concepts, such as the visitor pattern for semantic analysis, have been added. Part 1 of the book is titled "Fundamentals of Compilation." It follows the standard structuring of compiler tasks and phases, addressing lexical and syntactical analysis, abstract syntax, and semantic analysis, as well as code generation issues such as activation records, basic blocks, instruction selection, and register allocation. Each chapter has both paper-and-pencil exercises and a programming project that corresponds to one module of a compiler. The programming exercises use modern Java-based compiler tools such as JavaCC, an LL-parser generator, and SableCC, an LALR-parser generator. Both generators also produce lexical analyzers. The tools are freely available, and can be accessed through the well-structured online resources pages for this book hosted by Cambridge University Press. The book does not aim for completeness in its references to alternative methods and tools. Part 1 provides a concise, but sufficiently precise overview of the basic methods applied in compiler construction. Only the rather short chapter on semantic analysis does not reach that quality standard: for name analysis and type analysis, ad hoc solutions are presented rather than systematic methods. Despite this shortcoming, however, the first part of the book, with its strong emphasis on practical implementation, would be very well suited to accompany a first compiler course, or to help its readers in refreshing their compiler knowledge. Part 2 of the book, "Advanced Topics," is intended as a text for an advanced compiler course, either for students who have already taken the fundamental course based on Part 1, or for people with basic compiler know-how from other sources. Part 2 still proposes paper-and-pencil exercises, but does not continue the use of practical MiniJava projects, which makes it somewhat independent of the first part. Part 2 includes a discussion of garbage collection, and the special language features and compilation problems introduced by object-oriented and functional languages. It presents program analyses and transformations based on dataflow analysis and special optimization techniques for loops. It also discusses static single assignment form, pipelining and scheduling for instruction-level parallel (ILP) processors, and optimization for cache-memory hierarchies. With this part of his book, the author manages to provide a nice and interesting view of some of the more advanced and modern topics in compiler construction. In summary, I recommend this book as a textbook for both beginning and advanced compiler courses. It includes a discussion of the most relevant current techniques used in compiler front ends and back ends. It puts a strong emphasis on practical aspects by using Java as its implementation language, discussing Java-based compiler tools, and proposing practical exercises that implement the various phases of a compiler. Finally, this is also a well-written book, which strictly adheres to a no-nonsense style, and therefore is a pleasure to read. Online Computing Reviews Service

Reviewer: Hector A. Villa-Martinez

The objective of this book is to serve as a textbook for a two-semester course in compilers. The book is divided into two parts. Part 1 is adequate for an undergraduate course covering the principles of compilers, and Part 2 is more appropriate for a graduate course, as it is focused on advanced topics. Part 1 is comprised of 12 chapters, each describing one phase of a compiler. Chapter 1 is an introduction to the topic, and chapter 2 covers the standard material in lexical analysis: regular expressions and finite automata. The JavaCC and SableCC parser generators are introduced in this chapter. Chapter 3 addresses syntax analysis, and starts by explaining some parsing algorithms, for example recursive descent and LR parsing, and then demonstrates how to construct a parser using the aforementioned parser generators. The chapter ends with error recovery theory. Chapter 4 is about semantic actions using an abstract syntax tree. Chapter 5 covers semantic analysis and type checking. Chapter 6 studies techniques to implement activation records, and chapter 7 covers translation to machine-independent intermediate code, producing intermediate representation (IR) trees. Chapter 8 studies some transformations to IR trees that are necessary for the convenience of next phases, including hoisting side effects out of expressions, and clean up of conditional branches. Chapter 9 reviews some algorithms for instruction selection, and chapter 10 explains optimization through liveness analysis from control-flow graphs. Chapter 11 addresses register allocation techniques. Finally, chapter 12 is about code emission. Part 2 discusses more advanced topics, and has nine chapters. Chapter 13 is a review of some methods of garbage collection: mark and sweep, reference counts, copying collection, generational collection, incremental collection, and Bakers algorithm. Chapter 14 explores the compiling of object-oriented languages, and chapter 15 does the same for functional languages. Chapter 16 demonstrates how to deal with the two main kinds of polymorphism: parametric polymorphism and overloading. Chapters 17 through 19 are about optimization. The authors present an extensive review of techniques and their alternatives, including data flow analysis, loop optimization, and static single-assignment forms. Finally, chapters 20 and 21 address possible optimizations in machines supporting pipelining and cache management. Some valuable features are contained in the book. Although it has the word Java in its title, the book is not loaded with code, so anybody can benefit by reading it. Another advantage is its coverage of modern issues like reduced instruction set computing (RISC) machines, garbage collection, optimization, and compiling object-oriented and functional languages. On the first page, there is a warning that only [t]he most accepted and successful techniques are described concisely, rather than as an exhaustive catalog of every possible variant. For example, the chapters about lexical and syntactic analysis are very succinct, so, depending of the class and the instructor, another book may be needed. There is a companion Web site where the parser generators can be downloaded. At the end of each chapter, there are sections with a commented bibliography, a program assignment, and a set of exercises. The book is very readable, with a precise and concise style. Overall, I think this a very valuable textbook, which is worth its price. Online Computing Reviews Service