Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Colour:
Image not available

 
Tell the Publisher!
I’d like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Engineering a Compiler [Hardcover]

Keith Cooper , Linda Torczon
4.0 out of 5 stars  See all reviews (1 customer review)

Available from these sellers.


Formats

Amazon Price New from Used from
Hardcover --  
Paperback --  
There is a newer edition of this item:
Engineering a Compiler Engineering a Compiler
£44.04
In stock.

Book Description

1 Jan 2002 155860698X 978-1558606982
The proliferation of processors, environments, and constraints on systems has cast compiler technology into a wider variety of settings, changing the compiler and compiler writer's role. No longer is execution speed the sole criterion for judging compiled code. Today, code might be judged on how small it is, how much power it consumes, how well it compresses, or how many page faults it generates. In this evolving environment, the task of building a successful compiler relies upon the compiler writer's ability to balance and blend algorithms, engineering insights, and careful planning. Today's compiler writer must choose a path through a design space that is filled with diverse alternatives, each with distinct costs, advantages, and complexities. "Engineering a Compiler" explores this design space by presenting some of the ways these problems have been solved, and the constraints that made each of those solutions attractive. By understanding the parameters of the problem and their impact on compiler design, the authors hope to convey both the depth of the problems and the breadth of possible solutions. Their goal is to cover a broad enough selection of material to show readers that real tradeoffs exist, and that the impact of those choices can be both subtle and far-reaching. Authors Keith Cooper and Linda Torczon convey both the art and the science of compiler construction and show best practice algorithms for the major passes of a compiler. Their text re-balances the curriculum for an introductory course in compiler construction to reflect the issues that arise in current practice. This work: focuses on the back end of the compiler - reflecting the focus of research and development over the last decade; uses the well-developed theory from scanning and parsing to introduce concepts that play a critical role in optimization and code generation; introduces the student to optimization through data-flow analysis, SSA form, and a selection of scalar optimizations; builds on this background to teach modern methods in code generation: instruction selection, instruction scheduling, and register allocation; presents examples in several different programming languages in order to best illustrate the concept; and, provides end-of-chapter exercises, with on-line solutions available to instructors.

Customers Who Viewed This Item Also Viewed


Product details

  • Hardcover: 801 pages
  • Publisher: Morgan Kaufmann Publishers In (1 Jan 2002)
  • Language: English
  • ISBN-10: 155860698X
  • ISBN-13: 978-1558606982
  • Product Dimensions: 3.5 x 20 x 22.5 cm
  • Average Customer Review: 4.0 out of 5 stars  See all reviews (1 customer review)
  • Amazon Bestsellers Rank: 1,629,797 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description

Review

Keith Cooper and Linda Torczon are leading compilers researchers who have also built several state-of-the-art compilers. This book adeptly spans both worlds, by explaining both time-tested techniques and new algorithms, and by providing practical advice on engineering and constructing a compiler. Engineering a Compiler is a rich survey and exposition of the important techniques necessary to build a modern compiler. -Jim Larus, Microsoft Research A wonderful introduction to the theory, practice, and lore of modern compilers. Cooper and Torczon convey the simple joys of this subject that follow from the elegant interplay between compilation and the rest of computer science. If you're looking for an end-to-end tour of compiler construction annotated with a broad range of practical experiences, this is the book. -Michael D. Smith, Harvard University Modern compilers have played critical roles in areas such as software development tools, application performance, and processor design. This book has done an excellent job of illustrating various state-of-the-art technologies for an advanced compiler, in particular, optimization and code generation, the core of modern compilers. Compilers have evolved into complicated software and what makes a good compiler largely lies in the wisdom of engineering during design and development. The readers of this book can certainly learn how to construct a modern compiler with various engineering trade-offs. -Roy Ju, Senior Researcher,Microprocessor Research Labs, Intel Corp. As researchers, the authors have made major contributions to the literature and as teachers, they have produced leaders in the field. The combination is reflected in a book that is rich with the insight of great research and written with the clarity of experienced teachers. The result is an outstanding text. -Steve Blackburn, The Australian National University

About the Author

Dr. Cooper, Professor, Dept. of Computer Science at Rice University, is the leader of the Massively Scalar Compiler Project at Rice, which investigates issues relating to optimization and code generation for modern machines. He is also a member of the Center for High Performance Software Research, the Computer and Information Technology Institute, and the Center for Multimedia Communication -- all at Rice. He teaches courses in Compiler Construction at the undergraduate and graduate level. Linda Torczon is a principal investigator on the Massively Scalar Compiler Project at Rice University, and the Grid Application Development Software Project sponsored by the next Generation Software program of the National Science Foundation. She also serves as the executive director of HiPerSoft and of the Los Alamos Computer Science Institute. Her research interests include code generation, interprocedural dataflow analysis and optimization, and programming environments.

Inside This Book (Learn More)
First Sentence
The role of computers in daily life is growing each year. Read the first page
Explore More
Concordance
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

What Other Items Do Customers Buy After Viewing This Item?


Customer Reviews

5 star
0
3 star
0
2 star
0
1 star
0
4.0 out of 5 stars
4.0 out of 5 stars
Most Helpful Customer Reviews
0 of 5 people found the following review helpful
4.0 out of 5 stars It says everything you need to know 24 April 2010
Format:Paperback
It says everything you need to know. Easy to read and understand. Very good.Engineering a Compiler: International Student Edition
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 3.4 out of 5 stars  11 reviews
113 of 113 people found the following review helpful
5.0 out of 5 stars Super compiler text! 21 Feb 2005
By Jos van Roosmalen - Published on Amazon.com
Format:Hardcover
This is really a super compiler text. It is also one of the most recent compiler books you can buy.

First of all this is a theoretical book. If you read the title 'Engineering a compiler' as 'Coding/Building a compiler' you would be disappointed! So, if you're looking for a learing-by-coding book, this is not for you (but I have some recommendations at the end of this review in the latest paragraph). The difference with most of the other theoretical books is that this book is not a dry text. It has also a nice layout. It gives plenty of examples, and all topics are well connected to each other. It's a pleasure to read for not native English people, so native English people can read it pretty fast.

This book read like a novel.. It does contain enough diagrams, tables, etc. but not too much (crowded), and everything is well explained.

You can read this book as a compiler introduction book. But I can only recommend this to B.Sc/M.Sc Computer Science students (like me). You don't need to have a M.Sc in Mathematics to understand this text, (all the math, eg. liveness graphs are well explained), but you will understand everything better if you have some background in algorithms (design), pseudocode, etc. like you gained during your B.Sc program. People without formal computer science education I would recommend to read a practical book first (see at the end of this review), because you may find else this text too theoretical.

This book focus on code optimizations. According to the authors (and me) compiler front ends (scanning/parsing/etc) are commodities today, and the backend (codegeneration) is where the difference is made nowadays. So if you're looking for a introduction text into compiler optimization this book is for you!

If you're looking for a more practical book I advice you to read 'Programming Language Processors in Java' from Watt & Brown. In that book you learn to build a nice stack virtual machine in Java with 'advanced features' like records (structs), procedures/functions, arrays and so on. That book is a good companion for 'Engineering a Compiler' to give you some practical insight. If you're looking for a Language Design book I advice you to look at 'Programming Language Pragmatics'. Both books are worth the money...
42 of 42 people found the following review helpful
4.0 out of 5 stars Depends on what you want 12 Jun 2007
By wiredweird - Published on Amazon.com
Format:Hardcover|Verified Purchase
What it is: A great introduction to basic concepts in contemporary compilers.

What it's not: A handbook for someone thrown in at the deep end of commercial compiler development.

I can imagine a very good one-term course in compiler construction built around this text. After a brief introduction, it gets immediately into the classic topics of lexical scanning, parsing, and syntax analysis. These three chapters help any beginner understand the multiple levels of processing, from the character level, up through reorganizing grammars for practical parsing and table-driven techniques, to the lower levels of sematic analysis. This includes a very brief discussion of type systems and type inference - less than 20 pages, on a topic that whole books devote themselves to. These 200 pages typify what you'll see in the rest of the book: a lot of attention paid to lexical analysis, a problem largely eliminated by automated tools (lex and yacc being the best known), and thin mention of the harder problems that differ significantly across languages and applications of languages.

Chapter 5 addresses the critical issue of intermediate representation, the data structures that represent the program during analysis, optimization, and code generation. Chapter 6 is titled "The Procedure Abstraction." It deals with much more than its name suggests, including procedure activation records (generalizations of stack frames), parameter passing, stack management, symbol visibility and scoping, and scraps of symbol table organization - important stuff, but hard to understand as "procedure abstaction." The next chapter deals with "Code Shape," a grab-bag including value representations, arrays and strings, control constructs, and procedures (again). It also presents a very few pages, at the end, on object oriented language - hardly enough to scratch the surface, let alone build competence. And, for lack of a better place to stick them, I would have expected support for parallelism and exceptions to appear here, but this book seems to omit the topics altogether.

Code analysis and optimization appear in chapters 8-10. That includes a competent introduction to static single assignment notation, a staple of current compiler technology mentioned earlier, in the section on intermediate representation. This covers a range of basics, but omits all significant mention of arrays, the workhorses of performance computing. Chapters 11-13 introduce the basics of instruction selection, scheduling, and register allocation. Although it mentions some hardware effects, like out-of-order execution in superscalar architecture, discussion stays close the instruction sets of popular processors. As a result, it omits mention of SIMD, VLIW, DSP, and more exotic architectures, the ones most in need of good code generation. Compiler-specific support libraries, e.g. the kind that make up for lack of hardware divide instructions, should have appeared somewhere around here, but are oddly absent.

The authors present an adequate introduction for the beginner, someone who's still not sure what a hash table is (see appendix B). It introduces many basic topics, but doesn't go into a lot of depth in any of them. The student who finishes this book will understand most major issues of classical compiler construction. I just can't see a serious, working competence coming out of this text, though. I give it four stars as an academic introduction, but a lot less for anyone with immediate problems to solve.

-- wiredweird
24 of 24 people found the following review helpful
4.0 out of 5 stars A great starter guide to writing a compiler 9 Jun 2005
By Todd King - Published on Amazon.com
Format:Hardcover
I recently used this book to supplement the Dragon book in a Compilers course. I found this book so much easier to read and understand. They do a great job of laying out the basics and introducing you to compiler design.

I also liked how they seemed to keep an open mind about which intermediate representation is best to use. They discuss the pros and cons of graphical IRs vs Linear IRs, and let you decide which best fits your needs.

Their open mindedness ended when it came to optimization though. I got the impression that the authors consider SSA (static single assignment) form to be the silver bullet of optimization. Almost all of the optimizations they discuss in this book rely on your IR being in SSA form! I agree that SSA form does indeed make many optimizations much easier, but there is a very high initial cost involved in converting to and from SSA form. In there defense they spend almost an entire chapter on how to do these conversions.

So to sum up, this book does a great job of introducing you to compiler design. It is well written and very easy to understand. It also does a good job of discussing different compiler design choices and their pros and cons. The only short coming of this book is that the entire optimization discussion is revolves around SSA form.
33 of 36 people found the following review helpful
4.0 out of 5 stars I'd rather call it "A guide for engineering a compiler" 2 Sep 2004
By H. Kim - Published on Amazon.com
Format:Hardcover
This book deals with all the issues you will face while engineering a MODERN compiler. Each subject is rather a brief instroduction than a thorough discussion, but detailed enough to give readers a good introduction working as a good pointer when you need a more detailed information.

Also the author tries very hard to cover as much subjects as possible you have to deal with when you design a language and implment a compiler for it.

I'd use this book not as a thorough compiler algorithm bible but as a guide to follow when implementing my compiler.

By following each chapter in the book, at least you will know what problems you should slove. If the problem is simple enough, the solution is in the book. For more complicated problems, you gotta dig into the internet.

In my opinion, this book is the best compiler engineering guide ever I read.
10 of 11 people found the following review helpful
4.0 out of 5 stars Best introductory codegen/optimization book out there 1 Dec 2007
By Mark Lacey - Published on Amazon.com
Format:Hardcover
I've been working on commercial development tools for nearly 15 years now, with most of that time spent on compilers, and most of the compiler time spent on optimization and code generation.

The strength of this book is that it is a good introduction to modern compiler design, with many up-to-date techniques and references to recent papers. The authors present many algorithms in a very easy-to-grasp manner, and provide useful engineering insights. I've focused almost exclusively on the codegen/optimization sections of the book, so I can't say much about the chapters on parsing and semantic analysis.

The weakness of the book is that they don't discuss some important topics related to the areas that they do cover well. For example, pointer disambiguation, and what effect pointers and aliasing have on SSA form. There is no discussion whatsoever of this topic when they talk about things like dead code elimination. The SSA-based algorithm they present there has a first step of "mark all the needed operations as needed", but there is no discussion of what this means for writes to dereferenced pointers, or the trade-offs you face there (e.g. marking all writes to dereferenced pointers is inexpensive, but conservative, but the analysis required to mark only those dereferences that are truly necessary can be expensive and/or completely subsume the liveness issue they are trying to solve inexpensively with this SSA-based algorithm).

Having read many journal articles on optimization, this is unfortuntately common in the literature as well.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   


Look for similar items by category


Feedback