Browse Books

Reviewer: Frank George Pagan

The bulk of this volume consists of a description of the back end of a compiler for the functional programming language Standard ML. The compiler, which is playfully named Standard ML of New Jersey, employs continuation-passing style as an intermediate representation. As anyone familiar with denotational semantics knows, a continuation is a function that expresses the entire future portion of a programs computation, given that some part of the computation has already been completed. In languages that treat functions as first-class values, it is possible to write all programs in the highly unconventional continuation-passing style (CPS). In CPS, each non-continuation function takes a continuation k as an extra argument and, instead of returning a result z to its caller, completes its work by calling k with argument z . As an example (taken from page 15), the ML expression let fun f(x) = 2*x+1 in f(a+b)*f(c+d) end could be rewritten using CPS as let fun f(x,k) = k(2*x+1) fun k1(i) = let fun k2(j) = r(i*j) in f(c+d, k2) end in f(a+b, k1) end where k 1 and k 2 are the continuations for the two calls of f, and r is the continuation for the entire expression. For programs that are written entirely in CPS, all function calls can be implemented as simple jumps, and the need for a runtime stack of activation records can be eliminated. The first chapter immediately introduces the concept of CPS and compares it to other kinds of intermediate representation with respect to suitability for optimization. Chapter 2 defines and discusses a data structure for the representation of CPS ML programs. Using ML itself as the metalanguage, chapter 3 gives a denotational semantics for the CPS representation. Chapter 4 describes some ML-specific optimizations that constitute the compilers first back-end pass and result in a simplified, “lambda-language” re presentation of the source program. The next pass, which converts the lambda-language form into the CPS form, is defined in chapter 5. Chapters 6 through 9 describe various CPS-form optimizations, which account for the next several passes of the compiler. The optimizations include constant folding of many different kinds, beta contraction, eta reduction, uncurrying, beta expansion, hoisting, and common-subexpression elimination. Chapter 10 describes a closure conversion phase, producing a CPS form in which functions contain no free variables, and a lifting phase that eliminates all nesting of function definitions. A register spilling pass is described in chapter 11. Chapter 12 describes the space-complexity effects of the transformations described in the earlier chapters. Chapter 13 describes a pass that produces a generalized, assembly language–like representation of the program being compiled. The compilers final two passes, culminating in the generation of native machine code for any of four target machines, are described in chapter 14. An extensive evaluation of the compilers performance is given in chapter 15. It appears that, compared with other ML implementations, compilation speed is poor (but the author believes that it could be improved by a factor of 2) and runtime speed is good. Chapters 16 through 18 address some important miscellaneous aspects, such as garbage collection. The books typography and the authors writing style make it easy to read, despite quite a few errors in spelling and grammar. The five-page index seems adequate if not exceptional. The bibliography contains 98 items, is up-to-date, and is extensively referenced throughout the book. Since the book has no preface, it is more difficult than usual to discover its intended purpose and audience. It is evidently too advanced to be suitable as a course textbook (and, accordingly, no exercises are provided). The back cover blurb identifies the intended readers as “compiler writers in both industry and academe” and “students and researchers in programming-language theory.” It cannot be doubted that the techniques presented, many of which are clever and of recent invention, constitute an advance and consolidation of the state of the art of implementation of functional-paradigm programming languages. In my opinion, however, people involved with other kinds of languages will find the book to be of limited value. Implementors of imperative languages, for example, might well reject out of hand the prospect of a compiler with a double-digit number of internal passes. I recommend the book to language designers and implementors specializing in the functional paradigm.