The world of compiler design has changed significantly.
Programming languages have evolved to present new compilation problems.
Computer architectures offer a variety of resources of which the compiler
designer must take advantage. Perhaps most interestingly, the venerable
technology of code optimization has found use outside compilers. It is now used
in tools that and bugs in software, and most importantly, and security holes in
existing code. And much of the front-end technology the grammars, regular
expressions, parsers, and syntax-directed translators are still in wide use.
This book is very useful for the beginners and professionals
as well. Beside all the core concepts this book also contains extensive
exercises, with some for almost every section. The harder exercises or parts of
exercises with an exclamation point. The hardest exercises have a double
exclamation point. Here is an outline of the chapters included in this book.
Chapter 1 contains motivational material and also presents
some background issues in computer architecture and programming-language
principles.
Chapter 2 develops a miniature compiler and introduces many
of the important concepts, which are then developed in later chapters. The
compiler itself appears in the appendix.
Chapter 3 covers lexical analysis, regular expressions, finite-state
machines, and scanner-generator tools. This material is fundamental to
text-processing of all sorts.
Chapter 4 covers the major parsing methods, top-down
(recursive-descent, LL) and bottom-up (LR and its variants).
Chapter 5 introduces the principal ideas in syntax-directed
definitions and syntax-directed translations.
Chapter 6 takes the theory of Chapter 5 and shows how to use
it to generate intermediate code for a typical programming language.
Chapter 7 covers run-time environments, especially management
of the run-time stack and garbage collection.
Chapter 8 is on object-code generation. It covers
construction of basic blocks, generation of code from expressions and basic blocks,
and register-allocation techniques.
Chapter 9 introduces the technology of code optimization,
including flow graphs, data-flow frameworks, and iterative algorithms for
solving these frameworks.
Chapter 10 covers instruction-level optimization. The
emphasis is on the extraction of parallelism from small sequences of instructions
and scheduling them on single processors that can do more than one thing at
once.
Chapter 11 talks about larger-scale parallelism detection and
exploitation. Here, the emphasis is on numeric codes that have many tight loops
that range over multidimensional arrays.
Chapter 12 is on inter-procedural analysis. It covers pointer
analysis, aliasing, and data-flow analysis that takes into account the sequence
of procedure calls that reach a given point in the code.
0 comments:
Post a Comment