Safari, the world’s most comprehensive technology and business learning platform.

Find the exact information you need to solve a problem on the fly, or go deeper to master the technologies and skills you need to succeed

Start Free Trial

No credit card required

O'Reilly logo
X86 Assembly Language and C Fundamentals

Book Description

The predominant language used in embedded microprocessors, assembly language lets you write programs that are typically faster and more compact than programs written in a high-level language and provide greater control over the program applications. Focusing on the languages used in X86 microprocessors, X86 Assembly Language and C Fundamentals explains how to write programs in the X86 assembly language, the C programming language, and X86 assembly language modules embedded in a C program. A wealth of program design examples, including the complete code and outputs, help you grasp the concepts more easily. Where needed, the book also details the theory behind the design.

Learn the X86 Microprocessor Architecture and Commonly Used Instructions

Assembly language programming requires knowledge of number representations, as well as the architecture of the computer on which the language is being used. After covering the binary, octal, decimal, and hexadecimal number systems, the book presents the general architecture of the X86 microprocessor, individual addressing modes, stack operations, procedures, arrays, macros, and input/output operations. It highlights the most commonly used X86 assembly language instructions, including data transfer, branching and looping, logic, shift and rotate, and string instructions, as well as fixed-point, binary-coded decimal (BCD), and floating-point arithmetic instructions.

Get a Solid Foundation in a Language Commonly Used in Digital Hardware

Written for students in computer science and electrical, computer, and software engineering, the book assumes a basic background in C programming, digital logic design, and computer architecture. Designed as a tutorial, this comprehensive and self-contained text offers a solid foundation in assembly language for anyone working with the design of digital hardware.

Table of Contents

  1. Preliminaries
  2. By the same Author
  3. Preface
  4. Chapter 1 Number Systems and Number Representations
    1. 1.1 Number Systems
      1. 1.1.1 Binary Number System
      2. 1.1.2 Octal Number System
      3. 1.1.3 Decimal Number System
      4. 1.1.4 Hexadecimal Number System
      5. 1.1.5 Arithmetic Operations
      6. 1.1.6 Conversion between Radices
    2. 1.2 Number Representations
      1. 1.2.1 Sign Magnitude
      2. 1.2.2 Diminished-Radix Complement
      3. 1.2.3 Radix Complement
      4. 1.2.4 Arithmetic Operations
    3. 1.3 Problems
      1. Figure 1.1
      2. Figure 1.2
      3. Figure 1.3
      4. Figure 1.4
      5. Figure 1.5
      6. Figure 1.6
      7. Figure 1.7
      8. Figure 1.8
      9. Figure 1.9
      10. Figure 1.10
      11. Figure 1.11
      12. Figure 1.12
      13. Figure 1.13
      14. Figure 1.14
      15. Figure 1.15
      16. Figure 1.16
      17. Figure 1.17
      18. Figure 1.18
      19. Figure 1.19
      20. Figure 1.20
      21. Figure 1.21
      22. Figure 1.22
      23. Figure 1.23
      24. Figure 1.24
      1. Table 1.1
      2. Table 1.2
      3. Table 1.3
      4. Table 1.4
      5. Table 1.5
      6. Table 1.6
      7. Table 1.7
      8. Table 1.8
      9. Table 1.9
      10. Table 1.10
      11. Table 1.11
      12. Table 1.12
      13. Table 1.13
      14. Table 1.14
  5. Chapter 2 X86 Processor Architecture
    1. 2.1 General Architecture
    2. 2.2 Arithmetic and Logic Unit
    3. 2.3 Control Unit
    4. 2.4 Memory Unit
      1. 2.4.1 Main Memory
      2. 2.4.2 Hamming Code
      3. 2.4.3 Cache Memory
    5. 2.5 Input/Output
      1. 2.5.1 Tape Drives
      2. 2.5.2 Disk Drives
    6. 2.6 Register Set
      1. 2.6.1 General-Purpose Registers
      2. 2.6.2 Segment Registers
      3. 2.6.3 EFLAGS Register
      4. 2.6.4 Instruction Pointer
      5. 2.6.5 Floating-Point Registers
    7. 2.7 Translation Lookaside Buffer
    8. 2.8 The Assembler
      1. 2.8.1 The Assembly Process
    9. 2.9 Problems
      1. Figure 2.1
      2. Figure 2.2
      3. Figure 2.3
      4. Figure 2.4
      5. Figure 2.5
      6. Figure 2.6
      7. Figure 2.7
      8. Figure 2.8
      9. Figure 2.9
      10. Figure 2.10
      11. Figure 2.11
      12. Figure 2.12
      13. Figure 2.13
      14. Figure 2.14
      15. Figure 2.15
      16. Figure 2.16
      17. Figure 2.17
      18. Figure 2.18
      19. Figure 2.19
      20. Figure 2.20
      21. Figure 2.21
      22. Figure 2.22
      23. Figure 2.23
      24. Figure 2.24
      25. Figure 2.25
      26. Figure 2.26
      27. Figure 2.27
      28. Figure 2.28
      1. Table 2.1
      2. Table 2.2
  6. Chapter 3 Addressing Modes
    1. 3.1 Register Addressing
    2. 3.2 Immediate Addressing
    3. 3.3 Direct Memory Addressing
    4. 3.4 Base (Register Indirect) Memory Addressing
    5. 3.5 Base or Index Plus Displacement Addressing
    6. 3.6 Base and Index Plus Displacement Addressing
    7. 3.7 Scale Factor
    8. 3.8 Segment Override Prefix
    9. 3.9 X86 Operation Modes
      1. 3.9.1 Protected Mode
      2. 3.9.2 Real Mode
    10. 3.10 Problems
      1. Figure 3.1
      2. Figure 3.2
      3. Figure 3.3
      4. Figure 3.4
      5. Figure 3.5
      6. Figure 3.6
  7. Chapter 4 C Programming Fundamentals
    1. 4.1 Structure of a C Program
    2. 4.2 Variables and Constants
      1. 4.2.1 Variables
      2. 4.2.2 Constants
    3. 4.3 Input and Output
      1. 4.3.1 Printf () Function
      2. 4.3.2 Scanf () Function
    4. 4.4 Operators
      1. 4.4.1 Arithmetic Operators
      2. 4.4.2 Relational Operators
      3. 4.4.3 The If Statement
      4. 4.4.4 The Else Statement
      5. 4.4.5 Logical Operators
      6. 4.4.6 Conditional Operator
      7. 4.4.7 Increment and Decrement Operators
      8. 4.4.8 Bitwise Operators
    5. 4.5 While Loop
    6. 4.6 For Loop
    7. 4.7 Additional C Constructs
      1. 4.7.1 Arrays
      2. 4.7.2 Strings
      3. 4.7.3 Pointers
      4. 4.7.4 Functions
    8. 4.8 Problems
      1. Figure 4.1
      2. Figure 4.2
      3. Figure 4.3
      4. Figure 4.4
      5. Figure 4.5
      6. Figure 4.6
      7. Figure 4.7
      8. Figure 4.8
      9. Figure 4.9
      10. Figure 4.10
      11. Figure 4.11
      12. Figure 4.12
      13. Figure 4.13
      14. Figure 4.14
      15. Figure 4.15
      16. Figure 4.16
      17. Figure 4.17
      18. Figure 4.18
      19. Figure 4.19
      20. Figure 4.20
      21. Figure 4.21
      22. Figure 4.22
      23. Figure 4.23
      24. Figure 4.24
      25. Figure 4.25
      26. Figure 4.26
      27. Figure 4.27
      28. Figure 4.28
      29. Figure 4.29
      30. Figure 4.30
      31. Figure 4.31
      32. Figure 4.32
      33. Figure 4.33
      34. Figure 4.34
      35. Figure 4.35
      36. Figure 4.36
      37. Figure 4.37
      38. Figure 4.38
      39. Figure 4.39
      40. Figure 4.40
      41. Figure 4.41
      42. Figure 4.42
      43. Figure 4.43
      44. Figure 4.44
      45. Figure 4.45
      46. Figure 4.46
      47. Figure 4.47
      48. Figure 4.48
      49. Figure 4.49
      50. Figure 4.50
      51. Figure 4.51
      52. Figure 4.52
      53. Figure 4.53
      54. Figure 4.54
      55. Figure 4.55
      56. Figure 4.56
      1. Table 4.1
      2. Table 4.2
      3. Table 4.3
      4. Table 4.4
      5. Table 4.5
      6. Table 4.6
      7. Table 4.7
      8. Table 4.8
      9. Table 4.9
      10. Table 4.10
      11. Table 4.11
      12. Table 4.12
      13. Table 4.13
      14. Table 4.14
  8. Chapter 5 Data Transfer Instructions
    1. 5.1 Data Types
      1. 5.1.1 Signed Binary Integers
      2. 5.1.2 Unsigned Binary Integers
      3. 5.1.3 Unpacked and Packed BCD Integers
      4. 5.1.4 Floating-Point Numbers
    2. 5.2 Move Instructions
      1. 5.2.1 General Move Instructions
      2. 5.2.2 Move with Sign/Zero Extension
      3. 5.2.3 Conditional Move
    3. 5.3 Load Effective Address
    4. 5.4 Load Segment Registers
    5. 5.5 Exchange Instructions
      1. 5.5.1 Exchange
      2. 5.5.2 Byte Swap
      3. 5.5.3 Exchange and Add
      4. 5.5.4 Compare and Exchange
    6. 5.6 Translate
    7. 5.7 Conversion Instructions
    8. 5.8 Problems
      1. Figure 5.1
      2. Figure 5.2
      3. Figure 5.3
      4. Figure 5.4
      5. Figure 5.5
      6. Figure 5.6
      7. Figure 5.7
      8. Figure 5.8
      9. Figure 5.9
      10. Figure 5.10
      11. Figure 5.11
      12. Figure 5.12
      13. Figure 5.13
      14. Figure 5.14
      15. Figure 5.15
      16. Figure 5.16
      17. Figure 5.17
      18. Figure 5.18
      19. Figure 5.19
      20. Figure 5.20
      21. Figure 5.21
      22. Figure 5.22
      23. Figure 5.23
      1. Table 5.1
      2. Table 5.2
      3. Table 5.3
      4. Table 5.4
  9. Chapter 6 Branching and Looping Instructions
    1. 6.1 Branching Instructions
      1. 6.1.1 Unconditional Jump Instruction
      2. 6.1.2 Compare Instruction
      3. 6.1.3 Conditional Jump Instructions
    2. 6.2 Looping Instructions
      1. 6.2.1 Unconditional Loop
      2. 6.2.2 Conditional Loops
      3. 6.2.3 Implementing while Loops
      4. 6.2.4 Implementing for Loops
    3. 6.3 Problems
      1. Figure 6.1
      2. Figure 6.2
      3. Figure 6.3
      4. Figure 6.4
      5. Figure 6.5
      6. Figure 6.6
      7. Figure 6.7
      8. Figure 6.8
      9. Figure 6.9
      10. Figure 6.10
      11. Figure 6.11
      12. Figure 6.12
      1. Table 6.1
      2. Table 6.2
      3. Table 6.3
      4. Table 6.4
      5. Table 6.5
      6. Table 6.6
  10. Chapter 7 Stack Operations
    1. 7.1 Stack Structure
    2. 7.2 Additional Push Instructions
    3. 7.3 Additional Pop Instructions
    4. 7.4 Problems
      1. Figure 7.1
      2. Figure 7.2
      3. Figure 7.3
      4. Figure 7.4
  11. Chapter 8 Logical, Bit, Shift, and Rotate Instructions
    1. 8.1 Logical AND Instruction
    2. 8.2 Logical Inclusive-OR Instruction
    3. 8.3 Logical Exclusive-OR Instruction
    4. 8.4 Logical NOT Instruction — 1s Complement
    5. 8.5 NEG Instruction — 2s Complement
    6. 8.6 TEST and Set Byte on Condition Instructions
      1. 8.6.1 TEST Instruction
      2. 8.6.2 Set Byte on Condition (SETcc) Instruction
    7. 8.7 Bit Test Instructions
      1. 8.7.1 Bit Test (BT) Instruction
      2. 8.7.2 Bit Test and Set (BTS) Instruction
      3. 8.7.3 Bit Test and Reset (BTR) Instruction
      4. 8.7.4 Bit Test and Complement (BTC) Instruction
    8. 8.8 Bit Scan Instructions
      1. 8.8.1 Bit Scan Forward (BSF) Instruction
      2. 8.8.2 Bit Scan Reverse (BSR) Instruction
    9. 8.9 Shift Instructions
      1. 8.9.1 Shift Arithmetic Left (SAL) Instruction
      2. 8.9.2 Shift Logical Left (SHL) Instruction
      3. 8.9.3 Shift Arithmetic Right (SAR) Instruction
      4. 8.9.4 Shift Logical Right (SHR) Instruction
      5. 8.9.5 Shift Left Double (SHLD) Instruction
      6. 8.9.6 Shift Right Double (SHRD) Instruction
    10. 8.10 Rotate Instructions
      1. 8.10.1 Rotate Left (ROL) Instruction
      2. 8.10.2 Rotate through Carry Left (RCL) Instruction
      3. 8.10.3 Rotate Right (ROR) Instruction
      4. 8.10.4 Rotate through Carry Right (RCR) Instruction
    11. 8.11 Problems
      1. Figure 8.1
      2. Figure 8.2
      3. Figure 8.3
      4. Figure 8.4
      5. Figure 8.5
      6. Figure 8.6
      7. Figure 8.7
      8. Figure 8.8
      9. Figure 8.9
      10. Figure 8.10
      11. Figure 8.11
      12. Figure 8.12
      13. Figure 8.13
      14. Figure 8.14
      15. Figure 8.15
      16. Figure 8.16
      17. Figure 8.17
      18. Figure 8.18
      19. Figure 8.19
      20. Figure 8.20
      21. Figure 8.21
      22. Figure 8.22
      23. Figure 8.23
      24. Figure 8.24
      25. Figure 8.25
      26. Figure 8.26
      27. Figure 8.27
      28. Figure 8.28
      29. Figure 8.29
      30. Figure 8.30
      31. Figure 8.31
      32. Figure 8.32
      1. Table 8.1
      2. Table 8.2
      3. Table 8.3
      4. Table 8.4
      5. Table 8.5
      6. Table 8.6
      7. Table 8.7
  12. Chapter 9 Fixed-Point Arithmetic Instructions
    1. 9.1 Addition
      1. 9.1.1 Add (ADD) Instruction
      2. 9.1.2 Add with Carry (ADC) Instruction
      3. 9.1.3 Increment by 1 (INC) Instruction
    2. 9.2 Subtraction
      1. 9.2.1 Subtract (SUB) Instruction
      2. 9.2.2 Integer Subtraction with Borrow (SBB) Instruction
      3. 9.2.3 Decrement by 1 (DEC) Instruction
      4. 9.2.4 Two's Complement Negation (NEG) Instruction
    3. 9.3 Multiplication
      1. 9.3.1 Unsigned Multiply (MUL) Instruction
      2. 9.3.2 Signed Multiply (IMUL) Instruction
    4. 9.4 Division
      1. 9.4.1 Unsigned Divide (DIV) Instruction
      2. 9.4.2 Signed Divide (IDIV) Instruction
    5. 9.5 Problems
      1. Figure 9.1
      2. Figure 9.2
      3. Figure 9.3
      4. Figure 9.4
      5. Figure 9.5
      6. Figure 9.6
      7. Figure 9.7
      8. Figure 9.8
      9. Figure 9.9
      10. Figure 9.10
      11. Figure 9.11
      12. Figure 9.12
      13. Figure 9.13
      14. Figure 9.14
      15. Figure 9.15
      16. Figure 9.16
      17. Figure 9.17
      18. Figure 9.18
      19. Figure 9.19
      20. Figure 9.20
      21. Figure 9.21
      22. Figure 9.22
      23. Figure 9.23
      24. Figure 9.24
      25. Figure 9.25
      26. Figure 9.26
      27. Figure 9.27
      28. Figure 9.28
      1. Table 9.1
      2. Table 9.2
      3. Table 9.3
  13. Chapter 10 Binary-Coded Decimal Arithmetic Instructions
    1. 10.1 ASCII Adjust After Addition (AAA) Instruction
    2. 10.2 Decimal Adjust AL after Addition (DAA) Instruction
    3. 10.3 ASCII Adjust AL after Subtraction (AAS) Instruction
    4. 10.4 Decimal Adjust AL after Subtraction (DAS) Instruction
    5. 10.5 ASCII Adjust AX after Multiplication (AAM) Instruction
    6. 10.6 ASCII Adjust AX before Division (AAD) Instruction
    7. 10.7 Problems
      1. Figure 10.1
      2. Figure 10.2
      3. Figure 10.3
      4. Figure 10.4
      5. Figure 10.5
      6. Figure 10.6
      7. Figure 10.7
      8. Figure 10.8
      9. Figure 10.9
      10. Figure 10.10
      11. Figure 10.11
      12. Figure 10.12
      13. Figure 10.13
      14. Figure 10.14
      15. Figure 10.15
      16. Figure 10.16
      1. Table 10.1
  14. Chapter 11 Floating-Point Arithmetic Instructions
    1. 11.1 Floating-Point Fundamentals
      1. 11.1.1 Rounding Methods
    2. 11.2 Load Data Instructions
      1. 11.2.1 Load Floating-Point Value (FLD) Instruction
      2. 11.2.2 Load Constant Instructions
      3. 11.2.3 Load X87 FPU Control Word (FLDCW) Instruction
      4. 11.2.4 Load X87 FPU Environment (FLDENV) Instruction
      5. 11.2.5 Load Integer (FILD) Instruction
      6. 11.2.6 Load Binary-Coded Decimal (FBLD) Instruction
    3. 11.3 Store Data Instructions
      1. 11.3.1 Store BCD Integer and Pop (FBSTP) Instruction
      2. 11.3.2 Store Integer (FIST) Instruction
      3. 11.3.3 Store Integer and Pop (FISTP) Instruction
      4. 11.3.4 Store Integer with Truncation and Pop (FISTTP) Instruction
      5. 11.3.5 Store Floating-Point Value (FST) Instruction
      6. 11.3.6 Store Floating-Point Value and Pop (FSTP) Instruction
      7. 11.3.7 Store X87 FPU Control Word (FSTCW) Instruction
      8. 11.3.8 Store X87 FPU Environment (FSTENV) Instruction
      9. 11.3.9 Store X87 FPU Status Word (FSTSW) Instruction
    4. 11.4 Addition Instructions
      1. 11.4.1 Overflow and Underflow
      2. 11.4.2 Add Instructions
    5. 11.5 Subtraction Instructions
      1. 11.5.1 Numerical Examples
      2. 11.5.2 Subtract Instructions
    6. 11.6 Multiplication Instructions
      1. 11.6.1 Double Bias
      2. 11.6.2 Numerical Examples
      3. 11.6.3 Multiply Instructions
    7. 11.7 Division Instructions
      1. 11.7.1 Zero Bias
      2. 11.7.2 Numerical Example
      3. 11.7.3 Divide Instructions
    8. 11.8 Compare Instructions
      1. 11.8.1 Compare Floating-Point Values
      2. 11.8.2 Compare Floating-Point Values and Set EFLAGS
      3. 11.8.3 Compare Integer
      4. 11.8.4 Test
      5. 11.8.5 Unordered Compare Floating-Point Values
    9. 11.9 Trigonometric Instructions
      1. 11.9.1 Cosine
      2. 11.9.2 Partial Arctangent
      3. 11.9.3 Partial Tangent
      4. 11.9.4 Sine
      5. 11.9.5 Sine and Cosine
    10. 11.10 Additional Instructions
      1. 11.10.1 Absolute Value
      2. 11.10.2 Change Sign
      3. 11.10.3 Decrement Stack-Top Pointer
      4. 11.10.4 Free Floating-Point Register
      5. 11.10.5 Increment Stack-Top Pointer
      6. 11.10.6 Partial Remainder
      7. 11.10.7 Round to Integer
      8. 11.10.8 Square Root
      9. 11.10.9 Exchange Register Contents
    11. 11.11 Problems
      1. Figure 11.1
      2. Figure 11.2
      3. Figure 11.3
      4. Figure 11.4
      5. Figure 11.5
      6. Figure 11.6
      7. Figure 11.7
      8. Figure 11.8
      9. Figure 11.9
      10. Figure 11.10
      11. Figure 11.11
      12. Figure 11.12
      13. Figure 11.13
      14. Figure 11.14
      15. Figure 11.15
      16. Figure 11.16
      17. Figure 11.17
      18. Figure 11.18
      19. Figure 11.19
      20. Figure 11.20
      21. Figure 11.21
      22. Figure 11.22
      23. Figure 11.23
      24. Figure 11.24
      25. Figure 11.25
      26. Figure 11.26
      27. Figure 11.27
      28. Figure 11.28
      29. Figure 11.29
      30. Figure 11.30
      31. Figure 11.31
      32. Figure 11.32
      33. Figure 11.33
      34. Figure 11.34
      35. Figure 11.35
      36. Figure 11.36
      37. Figure 11.37
      38. Figure 11.38
      1. Table 11.1
      2. Table 11.2
      3. Table 11.3
  15. Chapter 12 Procedures
    1. 12.1 Call a Procedure
    2. 12.2 Return from a Procedure
    3. 12.3 Passing Parameters to a Procedure
    4. 12.4 Problems
      1. Figure 12.1
      2. Figure 12.2
      3. Figure 12.3
      4. Figure 12.4
      5. Figure 12.5
      6. Figure 12.6
      7. Figure 12.7
      8. Figure 12.8
  16. Chapter 13 String Instructions
    1. 13.1 Repeat Prefixes
      1. 13.1.1 REP Prefix
      2. 13.1.2 REPE / REPZ Prefix
      3. 13.1.3 REPNE / REPNZ Prefix
    2. 13.2 Move String Instructions
      1. 13.2.1 Move Data from String to String (Explicit Operands) Instructions
      2. 13.2.2 Move Data from String to String (No Operands) Instructions
    3. 13.3 Load String Instructions
      1. 13.3.1 Load String (Explicit Operands) Instructions
      2. 13.3.2 Load String (No Operands) Instructions
    4. 13.4 Store String Instructions
      1. 13.4.1 Store String (Explicit Operands) Instructions
      2. 13.4.2 Store String (No Operands) Instructions
    5. 13.5 Compare Strings Instructions
      1. 13.5.1 Compare Strings (Explicit Operands) Instructions
      2. 13.5.2 Compare Strings (No Operands) Instructions
    6. 13.6 Scan String Instructions
      1. 13.6.1 Scan String (Explicit Operands) Instructions
      2. 13.6.2 Scan String (No Operands) Instructions
    7. 13.7 Problems
      1. Figure 13.1
      2. Figure 13.2
      3. Figure 13.3
      4. Figure 13.4
      5. Figure 13.5
      6. Figure 13.6
      7. Figure 13.7
      8. Figure 13.8
      9. Figure 13.9
      10. Figure 13.10
  17. Chapter 14 Arrays
    1. 14.1 One-Dimensional Arrays
      1. 14.1.1 One-Dimensional Arrays in C
    2. 14.2 Multidimensional Arrays
    3. 14.3 Problems
      1. Figure 14.1
      2. Figure 14.2
      3. Figure 14.3
      4. Figure 14.4
      5. Figure 14.5
      6. Figure 14.6
      7. Figure 14.7
      8. Figure 14.8
      9. Figure 14.9
      10. Figure 14.10
  18. Chapter 15 Macros
    1. 15.1 Macro Definitions
    2. 15.2 Macro Examples
    3. 15.3 Problems
      1. Figure 15.1
      2. Figure 15.2
      3. Figure 15.3
      4. Figure 15.4
      5. Figure 15.5
      6. Figure 15.6
      7. Figure 15.7
      8. Figure 15.8
      9. Figure 15.9
      10. Figure 15.10
      11. Figure 15.11
      12. Figure 15.12
      13. Figure 15.13
      1. Table 15.1
  19. Chapter 16 Interrupts and Input/Output Operations
    1. 16.1 Interrupts
    2. 16.2 Direct Memory Access
    3. 16.3 Memory-Mapped I/O
    4. 16.4 In/Out Instructions
      1. 16.4.1 Register I/O IN Instructions
      2. 16.4.2 Register I/O OUT Instructions
      3. 16.4.3 String I/O IN Instructions
      4. 16.4.4 String I/O OUT Instructions
    5. 16.5 Problems
      1. Figure 16.1
      2. Figure 16.2
      3. Figure 16.3
  20. Chapter 17 Additional Programming Examples
    1. 17.1 Programming Examples
    2. 17.2 Problems
      1. Figure 17.1
      2. Figure 17.2
      3. Figure 17.3
      4. Figure 17.4
      5. Figure 17.5
      6. Figure 17.6
      7. Figure 17.7
      8. Figure 17.8
      9. Figure 17.9
      10. Figure 17.10
      11. Figure 17.11
      12. Figure 17.12
      13. Figure 17.13
      14. Figure 17.14
      15. Figure 17.15
      16. Figure 17.16
      17. Figure 17.17
      18. Figure 17.18
      19. Figure 17.19
      20. Figure 17.20
      21. Figure 17.21
      22. Figure 17.22
      23. Figure 17.23
      24. Figure 17.24
      25. Figure 17.25
      26. Figure 17.26
  21. Appendix A ASCII Character Codes
  22. Appendix B Answers to Select Problems
    1. Chapter 1 Number Systems and Number Representations
    2. Chapter 2 X86 Processor Architecture
    3. Chapter 3 Addressing Modes
    4. Chapter 4 C Programming Fundamentals
    5. Chapter 5 Data Transfer Instructions
    6. Chapter 6 Branching and Looping Instructions
    7. Chapter 7 Stack Operations
    8. Chapter 8 Logical, Bit, Shift, and Rotate Instructions
    9. Chapter 9 Fixed-Point Arithmetic Instructions
    10. Chapter 10 Binary-Coded Decimal Arithmetic Instructions
    11. Chapter 11 Floating-Point Arithmetic Instructions
    12. Chapter 12 Procedures
    13. Chapter 13 String Instructions
    14. Chapter 14 Arrays
    15. Chapter 15 Macros
    16. Chapter 16 Interrupts and Input/Output Operations
    17. Chapter 17 Additional Programming Examples