Buy used:
$14.99 $9.36 per kg
Delivery Friday, October 11. Order within 16 hrs 46 mins
Or fastest delivery Monday, October 7
Used: Good | Details
Sold by usedbooks2ya
Fulfilled by Amazon
Condition: Used: Good
Comment: Cover is clean/shows wear, binding is good, pages are clean/unmarked.

Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.

If you're a seller, Fulfillment by Amazon can help you grow your business. Learn more about the program.

Access codes and supplements are not guaranteed with used items.
Added to

Sorry, there was a problem.

There was an error retrieving your Wish Lists. Please try again.

Sorry, there was a problem.

List unavailable.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

Keith D. Cooper
Follow
Something went wrong. Please try your request again later.

Engineering a Compiler 1st Edition

by Keith D. Cooper (Author), Linda Torczon (Author)
4.5 4.5 out of 5 stars 23 ratings
See all formats and editions

There is a newer edition of this item:

Engineering a Compiler
Engineering a Compiler
$94.95
(17)
Only 16 left in stock (more on the way).
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.
  • 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.
  • Provides end-of-chapter exercises.
Previous slide of product details
  1. ISBN-10
    155860698X
  2. ISBN-13
    978-1558606982
  3. Edition
    1st
  4. Publisher
    Morgan Kaufmann
  5. Publication date
    November 10, 2003
  6. Language
    English
  7. Dimensions
    8 x 1.25 x 9 inches
  8. Print length
    832 pages
  9. See all details
Next slide of product details

Editorial Reviews

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

Review

Distils and illustrates principles and best practices for designing modern compilers

Product details

  • Publisher ‏ : ‎ Morgan Kaufmann; 1st edition (November 10, 2003)
  • Language ‏ : ‎ English
  • Hardcover ‏ : ‎ 832 pages
  • ISBN-10 ‏ : ‎ 155860698X
  • ISBN-13 ‏ : ‎ 978-1558606982
  • Item Weight ‏ : ‎ 4.29 pounds
  • Dimensions ‏ : ‎ 8 x 1.25 x 9 inches
  • Customer Reviews:
    4.5 4.5 out of 5 stars 23 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
Keith D. Cooper

Keith D. Cooper

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read book recommendations and more.

Customer reviews

4.5 out of 5 stars
23 global ratings

Top reviews from the United States

playerdark
5.0 out of 5 stars A good book for the casual reader
Reviewed in the United States on March 21, 2015
Verified Purchase
A good book for the casual reader. I am not a student, but interested in compiler technology. This book is an easy read and can be understood by non academics as well. I would put it on a level with in-depth articles in Dr.Dobb's Journal or comparable magazines. It gives a general overview over the necessary techniques without going into detail, so unless you also use other sources, you won't be able to build a compiler all by yourself, but it is very good to get a first idea of what's behind compilers.
Helpful
 Report
Darlyn Daniel
5.0 out of 5 stars Five Stars
Reviewed in the United States on April 7, 2018
Verified Purchase
Good book, great qualiy !!!
Helpful
 Report
Amrit Kumar Panda
5.0 out of 5 stars Completely upto my expectations
Reviewed in the United States on November 8, 2009
Verified Purchase
The condition in which I received the book was very good and very much upto the standards I had expected. Regarding the book itself, its a wonderful book for computer science engineers.
Helpful
 Report
wiredweird
4.0 out of 5 stars Depends on what you want
Reviewed in the United States on June 12, 2007
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
42 people found this helpful
Helpful
 Report
Jos van Roosmalen
5.0 out of 5 stars Super compiler text!
Reviewed in the United States on February 21, 2005
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...
110 people found this helpful
Helpful
 Report
Mahamed Omran
2.0 out of 5 stars If you are a beginner...Do not buy it
Reviewed in the United States on December 31, 2006
Verified Purchase
I read this book and really did not like it. It is a nightmare for any one new to compilers. It is difficult to read with more emphesis on the backend of the compiler.

The following texts are much better for a beginner:

1. Louden's Compiler construction --> the best text for a beginner.

2. the Dragon book
13 people found this helpful
Helpful
 Report
Ray
5.0 out of 5 stars Good introduction
Reviewed in the United States on December 29, 2003
This book has a good introduction guiding the beginning compiler student into understanding basic concepts and gradually revealing the more intimidating stuff, but the authors took great care not to scare the beginners away and instead offers great indepth explanations into how concepts and implementation merge.
Its an overall good book!
14 people found this helpful
Helpful
 Report
William McColl
4.0 out of 5 stars Four Stars
Reviewed in the United States on April 7, 2015
Verified Purchase
great book
Helpful
 Report