Assembly Language for Intel-Based Computers, Fourth Edition is based on the Intel IA-32 Processor architecture, seen from a programmer's point of view. It is appropriate as a text in the following types of college courses for computer science majors:
- Assembly Language Programming
- Fundamentals of Computer Systems
- Fundamentals of Computer Architecture
Although this book was originally designed as a programming textbook for community college students, it has gradually developed into much more. Currently, many universities use the book for their introductory computer architecture courses. At Florida International University, for example, this book is used in a course named Fundamentals of Computer Systems, which leads to a more comprehensive course in Computer Architecture.
The present edition includes topics that lead naturally into subsequent courses in computer architecture, operating systems, and compiler writing:
- Virtual machine concept
- Elementary boolean operations
- Instruction execution cycle
- Memory access using clock cycles
- Interrupts and polling
- Multi-stage pipeline
- Superscalar architecture
- Multitasking
- Loading and executing programs
- Floating-point binary representation
Other topics relate specifically to Intel IA-32 architecture, using information gained from its manuals:
- IA-32 Protected Memory addressing and paging
- Memory segmentation in Real-address mode
- Interrupt handling
- Direct hardware I/O
- Instruction encoding
Certain examples presented in the book lend themselves to courses that occur later in a computer science curriculum:
- Searching and sorting algorithms
- High-level language structures
- Finite-state machines
- Code optimization examples
There are a number of new features in this edition that relate to programming:
- A more comprehensive and logical explanation of data definition.
- A more careful explanation of addressing modes.
- A simplified link library that requires fewer input parameters for nearly all procedures. There are new procedures to dump the CPU registers and sections of memory, as well as a delay timer.
- An explanation and demonstration of top-down program design.
- Use of flowcharts as code-generation tools.
- Even more thorough coverage of assembly language directives, macros, and operators. For example, the PROC, PROTO, and INVOKE directives are thoroughly explained and demonstrated.
- More complete coverage of structures, including nested structures and arrays of structures.
- Block-structured IF, WHILE, and REPEAT statements (an advanced feature of MASM).
- Introduction to video graphics, using both BIOS and direct-memory mapping techniques.
- Mouse programming.
- Win32 Console programming, using calls to the Kernel32 Windows library.
- More array manipulation examples.
Still a Programming Book. It is important to note that this book is still focused on its original mission: to teach students how to write and debug programs at the machine level. It will never replace a complete book on computer architecture, but it does give students the first-hand experience of writing software in an environment that teaches them how the computer really works. The value of this cannot be underestimated, because they will retain a great deal more theoretical knowledge by having immediate contact with the machine. In an engineering course, students construct prototypes; in a software course, students write programs. In both cases, they have a memorable experience that gives them the confidence to work in any OS/machine-oriented environment.
Real Mode and Protected Mode. Many professors have indicated a desire to move to 32-bit programming, using Intel's protected memory model. This edition primarily emphasizes 32-bit Protected mode, but it still has three chapters devoted exclusively to Real-mode programming. For example, there is an entire chapter on BIOS programming for the keyboard, video display (including graphics), and mouse. There is another chapter exclusively on MS-DOS programming using interrupt (function) calls. It is very beneficial for students to have some experience programming directly for firmware and hardware.
The examples in the first part of the book are nearly all presented as 32-bit text-oriented applications running in Protected mode using the flat memory model. This is extremely straightforward. No longer do students have to deal with segment-offset addressing. There are specially marked paragraphs and popup boxes that note the small differences between Protected mode and Real-mode programming. Most of the differences are hidden away in the book's two link libraries.
Link Libraries. There are two versions of the link library that students use for basic input-output in this book. The 32-bit version (Irvine32.lib) works in Win32 Console mode, under any version of MS-Windows. The 16-bit version (Irvinel6.lib) works under MS-DOS, MS-Windows, and a Linux DOS emulator. In later chapters, all the functions in these two libraries are exposed, and readers can modify the libraries as they wish. It is important to realize that the link libraries are there only for convenience, not to prevent students from learning how to program input-output themselves.
Included Software and Examples. All the example programs have been tested with the Microsoft Macro Assembler Version 6.15. For the most part, the programs will assemble with Borland TASM 4.0 and 5.0, but there are some features that Borland does not fully support.
Web Site Information. Updates and corrections to this book may be found at the book's Web site, including additional programming projects for professors to assign at the ends of chapters.
If for some reason you cannot access this site, information about the book and a link to its current Web site can be found by searching for the book title or for the full author name "Kip Irvine." The author's e-mail address is kip@nuvisionmiami.com
Overall Goals
Each of the following goals of this book is designed to broaden the student's interest and knowledge in topics related to assembly language:
- The Intel IA-32 processor architecture and programming
- Assembly language directives, macros, operators, and program structure
- Programming methodology, showing how to use assembly language to create both system-level software tools and application programs
- Computer hardware manipulation
- Interaction between assembly language programs, the operating system, and other application programs
One of my goals is to help students approach programming problems with a machine-level mind set. It is important to think of the CPU as an interactive tool, and to learn to monitor each of its actions as directly as possible. A debugger is a programmer's best friend, not only for catching errors, but as an educational tool that teaches about the CPU and operating system. I encourage students to look beneath the surface of high-level languages, and to realize that most programming languages are designed to be portable and, therefore, independent of their host machines.
In addition to the short examples, Assembly Language for Intel-Based Computers contains more than 115 ready-to-run programs that demonstrate instructions or ideas as they are presented in the text. Reference materials, such as guides to MS-DOS interrupts and instruction mnemonics, are available at the end of the book. There is a comprehensive link library that makes the user interface much more accessible for students writing their first programs. The macro library included with the book may also provide inspiration for further development by professors and students.
Required Background. The reader should already be able to program confidently in at least one other programming language, preferably Pascal, Java, C, or C++. One chapter goes into C++ interfacing in some depth, so it is very helpful to have a compiler on hand. I have used this book in the classroom with majors in both computer science and management information systems, and it has been used elsewhere in engineering courses. I used Microsoft Visual C++ 6.0 and Borland C++ 5.0 for the examples that deal with high-level language interfacing.
Features
Complete Program Listings. A companion CD-ROM contains all the source code from the examples in this book. Additional listings are available on the author's Web page. An extensive link library is supplied with the book, containing more than 30 procedures that simplify user input-output, numeric processing, disk and file handling, and string handling. In the beginning stages of the course, students can use this library to enhance their programs. Later, they can create their own procedures and add them to the library. Students are given the complete source code for the 16-bit and 32-bit link libraries.
Programming Logic. Two chapters emphasize boolean logic and bit-level manipulation. A conscious attempt is made to relate high-level programming logic to the low-level details of the machine. This helps students to create more efficient implementations and to better understand how language compilers generate object code.
Hardware and Operating System Concepts. The first two chapters introduce basic hardware and data representation concepts, including binary numbers, CPU architecture, status flags, and memory mapping. A survey of the computer's ha...
