List of Figures

Chapter 1: Another Pleasant Valley Saturday Understanding What Computers Really Do

Figure 1.1: The Game of Big Bux.

Figure 1.2: The Game of Assembly Language.

Chapter 2: Alien Bases Getting Your Arms around Binary and Hexadecimal

Figure 2.1: The anatomy of ∩≡ Θ≡.

Figure 2.2: The anatomy of 76225 octal.

Figure 2.3: The anatomy of 3C0A9H.

Chapter 3: Lifting the Hood Discovering What Computers Actually Are

Figure 3.1: Transistor switches and memory cells.

Figure 3.2: A RAM chip.

Figure 3.3: A 1-megabyte memory bank.

Figure 3.4: The CPU and memory.

Chapter 4: The Right to Assemble The Process of Making Assembly Language Programs

Figure 4.1: Rotating disk storage.

Figure 4.2: The structure of a DOS text file.

Figure 4.3: What the assembler does.

Figure 4.4: The assembler and linker.

Figure 4.5: The assembly language development process.

Figure 4.6: A hex dump of SAM.TXT.

Chapter 5: NASM-IDE: A Place to Stand Give me a lever long enough, and a place to stand, and I will move the Earth.

Figure 5.1: The NASM-IDE environment.

Figure 5.2: A NASM-IDE error message box.

Figure 5.3: When you exit without saving.

Figure 5.4: The error information window appears.

Figure 5.5: Running the executable program file.

Figure 5.6: The Open File dialog box.

Figure 5.7: The Find dialog box.

Figure 5.8: The Replace dialog box.

Figure 5.9: The Environment Options dialog box.

Chapter 6: An Uneasy Alliance The x86 CPU and Its Segmented Memory System

Figure 6.1: The 8080 memory model.

Figure 6.2: The 8080 memory model inside an 8086 memory system.

Figure 6.3: Seeing a megabyte through 64K blinders.

Figure 6.4: Memory addresses versus segment addresses.

Figure 6.5: Segments and offsets.

Figure 6.6: Extending the 16-bit general-purpose registers.

Figure 6.7: 8-bit, 16-bit, and 32-bit registers.

Figure 6.8: The real mode flat model.

Figure 6.9: The real mode segmented model.

Figure 6.10: The protected mode flat model.

Figure 6.11: The PC''s video refresh buffer.

Chapter 7: Following Your Instructions Meeting Machine Instructions up Close and Personal

Figure 7.1: How memory data is addressed.

Chapter 8: Our Object All Sublime Creating Programs that Work

Figure 8.1: The big picture of the real mode stack.

Figure 8.2: How the stack works.

Figure 8.3: The interrupt vector table.

Figure 8.4: Riding the interrupt vector into DOS.

Figure 8.5: Returning home from an interrupt.

Chapter 9: Dividing and Conquering Using Procedures and Macros to Battle Complexity

Figure 9.1: Calling a procedure and returning.

Figure 9.2: Connecting globals and externals.

Figure 9.3: How macros work.

Chapter 10: Bits, Flags, Branches, and Tables Easing into Mainstream Assembly Programming

Figure 10.1: Bit numbering.

Figure 10.2: The anatomy of an AND instruction.

Figure 10.3: Using XOR to zero a register.

Figure 10.4: Using a lookup table.

Figure 10.5: Interrupt 11H configuration information.

Chapter 11: Stringing Them Up Those Amazing String Instructions

Figure 11.1: Unpacked BCD digits.

Chapter 12: The Programmer''s View of Linux Tools and Skills to Help You Write Assembly Code under a True 32-Bit OS

Figure 12.1: How gcc builds Linux executables.

Figure 12.2: The structure of a Linux assembly language program.

Chapter 13: Coding for Linux Applying What You''ve Learned to a True Protected Mode Operating System

Figure 13.1: A stack frame.

Figure 13.2: Protected mode memory addressing.

Figure 13.3: Linux command-line arguments.