Books & Videos

Table of Contents

  1. Chapter 1 Thinking Low-Level, Writing High-Level

    1. 1.1 Misconceptions About Compiler Quality

    2. 1.2 Why Learning Assembly Language Is Still a Good Idea

    3. 1.3 Why Learning Assembly Language Isn’t Absolutely Necessary

    4. 1.4 Thinking Low-Level

    5. 1.5 Writing High-Level

    6. 1.6 Assumptions

    7. 1.7 Language-Neutral Approach

    8. 1.8 Characteristics of Great Code

    9. 1.9 The Environment for This Text

    10. 1.10 For More Information

  2. Chapter 2 Shouldn’t You Learn Assembly Language?

    1. 2.1 Roadblocks to Learning Assembly Language

    2. 2.2 Write Great Code, Volume 2, to the Rescue

    3. 2.3 High-Level Assemblers to the Rescue

    4. 2.4 The High-Level Assembler (HLA)

    5. 2.5 Thinking High-Level, Writing Low-Level

    6. 2.6 The Assembly Programming Paradigm (Thinking Low-Level)

    7. 2.7 The Art of Assembly Language and Other Resources

  3. Chapter 3 80x86 Assembly for the HLL Programmer

    1. 3.1 Learning One Assembly Language Is Good, Learning More Is Better

    2. 3.2 80x86 Assembly Syntaxes

    3. 3.3 Basic 80x86 Architecture

    4. 3.4 Literal Constants

    5. 3.5 Manifest (Symbolic) Constants in Assembly Language

    6. 3.6 80x86 Addressing Modes

    7. 3.7 Declaring Data in Assembly Language

    8. 3.8 Specifying Operand Sizes in Assembly Language

    9. 3.9 The Minimal 80x86 Instruction Set

    10. 3.10 For More Information

  4. Chapter 4 PowerPC Assembly for the HLL Programmer

    1. 4.1 Learning One Assembly Language Is Good; More Is Better

    2. 4.2 Assembly Syntaxes

    3. 4.3 Basic PowerPC Architecture

    4. 4.4 Literal Constants

    5. 4.5 Manifest (Symbolic) Constants in Assembly Language

    6. 4.6 PowerPC Addressing Modes

    7. 4.7 Declaring Data in Assembly Language

    8. 4.8 Specifying Operand Sizes in Assembly Language

    9. 4.9 The Minimal Instruction Set

    10. 4.10 For More Information

  5. Chapter 5 Compiler Operation and Code Generation

    1. 5.1 File Types That Programming Languages Use

    2. 5.2 Programming Language Source Files

    3. 5.3 Types of Computer Language Processors

    4. 5.4 The Translation Process

    5. 5.5 Compiler Output

    6. 5.6 Object File Formats

    7. 5.7 Executable File Formats

    8. 5.8 Data and Code Alignment in an Object File

    9. 5.9 Linkers and Their Effect on Code

    10. 5.10 For More Information

  6. Chapter 6 Tools for Analyzing Compiler Output

    1. 6.1 Background

    2. 6.2 Telling a Compiler to Produce Assembly Output

    3. 6.3 Using Object-Code Utilities to Analyze Compiler Output

    4. 6.4 Using a Disassembler to Analyze Compiler Output

    5. 6.5 Using a Debugger to Analyze Compiler Output

    6. 6.6 Comparing Output from Two Compilations

    7. 6.7 For More Information

  7. Chapter 7 Constants and High-Level Languages

    1. 7.1 Literal Constants and Program Efficiency

    2. 7.2 Literal Constants Versus Manifest Constants

    3. 7.3 Constant Expressions

    4. 7.4 Manifest Constants Versus Read-Only Memory Objects

    5. 7.5 Enumerated Types

    6. 7.6 Boolean Constants

    7. 7.7 Floating-Point Constants

    8. 7.8 String Constants

    9. 7.9 Composite Data Type Constants

    10. 7.10 For More Information

  8. Chapter 8 Variables in a High-Level Language

    1. 8.1 Runtime Memory Organization

    2. 8.2 What Is a Variable?

    3. 8.3 Variable Storage

    4. 8.4 Common Primitive Data Types

    5. 8.5 Variable Addresses and High-level Languages

    6. 8.6 Variable Alignment in Memory

    7. 8.7 For More Information

  9. Chapter 9 Array Data Types

    1. 9.1 What Is an Array?

    2. 9.2 For More Information

  10. Chapter 10 String Data Types

    1. 10.1 Character String Formats

    2. 10.2 Static, Pseudo-Dynamic, and Dynamic Strings

    3. 10.3 Reference Counting for Strings

    4. 10.4 Delphi/Kylix Strings

    5. 10.5 Using Strings in a High-Level Language

    6. 10.6 Character Data in Strings

    7. 10.7 For More Information

  11. Chapter 11 Pointer Data Types

    1. 11.1 Defining and Demystifying Pointers

    2. 11.2 Pointer Implementation in High-Level Languages

    3. 11.3 Pointers and Dynamic Memory Allocation

    4. 11.4 Pointer Operations and Pointer Arithmetic

    5. 11.5 A Simple Memory Allocator Example

    6. 11.6 Garbage Collection

    7. 11.7 The OS and Memory Allocation

    8. 11.8 Heap Memory Overhead

    9. 11.9 Common Pointer Problems

    10. 11.10 For More Information

  12. Chapter 12 Record Union, and Class Data Types

    1. 12.1 Records

    2. 12.2 Discriminant Unions

    3. 12.3 Union Declarations in Various Languages

    4. 12.4 Memory Storage of Unions

    5. 12.5 Other Uses of Unions

    6. 12.6 Variant Types

    7. 12.7 Namespaces

    8. 12.8 Classes and Objects

    9. 12.9 For More Information

  13. Chapter 13 Arithmetic and Logical Expressions

    1. 13.1 Arithmetic Expressions and Computer Architecture

    2. 13.2 Optimization of Arithmetic Statements

    3. 13.3 Side Effects in Arithmetic Expressions

    4. 13.4 Containing Side Effects: Sequence Points

    5. 13.5 Avoiding Problems Caused by Side Effects

    6. 13.6 Forcing a Particular Order of Evaluation

    7. 13.7 Short-Circuit Evaluation

    8. 13.8 The Relative Cost of Arithmetic Operations

    9. 13.9 For More Information

  14. Chapter 14 Control Structures and Programmatic Decisions

    1. 14.1 Control Structures Are Slower Than Computations!

    2. 14.2 Introduction to Low-Level Control Structures

    3. 14.3 The goto Statement

    4. 14.4 break, continue, next, return, and Other Limited Forms of the goto Statement

    5. 14.5 The if Statement

    6. 14.6 The switch/case Statement

    7. 14.7 For More Information

  15. Chapter 15 Iterative Control Structures

    1. 15.1 The while Loop

    2. 15.2 The repeat..until (do..until/do..while) Loop

    3. 15.3 The forever..endfor Loop

    4. 15.4 The Definite Loop (for Loops)

    5. 15.5 For More Information

  16. Chapter 16 Functions and Procedures

    1. 16.1 Simple Function and Procedure Calls

    2. 16.2 Leaf Functions and Procedures

    3. 16.3 Macros and Inline Functions

    4. 16.4 Passing Parameters to a Function or Procedure

    5. 16.5 Activation Records and the Stack

    6. 16.6 Parameter-Passing Mechanisms

    7. 16.7 Function Return Values

    8. 16.8 For More Information

  1. Appendix Engineering Software

  2. Appendix A Brief Comparison of the 80x86 and PowerPC CPU Families

    1. A.1 Architectural Differences Between RISC and CISC

    2. A.2 Compiler and Application Binary Interface Issues

    3. A.3 Writing Great Code for Both Architectures

  3. Appendix Online Appendices

  4. Colophon

  5. Appendix Updates