Softcover

ISBN 10: 0138768897 ISBN 13: 9780138768898

Publisher: Prentice Hall, 1993

An introduction to computer architecture for the SPARC reduced instruction set architecture, this text aims to teach users how to evaluate compilers, data structures and control structures in order to write efficient programs in a high-level language.

From the Inside Flap:

Preface to the First Edition

This book is written as an introductory text in computer architecture for the SPARC reduced instruction set architecture. It is assumed that readers have a working knowledge of C and UNIX. The GNU compiler gcc and the gdb debugger are used.

Computer architecture is closely related to assembly language programming, as it is through assembly language programs that the architecture of a machine is made apparent. The presentation of the material breaks from the tradition of computer architecture texts in which assembly language programming was presented as a language in which one might write programs; with a knowledge of the computer architecture, there are, today, a number of high-level languages, such as C, which provide most of the capabilities of assembly language programming. The use of high-level languages results in much higher programmer efficiency and level of representation. It is, however, important to understand the machine at the assembly language level in order to write high-level programs intelligently: to decide between competing data and control structures, the use of global variables and function parameters, the use of recursion, nested procedures, etc. While many of these choices are influenced by high-level factors, the machine architecture has a profound effect on the computational efficiency of the resulting choice.

Although the machine language of a computer is easy to understand, its use results in vast quantities of numeric data that have little meaning. Related to the very heart of computer science is the use of symbol manipulation to simplify and to bring to a clear level of understanding the manipulation and generation of low-level numeric codes. Therefore, symbol manipulation is introduced in the first chapter in the form of the m4 macro processor. Throughout the remainder of the book macros are used to simplify and clarify what is being programmed. The generation of reams of assembly language code is discouraged in favor of the highest level of representation possible.

The computer is introduced by way of the calculator, as most students are familiar with calculators. We make use of the Hewlett-Packard programmable calculator, which reveals many details of machine architectures. The HP calculators have a natural machine language. Assembly language programming is introduced to generate calculator programs making use of m4. A more formal introduction to the machine is presented in the latter half of the first chapter. Stack, accumulator, and load/store machine architectures are also introduced in the first chapter.

The second chapter introduces the SPARC architecture so that students may start programming as early as possible. Like swimming, assembly language programming is not learned in a library! Making use of the machine registers for variable storage, students may start writing short programs by the end of the chapter. The assembler, as, is introduced along with gdb, the debugger. Formatted output is deferred until very late in the book to prevent students from developing the "insert a print statement" mode of program debugging. Instead, gdb is introduced as a natural way to examine memory and registers, and to execute programs. The assembler, as, lacks a macro expansion capability, as it was only designed to be an efficient final pass for the compiler, which has its own macro facilities. In general, we will use the assembler as a second pass to m4, which provides a macro facility. Branching is introduced in the second chapter, as it is difficult to write very interesting programs without branches. Together with branching, pipelining is introduced with the resulting need for delay slot instructions. As the initial specification of the SPARC architecture did not have a multiplication or division instruction, calls to the system routines .mul and .div, etc., are introduced in the second chapter without discussing what happens when the call is made.

As each of the architectural features of the machine is introduced it is related as closely as possible to C language constructs so that students learn the relationship between C and the resulting machine language structures. In the second chapter the control structures of C are introduced in assembly language form. In general, algorithms are written in C and then hand-coded into assembly language. Frequently, optimizations are then seen and the assembly language code optimized. However, we then return to C to learn how the optimized code might have been generated directly from C or why it could not. In this way students learn the problems that compiler writers must face and the reasons why many programs are written the way they are.

Once students are able to write and execute simple assembly language programs, binary logic and arithmetic are introduced. Chapter 3 introduces binary storage devices and number systems: binary, octal, and hexadecimal and their conversions. Bitwise logic operations are introduced and the use of the register %g0, which always yields a zero when used as a source register, effectively increasing the instruction set of the machine. Chapter 4 introduces modulus arithmetic and binary multiplication and division. The treatment of multiplication is fairly extensive, as it is needed to understand the multiply-step instruction of the SPARC architecture. Signed and unsigned comparisons are discussed. The chapter concludes with extended precision arithmetic.

Chapter 5 introduces the stack for the storage of variables. Frames are introduced to provide local storage for functions. The definition of variable offsets is discussed and problems of memory alignment and the load and store instructions. Macros are made use of in the definition of stack offsets and the adjustment of the stack pointer to provide storage. Variables are addressed relative to the frame pointer, which is natural for this architecture. We defer the use of static data until Chapter 9, as their use is clumsy with the SPARC architecture and is not representative of current programming practice.

Chapter 6 introduces multidimensional arrays and structures. Problems of array bound checking and lower bounds differing from zero are discussed along with the problems of dynamic arrays so that students understand the reasons for array addressing restrictions in C. Multiplication by constants for array subscripting is introduced and macros for the automatic generation of multiplication sequences developed in Appendix C. The simplicity of structure addressing is presented so that students understand that arrays, while conceptually simple, are usually a poor choice when structures may be used in their place. Macros are developed for the definition of structure fields and storage allocation.

Functions are then introduced, with discussion of the following: register sets, subroutine linkage, arguments, and return values. Examples are given of simple function calls and of function calls with many arguments or that return aggregates. Finally, leaf routines are presented with their limited register usage.

Chapter 8 introduces the machine language of the SPARC architecture and presents the concepts of instruction decoding and operand access. The handling of 32-bit constants is presented together with program counter relative addressing.

In Chapter 9, global data, initialized data, and addressing methods are discussed. ASCII strings are introduced and formatted output discussed. The switch C statement's translation into assembly language is introduced in this chapter. The handling of C command line arguments is presented along with linking with other code.

Chapter 10 discusses input/output from character devices up through I/O processors. The chapter concludes with a section on system input/output using traps.

It is not until Chapter 11 that floating-point is introduced. Floating-point may be left out of a course without affecting the other material. The concept of additional processors with multiple functional units is discussed as well as the interlocking of the floating-point processor with the integer unit. Single, double, and extended precision number formats are described along with NaN's (not a number) and subnormal numbers.

Chapter 12 discusses supervisor mode, processor state registers, and traps. Register window saving by means of traps is discussed in detail. Interrupts are introduced together with hardware traps. This chapter may also be left out of a course without detracting from the other material.

Chapter 13 introduces sharing of the processor between many users and the mechanisms for so doing. Sharing memory is of primary importance and the SPARC virtual memory mapping, translation lookaside buffer, and cache memory system are presented. The chapter concludes with a discussion of context switching.

Chapter 14 presents some alternative architectures, the PDP-11 for historical interest, the VAX as an example of a CISC machine, and the MIPS RISC machine as a contemporary architecture. This chapter may also be left out of a course without detracting from the other

From the Back Cover:

Written from a programmer's perspective, this book introduces the SPARC assembly language to readers early on. Other introductory material encompasses making use of UNIX® tools (the m4 macro processor, the assembler, the gnu emacs editor, and the gdb debugger). Further coverage includes a formal definition of the von Neumann machine, its relationship to programmable calculators, and to the JAVA™ bytecode and JAVA virtual machine. This book's loyal audience has been anticipating a revision of a very successful book for this growing market. Not only is this book suitable for introductory computer architecture courses, but for programmers who will be programming SPARC architecture machine in languages such as C and C++.

• Provides reader understanding of the complexity and cost of using various data and control structures in high-level languages
• Includes the latest material on the new Ultra SPARC architecture
• Frequent references to C and C++ language constructs and their translation into SPARC assembly language
• Offers optional material on floating point, traps, memory management, and other architectures
• Companion Website supplements the text with updates and code examples at http://www.prenhall.com/paul