A book like this should have been published half a decade ago. It satisfies several needs beautifully. It shows how high-level language constructs can be mapped onto corresponding real machine instructions and uses this mapping to illustrate why the 68000 architecture includes certain features but omits others. Consistent with its stated goals, the book does not offer the algorithms to perform the actual mapping; that is left to compiler writing texts. The three major values of this text, the introduction to 68000 assembly language programming, the discussion of compiler principles for 68000 targets, and the coverage of the interaction between computer architecture and software writing, by far outweigh its minor shortcomings. It is a suitable supplemental textbook for compiler construction and computer architecture classes at the third-year level.
Chapters 1 to 3 cover 68000 machine objects and binary number representation including fixed-point and extended arithmetic, introduce the power and pitfalls of assembly language programming, and explain the 68000 machine architecture. The Motorola processor comes across as a powerful engine that makes us wonder whether the winner in the competition between CISC and RISC may be the complex instruction set architecture after all.
Chapters 4 to 8 clarify how to map Pascal source constructs onto 68000 machine instructions and objects. The author uses the effective didactic trick of making the readers assume the role of the compiler. In our minds we play compiler, which is fun and saves the author from having to explain the nitty-gritty detail of compiler algorithms. Chapter 5 maps composite Pascal data structures onto simple machine objects. Even popular compiler texts fail to explain the translation of multiple qualified record names, but this text does and convinces the reader that this translation is easy. It thoroughly explains the packed Pascal attribute, its associated reduced data storage requirement, and the growing need for instruction space and makes us aware of the resulting tradeoff. Most satisfying is the coverage of the case statement and its corresponding 68000 assembly language. This interesting topic is treated exhaustively by including even the special cases for which no branch table should be emitted by a good compiler. Chapter 8 offers straightforward 68000 implementations for the complex mechanisms of recursive calls, return, and parameter passing. It includes the addressing of intermediate-level global variables.
Chapter 9 introduces LISP and shows how easily LISP can be compiled for the 68000. We learn about LISP objects, the need for the runtime heap and stack, garbage collection, and the similarity of LISP function application to the Pascal function call. Minor subjective claims, such as LISP being a higher-level language than Pascal, barely disturb the subject proper. Chapter 10 covers Prolog as chapter9 did LISP, except that the 68000 processor is discussed only in passing. Finally, the appendices demonstrate the rich addressing modes of the Motorola processor and list all assembler instructions used in the book. A compendium of all instructions is not included.
The only major flaw is chapter 10. It discusses in detail the internal organization of Prolog systems and the logical representation of Prolog’s objects and contrasts them with LISP, yet fails to explain how this can all be mapped into 68000 assembler. The LISP coverage alone would have been sufficient; the space for chapter 10 should have been used for something more fitting. Other minor flaws include a limited view of the Pascal set data type and the omission of a specification of the number of bits for literal operands in 68000 instructions. These flaws do not seriously diminish the value of the book, however.
One of the great values of this text, which seems to start as an introduction to 68000 assembly language programming, is the broad and complete coverage of assembly language, machine architecture, and compiler design principles. Appreciating and understanding the interrelationship of machine architecture and software writing is an elusive yet important goal; this book satisfies the goal masterfully by using principles of compiler design to tie machine architecture and software design together. Besides, compiler writing is exciting and the author succeeds in passing his enthusiasm on to the reader.
Even the best compilers sometimes do not use the complete mix of machine instructions to translate a source language. This text makes a clean distinction between a machine’s full instruction set and that subset actually used by a compiler, a curious differentiation rarely mentioned in the literature.
The author links numeric representation on the 68000 processor--especially extended arithmetic--with the concept of big nums in LISP. Numeric representation on a physical machine could be an almost dangerously boring subject. Arbitrary-precision arithmetic is one of the extraordinary, powerful capabilities of the LISP language. The author points out that it is astonishing that so few programming languages, all eminently capable of processing numbers, produce numeric values greater than what fits into a scalar machine word. The text successfully integrates the arbitrary precision requirement of LISP with its natural solution on the 68000 architecture.
I recommend this text highly as an introduction to 68000 assembly programming. The book is a perfect supplement for compiler writing courses that target the 68000, particularly if the source language is Pascal or LISP. It also reads well.
