Engineering a compiler second edition by linda torczon   super compiler text
Upcoming SlideShare
Loading in...5
×
 

Engineering a compiler second edition by linda torczon super compiler text

on

  • 557 views

 

Statistics

Views

Total Views
557
Views on SlideShare
557
Embed Views
0

Actions

Likes
0
Downloads
1
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Engineering a compiler second edition by linda torczon   super compiler text Engineering a compiler second edition by linda torczon super compiler text Document Transcript

  • Engineering a Compiler, Second Edition by Linda Torczon Depends On What You Want This entirely revised second edition of Engineering a Compiler is full oftechnical updates and new material covering the latest developments incompiler technology. In this comprehensive text you will learn importanttechniques for constructing a modern compiler. Leading educators andresearchers Keith Cooper and Linda Torczon combine basic principles withpragmatic insights from their experience building state-of-the-art compilers.They will help you fully understand important techniques such ascompilation of imperative and object-oriented languages, construction ofstatic single assignment forms, instruction scheduling, and graph-coloringregister allocation. In-depth treatment of algorithms and techniques used in the front end ofa modern compiler Focus on code optimization and code generation, theprimary areas of recent research and development Improvements inpresentation including conceptual overviews for each chapter, summariesand review questions for sections, and prominent placement of definitionsfor new terms Examples drawn from several different programminglanguages Changes This Edition The second edition of Engineering a Compiler presents bothperspectives: big-picture views of the problems in compiler constructionand detailed discussions of algorithmic alternatives. In preparing thesecond edition of Engineering a Compiler, we focused on the usability ofthe book, both as a textbook and as a reference for professionals.Specifically, we: Improved the flow of ideas to help the student who reads the booksequentially. Chapter introductions explain the purpose of the chapter, layout the major concepts, and provide a high-level overview of the chapter’ssubject matter. Examples have been reworked to provide continuity acrosschapters. In addition, each chapter begins with a summary and a set ofkeywords to aid the user who treats Engineering a Compiler as a reference
  • book. Added section reviews and review questions at the end of eachmajor section. The review questions provide a quick check as to whetheror not the reader has understood the major points of the section. Moveddefinitions of key terms into the margin adjacent to the paragraph wherethey are first defined and discussed. Revised the material on optimizationextensively so that it provides broader coverage of the possibilities for anoptimizing compiler. Compiler development today focuses onoptimization and on code generation. A newly hired compiler writer is farmore likely to port a code generator to a new processor or modify anoptimization pass than to write a scanner or parser. The successfulcompiler writer must be familiar with current best-practice techniques inoptimization, such as the construction of static single-assignment form,and in code generation, such as software pipelining. They must also havethe background and insight to understand new techniques as they appearduring the coming years. Finally, they must understand the techniques of scanning, parsing, andsemantic elaboration well enough to build or modify a front end. Our goalfor the second edition of Engineering a Compiler has been to create a textand a course that exposes students to the critical issues in moderncompilers and provides them with the background to tackle thoseproblems. We have retained, from the first edition, the basic balance ofmaterial. Front ends are commodity components; they can be purchasedfrom a reliable vendor or adapted from one of the many open-sourcesystems. At the same time, optimizers and code generators are custom-crafted for particular processors and, sometimes, for individual models,because performance relies so heavily on specific low-level details of thegenerated code. These facts affect the way that we build compilers today;they should also affect the way that we teach compiler construction. Read a Sample Chapter from Engineering a Compiler on PracticalIssues Even with automatic parser generators, the compiler writer must manageseveral issues to produce a robust, efficient parser for a real programminglanguage. This chapter addresses several issues that arise in practice.My Personal Review:What it is: A great introduction to basic concepts in contemporarycompilers.What its not: A handbook for someone thrown in at the deep end ofcommercial compiler development.I can imagine a very good one-term course in compiler construction builtaround this text. After a brief introduction, it gets immediately into theclassic topics of lexical scanning, parsing, and syntax analysis. These
  • three chapters help any beginner understand the multiple levels ofprocessing, from the character level, up through reorganizing grammars forpractical parsing and table-driven techniques, to the lower levels ofsematic analysis. This includes a very brief discussion of type systems andtype inference - less than 20 pages, on a topic that whole books devotethemselves to. These 200 pages typify what youll see in the rest of thebook: a lot of attention paid to lexical analysis, a problem largely eliminatedby automated tools (lex and yacc being the best known), and thin mentionof the harder problems that differ significantly across languages andapplications of languages.Chapter 5 addresses the critical issue of intermediate representation, thedata structures that represent the program during analysis, optimization,and code generation. Chapter 6 is titled The Procedure Abstraction. Itdeals with much more than its name suggests, including procedureactivation records (generalizations of stack frames), parameter passing,stack management, symbol visibility and scoping, and scraps of symboltable organization - important stuff, but hard to understand as procedureabstaction. The next chapter deals with Code Shape, a grab-bag includingvalue representations, arrays and strings, control constructs, andprocedures (again). It also presents a very few pages, at the end, on objectoriented language - hardly enough to scratch the surface, let alone buildcompetence. And, for lack of a better place to stick them, I would haveexpected support for parallelism and exceptions to appear here, but thisbook seems to omit the topics altogether.Code analysis and optimization appear in chapters 8-10. That includes acompetent introduction to static single assignment notation, a staple ofcurrent compiler technology mentioned earlier, in the section onintermediate representation. This covers a range of basics, but omi ts allsignificant 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, likeout-of-order execution in superscalar architecture, discussion stays closethe instruction sets of popular processors. As a result, it omits mention ofSIMD, VLIW, DSP, and more exotic architectures, the ones most in needof good code generation. Compiler-specific support libraries, e.g. the kindthat make up for lack of hardware divide instructions, should haveappeared somewhere around here, but are oddly absent.The authors present an adequate introduction for the beginner, someonewhos still not sure what a hash table is (see appendix B). It introducesmany basic topics, but doesnt go into a lot of depth in any of them. Thestudent who finishes this book will understand most major issues ofclassical compiler construction. I just cant see a serious, workingcompetence coming out of this text, though. I give it four stars as anacademic introduction, but a lot less for anyone with immediate problemsto solve.
  • -- wiredweird For More 5 Star Customer Reviews and Lowest Price: Engineering a Compiler, Second Edition by Linda Torczon - 5 Star Customer Reviews and Lowest Price!