An instructor could use this text for more than one semester. The authors suggest using the first seven chapters, containing the basic syntax and instructions for the MC68000, along with selected chapters on key application areas, for a one-semester course. Additional chapters dealing with more complex topics can support further work. Suggested support materials include Motorola manuals, a simple simulator of a one-register 68000-equivalent machine running under most popular operating systems, and a complete 68000 assembler (the latter two are available from the publisher or the authors.) Most of the example programs and I/O libraries in the text are written with the Motorola Educational Computer Board (ECB) in mind, and a few others are for the Macintosh environment. Each chapter has a short introduction; a discussion of the instructions being introduced, including the instruction syntax and examples using the instruction; additional instructions for the 68020/68030/68040 (680x0) systems, where applicable; a set of exercises (answers to odd-numbered exercises appear in an appendix); and programming exercises (answers appear in the instructor’s manual). The exercises are in short question style, while the programming exercises ask students to write subroutines and test programs.
The first three chapters are the introduction, covering why to learn assembly language, data representation (numeric, binary, hexadecimal, complements, and character), and machine organization.
Chapter 4 begins the formal approach to the MC68000 assembly language. The authors present its syntax and some assembly language directives students need to begin programming. Some simple addressing modes and instructions are discussed so students can write programs immediately. Input/output routines are also supplied so students can do numeric I/O without worrying about device handling and more complex instructions.
The next chapter introduces condition codes and branching instructions. Since programs are not straight lines, structured programming is discussed. The integer arithmetic instructions “multiply” and “divide” are added to the list. The array and stack data structures serve as the motivation for additional addressing modes, and these data structures are used in simple sort algorithms.
The chapter on subroutines is motivated by modular design considerations at the assembly language level. It includes the syntax for the necessary instructions; the subroutine structure when interacting with other blocks of code; and parameter passing conventions.
The chapter on extended arithmetic extends the standard arithmetic operations to 64 bits and introduces floating point numbers in the IEEE standard form and binary-coded decimal (BCD) numbers. These operations are represented by library calls to subroutines that are developed in the chapter. The authors also include the 680x0 additional instructions on bit fields, multiply and divide, and BCD pack and unpack.
A chapter is devoted to manipulation of null terminated strings. Copy, insert, comparison, conversion of input strings to numeric values, and vice versa are examined as library routines.
Chapter 10 deals with the HLL runtime environment. It discusses a variety of jump table implementations (a basis for case statement implementations); stack frames for subroutines with fixed and variable numbers of arguments; recursion and its effect on the stack; and position-independent code with its different art of programming.
The chapter on data structures is an introduction to a few data structures with some algorithms and programs developed to handle the usual cases. It covers sets as bit strings and their operations; matrices as two-dimensional arrays with an access function in assembly language; other stack uses; queues and queue operations; linked lists and trees with memory allocations and pointer manipulation; and hashing functions.
The communication interface programming assumes the Motorola ECB with its associated peripheral chips for the programming examples. The interface chips are the 6850 ACIA serial interface and the 68230 PI/T parallel interface/timer. The registers for each chip are examined, and polled I/O is used for the example programs: serial (RS232), parallel (Centronics printer), and timer for timing delays.
The chapter on exception processing considers the CPU state, status register, and stack behavior when servicing exceptions. Additional instructions that execute only in the supervisor state are examined. This chapter deals with internal exceptions, and small routines demonstrate exception handling. The additions for exception processing on the 680x0 systems are included here.
The chapter on peripheral device interrupts deals with exceptions due to events outside the CPU. The ECB is used to demonstrate the handling of these interrupts. The authors examine implementing priorities. For each of the peripheral chips discussed earlier running in polled mode, the authors develop a set of routines for using it in interrupt mode.
The last chapter deals primarily with the 68020 and later processors. The material here is introductory. Topics include the coprocessor interface, adjuncts to operating system programming (semaphores), cache control, the floating point coprocessor, and the memory management unit (MMU) (virtual memory).
The book contains a series of appendices: an alphabetical list of the integer instructions; a list of supervisor (privileged) instructions; coprocessor instructions; a listing of input/output libraries used in the text; and answers to the odd-numbered exercises. The inside covers contain the ASCII character table and the exception vector table. The Instructor’s Guide contains answers for the programming exercises.
This work is a good textbook for teaching 68000 assembly language, since it contains example programs using the instructions as they are introduced. This portion of the text has few prerequisites. For the additional chapters on advanced topics, a knowledge of operating systems may be required.
