- STAFF PICKS
- GIFTS + GIFT CARDS
- SELL BOOKS
- FIND A STORE
New Trade Paper
Ships in 1 to 3 days
available for shipping or prepaid pickup only
Available for In-store Pickup
in 7 to 12 days
SPARC Architecture, Assembly Language Programming, and Cby Richard P. Paul
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 material.
Appendices include the macro definitions used in the book, the use of macros to generate an open subroutine for integer multiplication by constants, the user mode instruction set, a table of powers of 2, and the description of m4.
In an introductory course for students, Chapters 1 through 9 would logically be followed in order. Additional material could then be selected by the instructor: system I/O, floating-point, traps, virtual memory, other architectures; each of these chapters is independent and may be covered in any order.
For the professional reader, Chapter 2 provides an introduction, followed by the discussion of multiplication on the SPARC at the end of Chapter 4. This should then be followed by Chapters 5 through 13. The appendices provide all the necessary reference material for those interested in user mode programming. The text should be supplemented by the SPARC architecture manual for the professional programmer.
The book was produced by the Latex document preparation system 13 and postscript files were generated by Textures. Figures were drawn using the xfig program.
Mark Foster helped with gdb and the UNIX operating system and provided extensive proofreading corrections. Craig Sayers assisted with the interpretation of the architecture and with technical aspects of the presentation. Angela Lai corrected the Instruction Set Appendix. Doug Nelson provided almost instant responses to my many questions relating to Sun. Horst Hogenkamp assisted with a very careful proofreading and suggestions for clarifying the presentation. Carl Bredlau offered support and thoughtful comments, suggestions, and corrections. Rina Ramamurthy and John Turner assisted with careful reviews and comments. Mel Paul assisted with revisions and editorial changes. Raymond McKendall was extremely helpful with the formatting of the final version of the book. My thanks to all the above. I also wish to thank Tom McElwee, Bill Zobrist, and Jennifer Wenzel at Prentice Hall, who made publication of the book such a pleasant and straightforward matter. Appendix D, Appendix E, and Appendix H are printed with permission from Sun Microsystems, Inc.
Preface to the Second Edition
Since the first edition of the book Sun has announced both a superscalar version of the architecture and an increase in the memory address size from 32 bits to 64 - the Ultra SPARC. The architecture remains binary compatible with the original, which is discussed in detail in the book. A new chapter has been added to describe the new Ultra SPARC architecture, its additional instructions, its compatibility with the existing architecture, and changes to the supervisor mode.
A number of other changes have been made throughout the book to keep it current. The description of the Burroughs B5000, as an example of a stack architecture, has been replaced by a description of a version of the Java virtual machine to support the integer bytecode instructions together with a simulator written in C. New tools are provided for debugging double-precision programs. An extended discussion and example of tagged arithmetic has been added. New exercises have been included. The description of pipelining has been rewritten with a more detailed example. The example of division has been brought into line with the description of multiplication.
A number of people have helped with the preparation of the second edition. Raymond McKendall provided vital Latex support. Jorgen Wahlsten, Dave Reed, and Kostas Daniilidis helped with errors in the book. Joe Bissell provides corrections and pointed out that m4 now includes bitwise operators. Petra Recter, Barbara Till, and Alan Apt of Prentice Hall made the publication of the second edition as straightforward as the first. I also wish to thank reviewers Carl Bredlau and Peter Jones for their helpful insights. Alex Malex helped with Unix system problems and Sean Sheridan with the Web pages. Mel Paul helped with revisions and editorial changes.
Richard P. Paul
Availability of Software
Latest updates to the book may be obtained from the following Web site:
At this site you will also find all the software to accompany this text, macro definition files, and all example programs in the text. The example programs and files may be downloaded together or accessed individually from the Web. To obtain an instructors manual, which includes the originals for all figures and tables suitable for making slides and solutions to exercises, you should contact your Prentice Hall sales representative.
What Our Readers Are Saying
Other books you might like