Advanced Compiler Design and Implementation | 
 enlarge | Author: Steven Muchnick
Publisher: Morgan Kaufmann
Category: Book
List Price: $119.00
Buy New: $49.99
You Save: $69.01 (58%)
New (15) Used (6) from $49.99
Avg. Customer Rating:  17 reviews
Sales Rank: 378624
Media: Hardcover
Edition: 1st
Number Of Items: 1
Pages: 856
Shipping Weight (lbs): 3.7
Dimensions (in): 9.4 x 7.4 x 1.7
ISBN: 1558603204
Dewey Decimal Number: 005.453
EAN: 9781558603202
ASIN: 1558603204
Publication Date: August 15, 1997
Availability: Usually ships in 1-2 business days
|
| Also Available In:
|
| Similar Items:
|
| Editorial Reviews:
Amazon.com Review
Optimizing compilers, which turn human-readable programming languages into the smallest, most efficient machine code possible, are among the most complex pieces of software ever written. Building a compiler is both science and black art and demands an intimate knowledge of data structures, algorithms, high-level programming languages, and processor architectures and their instruction sets. Advanced Compiler Design and Implementation presents a comprehensive and technically up-to-date look at design of real-world compilers for CISC- and RISC-based uni-processor architectures. The author led the advanced compiler design and implementation teams for both Hewlett-Packard's PA-RISC and Sun Microsystems's SPARC processors.
Product Description
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 design
This comprehensive, up-to-date work examines advanced issues in the design
and implementation of compilers for modern processors. Written for
professionals and graduate students, the book guides readers in designing
and implementing efficient structures for highly optimizing compilers for
real-world languages. Covering advanced issues in fundamental areas of
compiler design, this book discusses a wide array of possible code
optimizations, determining the relative importance of optimizations, and
selecting the most effective methods of implementation.
* Lays the foundation for understanding the major issues of advanced
compiler design
* Treats optimization in-depth
* Uses four case studies of commercial compiling suites to illustrate
different approaches to compiler structure, intermediate-code design, and
optimizationAA€A”these include Sun Microsystems's compiler for SPARC, IBM's for
POWER and PowerPC, DEC's for Alpha, and Intel's for Pentium an related
processors
* Presents numerous clearly defined algorithms based on actual cases
* Introduces Informal Compiler Algorithm Notation (ICAN), a language devised
by the author to communicate algorithms effectively to people
|
| Customer Reviews: Read 12 more reviews...
 Good, but flawed December 1, 2007
3 out of 3 found this review helpful
This is a very good intermediate/advanced text for codegen & optimization.
Having spent nearly 15 years working on compiler development, with most of it spent on codegen & optimization in compiler backends, I was very happy to see this book published ten years ago when I was relatively new to the field and hungry for more information.
The good: Coverage of many important topics, and a better discussion of the phase ordering issues than I've seen in other texts.
The bad: The writing style is okay, but not great. Little insight is typically given for the problems discussed. A very annoying aspect of the book is that the author sometimes goes into great detail about one technique, and then later mentions another (often superior, IMO) way to solve the problem at hand, without going into much detail. As a working compiler writer, I would have preferred it be the other way around.
The very very bad: The ICAN notation used throughout the book is verbose, unintuitive, and ultimately takes away from the presentation. Compare the complicated detail-filled ICAN listings in this book to the simple, elegant algorithms in the Dragon Book or Cooper/Torczon's text.
 Bible of compiler data-flow analysis September 12, 2007
1 out of 2 found this review helpful
It's the bible of compiler data-flow analysis. The author had the experience of building an industrial strength compiler. One tip: skip books authored by those who haven't implemented an industrial strength compiler by themself.
Great starting point for compiler development March 3, 2007
8 out of 8 found this review helpful
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
 Confusing at best August 17, 2006
5 out of 7 found this review helpful
I've seen chapter 14 of this book referenced (by a university professor giving suggestion to his students, not by a random guy) as:
"Another conventional approach to strength reduction. 35 pages of the same kind of confusing crap we've all come to expect from this book."
This could not sum it up better. A confusing book at best, presenting basic material so as to make it look "advanced", and without any covering of even relatively new techniques. A good source of references to papers that you should read, but not at all a valid reference on its own.
 Good for seasoned compiler writers, bad for CS students December 14, 2004
20 out of 41 found this review helpful
Ok, let's be fair. This book provides a broad coverage of useful optimizations and it will be useful in case you work writing compilers AND have some experience.
However, for learning the concepts, it is a very bad material. At the end you end up confused under a pile of thousands of lines of pseudocode in a weird notation (invented by the author) called "I CAN" (yes you can write a very bad book Mr. Muchnick) instead of reading useful explanations of the topics. The author also assumes that you already know some concepts and that's why he does not explain them as he should. If you want to really understand this book, first review Chapter 10 of the Dragon Book. I thought that the Dragon book was not so good because you have to re read some things in order to fully understand, but with Muchnick's book that is not always possible.
You can also take a look at Morgan's book (unfortunately, out of print) or just read the papers (as the first reviewer suggested). This book is not enough, and sadly, a lot of "teachers" think of it as a kind of "bible" and as a very bad excuse to teach very poorly. Some of them even don't master all the concepts presented there and have to use other books (their "dirty little secret") but they don't tell you which ones and continue praising this bad piece of work. If you are a CS student who really wants to learn, be warned that this book is not for you (it has at least three erratas and still has errors!)
|
|
|
