Advanced Compiler Design and Implementation

by Steven S. Muchnick

Book Overview

From the Foreword by Susan L. Graham: This book takes on the challenges of contemporary languages and architectures, and prepares the reader for the new compiling problems that will inevitably arise in the future.

The definitive book on advanced compiler designThis comprehensive, up-to-date work examines advanced issues in the design and implementation of compilers for modern processors. Written for professionals and graduate students,...

• Format: Hardcover
• Language: English
• ISBN: 1558603204
• ISBN13: 9781558603202
• Release Date: August 1997
• Publisher: Morgan Kaufmann Publishers
• Length: 888 Pages
• Weight: 3.60 lbs.
• Dimensions: 1.7" x 7.6" x 9.6"

Customer Reviews

Great starting point for compiler development

Compiler development is more of a craft than a science, although there's plenty of science involved. It involves huge numbers of tradeoffs in features, optimizations, and use of the underlying processor. But, as long as people keep coming up with new computing platforms (and not just instruction set processors), new languages, and new performance demands there will always be need for new compiler developers. If you can't apprentice yourself to masters of the craft, or even if you can, this book is a great introduction 2000-era compiler development. Muchnik does a clear, thorough job of laying out the basics, starting with the intermediate representation used. (If you get that wrong, nothing else is going to work.) He then moves on to the basics of symbol table structure - an issue that can get immensely complicated in systems like Microsoft's CLR. He also discusses run time support briefly. Although that discussion is good as far as it goes, it skips past a lot of the complexities of dynamic loading, debug symbol tables, simulation support, and related issues. They aren't strictly part of the compiled, executable code, but responsibilities of the compiler developer nonetheless. Next comes a brief description of code generation, crucial in normal environments but tangential to my own needs. That's just the first quarter of the book, though. The rest is the real meat of the topic: code analysis and optimization techniques, over 600 pages of discussion. It's way too much to summarize here, but even that just an introduction to a huge technology. Still, you have to start somewhere. By this point, you may be asking "But what about tokens, lexemes, and grammars? Isn't that what compilers do?" Well, yes, but it's done. Tool developers have made lexical analysis a commodity. The easily automated tasks are not where modern compiler distinguishes itself. This book addresses the semantic levels, getting the reader into the shallow end of the industry's huge pool of specialized compilation knowledge. If you have to self-teach compiler development - good luck. Start here, though, and luck will have a lot less to do with the outcome. //wiredweird

A great book on advanced compiler design

I have been working on language processors, interpreters and compilers for almost twenty years. I try to order all the booksthat have something unique to say about compiler design andimplementation. This is one of the best books I have seen onadvanced compiler design. I have owned it since it was firstpublished. Going back and rereading it I am reminded of whatand excellent book it is, which is what motivated this review.Advanced compiler design deals with various forms of optimization,including local, global and loop optimization. This is a complextopic with thirty years of research behind it (it is interestingto note that the late Gary Kildall, of CP/M fame, did some earlywork on optiimization in the early 1970s). No single book canprovide complete coverage of all optimization issues. However,this book, along with Allen and Kennedy's equally excellent"Optimizing Compilers for Modern Architectures" covers almosteverything you need to know.One of the problems with the academic literature on compiler optimization is that it can be unnecessarily obscure. Muchnickwrites clearly, with the implementer in mind. He provides awide range of techniques, allowing the implementer to choosethe correct one for a given compiler. This approach is bothuseful and necessary: there is no single method for buildinga compiler, given the range of languages and design objectives.Muchnick covers everything you need to know about local andglobal scalar optimization, including scalar optimization inloops and optimization for modern processor architecture.The only thing missing is an indepth coverage of loop dependenceand optimization techniques, which is provided by Allen andKennedy.If you are working on the design, implementation or extension ofa modern compiler, this book should be part of your library.

So you want to be a compiler writer?

This the next step after the dragon book (Compilers by Aho, et al). The algorithms contained in this book are a FANTASTIC reference for the compiler professional and i've used them on the job many times. Instuction Scheduling chapter in particular was comprehensive and useful. Covers all the important topics in a practical manner. The key word in the title is "implementation". If you are sitting down to write a compiler, this should be sitting next to you.

A must have book for professional compiler design,

Having read the dragon book, i was looking around for a book which can give me more information on subjects like code generation & code optimization. This book is exactly that. 90% of the book deals with the code generation & optimization techniques used by the commercial compilers available today. The algorithms are complete and can be implemented without any difficulty. You won't find any book which deals with the code generation & optimization techniques so detailed as this one. This book is certainly not intended for a beginner. This book is for the professionals.

The definitive compiler book for the 1990s

This book is the comprehensive text for anyone working on an optimizing compiler for uniprocessor systems. It gives good detail on all major approaches and is up-to-date on important techniques like SSA form and partial redundancy information. As someone working directly in the field, it's saved me the effort of hunting up original research papers in many areas. One drawback for this book as a practical tool: the pseudocode used to illustrate examples is often pretty far from being suitable for real implementations.A warning: this is not an introductory book, and people who want to learn about the basics of building a compiler should look elsewhere; perhaps Andrew Appel's ``Modern Compilers'' series. Muchnick's book is for people who want to write compilers which generate high-performance code.