book

The Art of Assembly Language, 2nd Edition

Name: The Art of Assembly Language, 2nd Edition
Author: Randall Hyde
ISBN: 9781593272074

by Randall Hyde

March 2010

Beginner

760 pages

18h 51m

English

No Starch Press

Read now

Unlock full access

PRAISE FOR THE SECOND EDITION OF THE ART OF ASSEMBLY LANGUAGE
The Art of Assembly Language
ACKNOWLEDGMENTS
First EditionSecond Edition
1. HELLO, WORLD OF ASSEMBLY LANGUAGE
1.1 The Anatomy of an HLA Program
1.2 Running Your First HLA Program
1.3 Some Basic HLA Data Declarations
1.4 Boolean Values
1.5 Character Values
1.6 An Introduction to the Intel 80x86 CPU Family
1.7 The Memory Subsystem

1.8 Some Basic Machine Instructions
1.9 Some Basic HLA Control Structures
1.9.1 Boolean Expressions in HLA Statements1.9.2 The HLA if..then..elseif..else..endif Statement1.9.3 Conjunction, Disjunction, and Negation in Boolean Expressions1.9.4 The while..endwhile Statement1.9.5 The for..endfor Statement1.9.6 The repeat..until Statement1.9.7 The break and breakif Statements1.9.8 The forever..endfor Statement1.9.9 The try..exception..endtry Statement
1.10 Introduction to the HLA Standard Library
1.10.1 Predefined Constants in the stdio Module1.10.2 Standard In and Standard Out1.10.3 The stdout.newln Routine1.10.4 The stdout.putiX Routines1.10.5 The stdout.putiXSize Routines1.10.6 The stdout.put Routine1.10.7 The stdin.getc Routine1.10.8 The stdin.geti X Routines1.10.9 The stdin.readLn and stdin.flushInput Routines1.10.10 The stdin.get Routine
1.11 Additional Details About try..endtry
1.11.1 Nesting try..endtry Statements1.11.2 The unprotected Clause in a try..endtry Statement1.11.3 The anyexception Clause in a try..endtry Statement1.11.4 Registers and the try..endtry Statement
1.12 High-Level Assembly Language vs. Low-Level Assembly Language
1.13 For More Information
2. DATA REPRESENTATION
2.1 Numbering Systems2.1.1 A Review of the Decimal System2.1.2 The Binary Numbering System2.1.3 Binary Formats
2.2 The Hexadecimal Numbering System
2.3 Data Organization
2.3.1 Bits2.3.2 Nibbles2.3.3 Bytes2.3.4 Words2.3.5 Double Words2.3.6 Quad Words and Long Words
2.4 Arithmetic Operations on Binary and Hexadecimal Numbers
2.5 A Note About Numbers vs. Representation
2.6 Logical Operations on Bits
2.7 Logical Operations on Binary Numbers and Bit Strings
2.8 Signed and Unsigned Numbers
2.9 Sign Extension, Zero Extension, Contraction, and Saturation
2.10 Shifts and Rotates
2.11 Bit Fields and Packed Data
2.12 An Introduction to Floating-Point Arithmetic
2.12.1 IEEE Floating-Point Formats2.12.2 HLA Support for Floating-Point Values
2.13 Binary-Coded Decimal Representation
2.14 Characters
2.14.1 The ASCII Character Encoding2.14.2 HLA Support for ASCII Characters
2.15 The Unicode Character Set
2.16 For More Information
3. MEMORY ACCESS AND ORGANIZATION
3.1 The 80x86 Addressing Modes3.1.1 80x86 Register Addressing Modes3.1.2 80x86 32-Bit Memory Addressing Modes3.1.2.1 The Displacement-Only Addressing Mode3.1.2.2 The Register-Indirect Addressing Modes3.1.2.3 Indexed Addressing Modes3.1.2.4 Variations on the Indexed Addressing Mode3.1.2.5 Scaled-Indexed Addressing Modes3.1.2.6 Addressing Mode Wrap-up
3.2 Runtime Memory Organization
3.2.1 The code Section3.2.2 The static Section3.2.3 The readonly Data Section3.2.4 The storage Section3.2.5 The @nostorage Attribute3.2.6 The var Section3.2.7 Organization of Declaration Sections Within Your Programs
3.3 How HLA Allocates Memory for Variables
3.4 HLA Support for Data Alignment
3.5 Address Expressions
3.6 Type Coercion
3.7 Register Type Coercion
3.8 The stack Segment and the push and pop Instructions
3.8.1 The Basic push Instruction3.8.2 The Basic pop Instruction3.8.3 Preserving Registers with the push and pop Instructions
3.9 The Stack Is a LIFO Data Structure
3.9.1 Other push and pop Instructions3.9.2 Removing Data from the Stack Without Popping It
3.10 Accessing Data You've Pushed onto the Stack Without Popping It
3.11 Dynamic Memory Allocation and the Heap Segment
3.12 The inc and dec Instructions
3.13 Obtaining the Address of a Memory Object
3.14 For More Information
4. CONSTANTS, VARIABLES, AND DATA TYPES
4.1 Some Additional Instructions: intmul, bound, into
4.2 HLA Constant and Value Declarations
4.2.1 Constant Types4.2.2 String and Character Literal Constants4.2.3 String and Text Constants in the const Section4.2.4 Constant Expressions4.2.5 Multiple const Sections and Their Order in an HLA Program4.2.6 The HLA val Section4.2.7 Modifying val Objects at Arbitrary Points in Your Programs
4.3 The HLA Type Section
4.4 enum and HLA Enumerated Data Types
4.5 Pointer Data Types
4.5.1 Using Pointers in Assembly Language4.5.2 Declaring Pointers in HLA4.5.3 Pointer Constants and Pointer Constant Expressions4.5.4 Pointer Variables and Dynamic Memory Allocation4.5.5 Common Pointer Problems
4.6 Composite Data Types
4.7 Character Strings
4.8 HLA Strings
4.9 Accessing the Characters Within a String
4.10 The HLA String Module and Other String-Related Routines
4.11 In-Memory Conversions
4.12 Character Sets
4.13 Character Set Implementation in HLA
4.14 HLA Character Set Constants and Character Set Expressions
4.15 Character Set Support in the HLA Standard Library
4.16 Using Character Sets in Your HLA Programs
4.17 Arrays
4.18 Declaring Arrays in Your HLA Programs
4.19 HLA Array Constants
4.20 Accessing Elements of a Single-Dimensional Array
4.21 Sorting an Array of Values
4.22 Multidimensional Arrays
4.22.1 Row-Major Ordering4.22.2 Column-Major Ordering
4.23 Allocating Storage for Multidimensional Arrays
4.24 Accessing Multidimensional Array Elements in Assembly Language
4.25 Records
4.26 Record Constants
4.27 Arrays of Records
4.28 Arrays/Records as Record Fields
4.29 Aligning Fields Within a Record
4.30 Pointers to Records
4.31 Unions
4.32 Anonymous Unions
4.33 Variant Types
4.34 Namespaces
4.35 Dynamic Arrays in Assembly Language
4.36 For More Information
5. PROCEDURES AND UNITS
5.1 Procedures
5.2 Saving the State of the Machine
5.3 Prematurely Returning from a Procedure
5.4 Local Variables
5.5 Other Local and Global Symbol Types
5.6 Parameters
5.6.1 Pass by Value5.6.2 Pass by Reference
5.7 Functions and Function Results
5.7.1 Returning Function Results5.7.2 Instruction Composition in HLA5.7.3 The HLA @returns Option in Procedures
5.8 Recursion
5.9 Forward Procedures
5.10 HLA v2.0 Procedure Declarations
5.11 Low-Level Procedures and the call Instruction
5.12 Procedures and the Stack
5.13 Activation Records
5.14 The Standard Entry Sequence
5.15 The Standard Exit Sequence
5.16 Low-Level Implementation of Automatic (Local) Variables
5.17 Low-Level Parameter Implementation
5.17.1 Passing Parameters in Registers5.17.2 Passing Parameters in the Code Stream5.17.3 Passing Parameters on the Stack5.17.3.1 Accessing Value Parameters on the Stack5.17.3.2 Passing Value Parameters on the Stack5.17.3.3 Accessing Reference Parameters on the Stack5.17.3.4 Passing Reference Parameters on the Stack5.17.3.5 Passing Formal Parameters as Actual Parameters5.17.3.6 HLA Hybrid Parameter-Passing Facilities5.17.3.7 Mixing Register and Stack-Based Parameters
5.18 Procedure Pointers
5.19 Procedural Parameters
5.20 Untyped Reference Parameters
5.21 Managing Large Programs
5.22 The #include Directive
5.23 Ignoring Duplicate #include Operations
5.24 Units and the external Directive
5.24.1 Behavior of the external Directive5.24.2 Header Files in HLA
5.25 Namespace Pollution
5.26 For More Information
6. ARITHMETIC
6.1 80x86 Integer Arithmetic Instructions6.1.1 The mul and imul Instructions6.1.2 The div and idiv Instructions6.1.3 The cmp Instruction6.1.4 The setcc Instructions6.1.5 The test Instruction
6.2 Arithmetic Expressions
6.2.1 Simple Assignments6.2.2 Simple Expressions6.2.3 Complex Expressions6.2.4 Commutative Operators
6.3 Logical (Boolean) Expressions
6.4 Machine and Arithmetic Idioms
6.4.1 Multiplying without mul, imul, or intmul6.4.2 Division Without div or idiv6.4.3 Implementing Modulo-N Counters with and
6.5 Floating-Point Arithmetic
6.5.1 FPU Registers6.5.1.1 FPU Data Registers6.5.1.2 The FPU Control Register6.5.1.3 The FPU Status Register6.5.2 FPU Data Types6.5.3 The FPU Instruction Set6.5.4 FPU Data Movement Instructions6.5.4.1 The fld Instruction6.5.4.2 The fst and fstp Instructions6.5.4.3 The fxch Instruction6.5.5 Conversions6.5.5.1 The fild Instruction6.5.5.2 The fist, fistp, and fisttp Instructions6.5.5.3 The fbld and fbstp Instructions6.5.6 Arithmetic Instructions6.5.6.1 The fadd and faddp Instructions6.5.6.2 The fsub, fsubp, fsubr, and fsurpb Instructions6.5.6.3 The fmul and fmulp Instructions6.5.6.4 The fdiv, fdivp, fdivr, and fdivrp Instructions6.5.6.5 The fsqrt Instruction6.5.6.6 The fprem and fprem1 Instructions6.5.6.7 The frndint Instruction6.5.6.8 The fabs Instruction6.5.6.9 The fchs Instruction6.5.7 Comparison Instructions6.5.7.1 The fcom, fcomp, and fcompp Instructions6.5.7.2 The fcomi and fcomip Instructions6.5.7.3 The ftst Instruction6.5.8 Constant Instructions6.5.9 Transcendental Instructions6.5.9.1 The f2xm1 Instruction6.5.9.2 The fsin, fcos, and fsincos Instructions6.5.9.3 The fptan Instruction6.5.9.4 The fpatan Instruction6.5.9.5 The fyl2x Instruction6.5.9.6 The fyl2xp1 Instruction6.5.10 Miscellaneous Instructions6.5.10.1 The finit and fninit Instructions6.5.10.2 The fldcw and fstcw Instructions6.5.10.3 The fclex and fnclex Instructions6.5.10.4 The fstsw and fnstsw Instructions6.5.11 Integer Operations
6.6 Converting Floating-Point Expressions to Assembly Language
6.6.1 Converting Arithmetic Expressions to Postfix Notation6.6.2 Converting Postfix Notation to Assembly Language
6.7 HLA Standard Library Support for Floating-Point Arithmetic
6.8 For More Information
7. LOW-LEVEL CONTROL STRUCTURES
7.1 Low-Level Control Structures
7.2 Statement Labels
7.3 Unconditional Transfer of Control (jmp)
7.4 The Conditional Jump Instructions
7.5 "Medium-Level" Control Structures: jt and jf
7.6 Implementing Common Control Structures in Assembly Language
7.7 Introduction to Decisions
7.7.1 if..then..else Sequences7.7.2 Translating HLA if Statements into Pure Assembly Languageif( flag_specification ) then stmts endif;if( register ) then stmts endif;if( !register ) then stmts endif;if( boolean_variable ) then stmts endif;if( !boolean_variable ) then stmts endif;if( mem_reg relop mem_reg_const ) then stmts endif;if( reg/mem in LowConst..HiConst ) then stmts endif;if( reg/mem not in LowConst..HiConst ) then stmts endif;7.7.3 Implementing Complex if Statements Using Complete Boolean Evaluation7.7.4 Short-Circuit Boolean Evaluation7.7.5 Short-Circuit vs. Complete Boolean Evaluation7.7.6 Efficient Implementation of if Statements in Assembly Language7.7.6.1 Know Your Data!7.7.6.2 Rearranging Expressions7.7.6.3 Destructuring Your Code7.7.6.4 Calculation Rather Than Branching7.7.7 switch/case Statements
7.8 State Machines and Indirect Jumps
7.9 Spaghetti Code
7.10 Loops
7.10.1 while Loops7.10.2 repeat..until Loops7.10.3 forever..endfor Loops7.10.4 for Loops7.10.5 The break and continue Statementsforever..continue..endforwhile..continue..endwhilefor..continue..endforrepeat..continue..until7.10.6 Register Usage and Loops
7.11 Performance Improvements
7.11.1 Moving the Termination Condition to the End of a Loop7.11.2 Executing the Loop Backwards7.11.3 Loop-Invariant Computations7.11.4 Unraveling Loops7.11.5 Induction Variables
7.12 Hybrid Control Structures in HLA
7.13 For More Information
8. ADVANCED ARITHMETIC
8.1 Multiprecision Operations8.1.1 HLA Standard Library Support for Extended-Precision Operations8.1.2 Multiprecision Addition Operations8.1.3 Multiprecision Subtraction Operations8.1.4 Extended-Precision Comparisons8.1.5 Extended-Precision Multiplication8.1.6 Extended-Precision Division8.1.7 Extended-Precision neg Operations8.1.8 Extended-Precision and Operations8.1.9 Extended-Precision or Operations8.1.10 Extended-Precision xor Operations8.1.11 Extended-Precision not Operations8.1.12 Extended-Precision Shift Operations8.1.13 Extended-Precision Rotate Operations8.1.14 Extended-Precision I/O8.1.14.1 Extended-Precision Hexadecimal Output8.1.14.2 Extended-Precision Unsigned Decimal Output8.1.14.3 Extended-Precision Signed Decimal Output8.1.14.4 Extended-Precision Formatted Output8.1.14.5 Extended-Precision Input Routines8.1.14.6 Extended-Precision Hexadecimal Input8.1.14.7 Extended-Precision Unsigned Decimal Input8.1.14.8 Extended-Precision Signed Decimal Input
8.2 Operating on Different-Size Operands
8.3 Decimal Arithmetic
8.3.1 Literal BCD Constants8.3.2 The 80x86 daa and das Instructions8.3.3 The 80x86 aaa, aas, aam, and aad Instructions8.3.4 Packed Decimal Arithmetic Using the FPU
8.4 Tables
8.4.1 Function Computation via Table Lookup8.4.2 Domain Conditioning8.4.3 Generating Tables8.4.4 Table Lookup Performance
8.5 For More Information
9. MACROS AND THE HLA COMPILE-TIME LANGUAGE
9.1 Introduction to the Compile-Time Language (CTL)
9.2 The #print and #error Statements
9.3 Compile-Time Constants and Variables
9.4 Compile-Time Expressions and Operators
9.5 Compile-Time Functions
9.5.1 Type-Conversion Compile-Time Functions9.5.2 Numeric Compile-Time Functions9.5.3 Character-Classification Compile-Time Functions9.5.4 Compile-Time String Functions9.5.5 Compile-Time Symbol Information9.5.6 Miscellaneous Compile-Time Functions9.5.7 Compile-Time Type Conversions of Text Objects
9.6 Conditional Compilation (Compile-Time Decisions)
9.7 Repetitive Compilation (Compile-Time Loops)
9.8 Macros (Compile-Time Procedures)
9.8.1 Standard Macros9.8.2 Macro Parameters9.8.2.1 Standard Macro Parameter Expansion9.8.2.2 Macros with a Variable Number of Parameters9.8.2.3 Required vs. Optional Macro Parameters9.8.3 Local Symbols in a Macro9.8.4 Macros as Compile-Time Procedures9.8.5 Simulating Function Overloading with Macros
9.9 Writing Compile-Time "Programs"
9.9.1 Constructing Data Tables at Compile Time9.9.2 Unrolling Loops
9.10 Using Macros in Different Source Files
9.11 For More Information
10. BIT MANIPULATION
10.1 What Is Bit Data, Anyway?
10.2 Instructions That Manipulate Bits
10.3 The Carry Flag as a Bit Accumulator
10.4 Packing and Unpacking Bit Strings
10.5 Coalescing Bit Sets and Distributing Bit Strings
10.6 Packed Arrays of Bit Strings
10.7 Searching for a Bit
10.8 Counting Bits
10.9 Reversing a Bit String
10.10 Merging Bit Strings
10.11 Extracting Bit Strings
10.12 Searching for a Bit Pattern
10.13 The HLA Standard Library Bits Module
10.14 For More Information
11. THE STRING INSTRUCTIONS
11.1 The 80x86 String Instructions11.1.1 How the String Instructions Operate11.1.2 The rep/repe/repz and repnz/repne Prefixes11.1.3 The Direction Flag11.1.4 The movs Instruction11.1.5 The cmps Instruction11.1.6 The scas Instruction11.1.7 The stos Instruction11.1.8 The lods Instruction11.1.9 Building Complex String Functions from lods and stos
11.2 Performance of the 80x86 String Instructions
11.3 For More Information
12. CLASSES AND OBJECTS
12.1 General Principles
12.2 Classes in HLA
12.3 Objects
12.4 Inheritance
12.5 Overriding
12.6 Virtual Methods vs. Static Procedures
12.7 Writing Class Methods and Procedures
12.8 Object Implementation
12.8.1 Virtual Method Tables12.8.2 Object Representation with Inheritance
12.9 Constructors and Object Initialization
12.9.1 Dynamic Object Allocation Within the Constructor12.9.2 Constructors and Inheritance12.9.3 Constructor Parameters and Procedure Overloading
12.10 Destructors
12.11 HLA's _initialize_ and _finalize_ Strings
12.12 Abstract Methods
12.13 Runtime Type Information
12.14 Calling Base Class Methods
12.15 For More Information
A. ASCII CHARACTER SET
COLOPHON
UPDATES

Overview

Assembly is a low-level programming language that's one step above a computer's native machine language. Although assembly language is commonly used for writing device drivers, emulators, and video games, many programmers find its somewhat unfriendly syntax intimidating to learn and use.

Since 1996, Randall Hyde's The Art of Assembly Language has provided a comprehensive, plain-English, and patient introduction to 32-bit x86 assembly for non-assembly programmers. Hyde's primary teaching tool, High Level Assembler (or HLA), incorporates many of the features found in high-level languages (like C, C++, and Java) to help you quickly grasp basic assembly concepts. HLA lets you write true low-level code while enjoying the benefits of high-level language programming.

As you read The Art of Assembly Language, you'll learn the low-level theory fundamental to computer science and turn that understanding into real, functional code.

You'll learn how to:

Edit, compile, and run an HLA program
Declare and use constants, scalar variables, pointers, arrays, structures, unions, and namespaces
Translate arithmetic expressions (integer and floating point)
Convert high-level control structures

This much anticipated second edition of The Art of Assembly Language has been updated to reflect recent changes to HLA and to support Linux, Mac OS X, and FreeBSD. Whether you're new to programming or you have experience with high-level languages, The Art of Assembly Language, 2nd Edition is your essential guide to learning this complex, low-level language.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Assembly Language Step-by-Step: Programming with Linux®, Third Edition

Publisher Resources

ISBN: 9781593272074Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Art of Assembly Language, 2nd Edition

by Randall Hyde

Overview

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

Assembly Language Step-by-Step: Programming with Linux®, Third Edition

x64 Assembly Language Step-by-Step, 4th Edition

Code: The Hidden Language of Computer Hardware and Software, 2nd Edition

Programming in C, Fourth Edition

Publisher Resources