1. Edition - March 2010
99.90 Euro
2010. 296 Pages, Hardcover
ISBN-10: 0-470-50095-6
ISBN-13: 978-0-470-50095-8 - John Wiley & Sons









Short description
This unique guide book explains and teaches the concept of trustworthy compilers based on 50+ years of worldwide experience in the area of compilers, and on the author's own 30+ years of expertise in development and teaching compilers. It covers the key topics related to compiler development as well as compiling methods not thoroughly covered in other books. The book also reveals many state-of-the-art compiler development tools and personal experience of their use in research projects by the author and his team. Software engineers of commercial companies and undergraduate/graduate students will benefit from this guide.

From the contents
Preface.

Chapter 1 Introduction.

1.1 The concept of trustworthy compiler.

1.2 Kinds of compilers.

1.3 Evolution of Java compilers.

1.4 Compilation for .NET.

1.5 Phases of compilation.

1.6 Overview of compiler development principles and technologies.

1.7 History of compiler development in the USSR and in Russia.

Exercises to Chapter 1.

Chapter 2 Theoretical foundations and principles of trustworthy compilers.

2.1 The trustworthy computing initiative.

2.2 Trustworthy computing and trustworthy compilers.

2.3 Verified compilers.

2.4 Spec#: Microsoft's approach to verifying compilers.

2.5 Perspectives of verified and verifying compilation.

Exercises to Chapter 2.

Chapter 3 Lexical analysis and its trustworthiness principles.

3.1 Token classes.

3.2 The output of the lexical analyzer.

3.3 Processing white spaces, comments, and new lines.

3.4 Theoretical models of lexical analysis.

3.5 Lexical errors, error diagnostics and recovery.

3.6 Processing identifiers and keywords.

3.7 The architecture of lexical analyzer and principles of its implementation.

3.8 The lexical analyzer generator lex.

3.9 Lexical analyzer generation in ANTLR.

Exercises to Chapter 3.

Chapter 4 Parsing and trustworthy methods of error recovery.

4.1 Basic concepts and principles of parsing.

4.2 Recursive descent and simple lookahead mechanism.

4.3 Overview of error recovery in parsing. Error recovery for recursive descent.

4.4 LR(1) and LALR(1) parsing.

4.5 Error recovery in LR parsing.

4.6 The yacc parser generator.

4.7 The bison parser generator. Generalized LR parsing.

4.8 The yacc++, JavaCC, SableCC, ANTLR, and CoCo/R object-oriented parser generators.

Exercises to Chapter 4.

Chapter 5 Semantic analysis and typing: efficient and trustworthy techniques.

5.1 Basic concepts and principles of semantic analysis.

5.2 Formal model of semantic analysis: attributed grammars.

5.3 Definition systems with forward references, and the algorithm of their one-pass analysis.

5.4 Common use semantic attributes for program constructs.

5.5 Design flaws of semantic attribute evaluation, and our efficient methods to speed it up.

5.6 Lookup - traditional and novel techniques.

5.7 Typing and type-checking: basic concepts.

5.8 Representing types at compile time.

5.9 Efficient method and algorithm to represent and handle types with structural identity.

5.10 Type identity and type compatibility.

5.11 Type-checking, typing error diagnostics and recovery.

5.12 Code trustworthiness checks in semantic analysis.

5.13 Checks for context restrictions in semantic analysis.

5.14 Intermediate code generation - principles and architectural models.

5.15 Postfix (reverse Polish) notation.

5.16 PCC trees.

5.17 Triples.

5.18 Summary of the chapter.

Exercises to Chapter 5.

Chapter 6 Trustworthy optimizations.

6.1 Basic concepts and trustworthiness of optimizations.

6.2 Optimizations and mixed computations.

6.3 Overview of the most common kinds of optimizations.

6.4 Control flow and data flow dependencies.

6.5 Static single assignment (SSA).

6.6 Data structures constructed and used by the optimizer.

6.7 Optimization in Sun Studio compilers.

6.8 Optimizations of Java bytecode.

6.9 Optimizations of .NET CIL code.

6.10 Optimizations during JIT compilation.

Exercises to Chapter 6.

Chapter 7 Code generation and runtime data representation.

7.1 Target platforms for code generation.

7.2 Overview of code generation tasks and goals.

7.3 Specifics of code generation for .NET.

7.4 Specifics of code generation for SPARC architecture.

7.5 Representing types and addressing variables.

7.6 Representing procedures, functions, and methods.

7.7 Principles of SPARC architecture.

7.8 Example of code generation for SPARC architecture.

7.9 Generation of debugging information.

7.10 Code generation for declarations (definitions), expressions, and statements.

Exercises to Chapter 7.

Chapter 8 Runtime, JIT, and AOT compilation.

8.1 The tasks of the runtime.

8.2 The relationship of the runtime and the operating system.

8.3 Just-in-time (JIT) compilation.

8.4 The architecture of FJIT - just-in-time compiler for SSCLI / Rotor.

8.5 The architecture of optimizing just-in-time compiler for SSCLI / Rotor.

8.6 Ahead-of-time (AOT) compilation.

Exercises to Chapter 8.

Chapter 9 Graph grammars and graph compilers.

9.1 Basic concepts of graph grammars and graph compilers.

9.2 Categorical approach to graph transformations.

9.3 Reserved graph grammars.

9.4 Layered graph grammars.

9.5 Meta-modeling approach to graph grammars and DiaMeta editor.

9.6 Hypergraph approach to graph grammars in DiaGen.

9.7 Graph compiler generation tools.

Exercises to Chapter 9.

Chapter 10 Microsoft Phoenix, Phoenix-targeted tools, and our Phoenix projects.

10.1 History of Phoenix and of our Phoenix projects.

10.2 Overview of Phoenix architecture.

10.3 Phoenix-based tools, passes, phases, and plug-ins.

10.4 Phoenix primitives. Strings and names.

10.5 Phoenix internal representation (IR).

10.6 Phoenix symbol system.

10.7 Phoenix type system.

10.8 Data flow analysis, control flow analysis, graphs and static single assignment in Phoenix.

10.9 Overview of other Phoenix features.

10.10 Example of a Phoenix-based plug-in.

10.11 Phoenix-FETE - a compiler front-end development toolkit and environment targeted to Phoenix.

10.11.1 Architectural specifics of Phoenix-FETE.

10.11.2 The input grammar meta-language.

10.11.3 The current status of the implementation.

Exercises to Chapter 10.

Conclusions.

Reference.

Index.