Skip to content

Art of Assembly Language

Spend $50 to get a free DVD!

ISBN-10: 1593272073

ISBN-13: 9781593272074

Edition: 2nd 2010

Authors: Randall Hyde

List price: $74.95
Shipping box This item qualifies for FREE shipping.
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!

Customers also bought

Book details

List price: $74.95
Edition: 2nd
Copyright year: 2010
Publisher: No Starch Press, Incorporated
Publication date: 3/1/2010
Binding: Paperback
Pages: 760
Size: 7.01" wide x 9.21" long x 1.81" tall
Weight: 3.542
Language: English

Randall Hyde is the author of Write Great Code Volumes 1 and 2 (No Starch Press) and the co-author of MASM 6.0 Bible (The Waite Group). He has written for Dr. Dobb ™s Journal, Byte, and various professional journals. Hyde taught assembly language at the University of California, Riverside for over a decade.

Praise For The First Edition Of The Art Of Assembly Language
Hello, World Of Assembly Language
The Anatomy of an HLA Program
Running Your First HLA Program
Some Basic HLA Data Declarations
Boolean Values
Character Values
An Introduction to the Intel 80x86 CPU Family
The Memory Subsystem
Some Basic Machine Instructions
Some Basic HLA Control Structures
Introduction to the HLA Standard Library
Additional Details About try..endtry
High-Level Assembly Language vs. Low-Level Assembly Language
For More Information;
Data Representation
Numbering Systems
The Hexadecimal Numbering System
Data Organization
Arithmetic Operations on Binary and Hexadecimal Numbers
A Note About Numbers vs. Representation
Logical Operations on Bits
Logical Operations on Binary Numbers and Bit Strings
Signed and Unsigned Numbers
Sign Extension, Zero Extension, Contraction, and Saturation
Shifts and Rotates
Bit Fields and Packed Data
An Introduction to Floating-Point Arithmetic
Binary-Coded Decimal Representation
The Unicode Character Set
For More Information;
Memory Access And Organization
The 80x86 Addressing Modes
Runtime Memory Organization
How HLA Allocates Memory for Variables
HLA Support for Data Alignment
Address Expressions
Type Coercion
Register Type Coercion
The stack Segment and the push and pop Instructions
The Stack Is a LIFO Data Structure
Accessing Data You've Pushed onto the Stack Without Popping It
Dynamic Memory Allocation and the Heap Segment
The inc and dec Instructions
Obtaining the Address of a Memory Object
For More Information;
Constants, Variables, And Data Types
Some Additional Instructions: intmul, bound, into
HLA Constant and Value Declarations
The HLA Type Section
enum and HLA Enumerated Data Types
Pointer Data Types
Composite Data Types
Character Strings
HLA Strings
Accessing the Characters Within a String
The HLA String Module and Other String-Related Routines
In-Memory Conversions
Character Sets
Character Set Implementation in HLA
HLA Character Set Constants and Character Set Expressions
Character Set Support in the HLA Standard Library
Using Character Sets in Your HLA Programs
Declaring Arrays in Your HLA Programs
HLA Array Constants
Accessing Elements of a Single-Dimensional Array
Sorting an Array of Values
Multidimensional Arrays
Allocating Storage for Multidimensional Arrays
Accessing Multidimensional Array Elements in Assembly Language
Record Constants
Arrays of Records
Arrays/Records as Record Fields
Aligning Fields Within a Record
Pointers to Records
Anonymous Unions
Variant Types
Dynamic Arrays in Assembly Language
For More Information;
Procedures And Units
Saving the State of the Machine
Prematurely Returning from a Procedure
Local Variables
Other Local and Global Symbol Types
Functions and Function Results
Forward Procedures
HLA v2.0 Procedure Declarations
Low-Level Procedures and the call Instruction
Procedures and the Stack
Activation Records
The Standard Entry Sequence
The Standard Exit Sequence
Low-Level Implementation of Automatic (Local) Variables
Low-Level Parameter Implementation
Procedure Pointers
Procedural Parameters
Untyped Reference Parameters
Managing Large Programs
The #include Directive
Ignoring Duplicate #include Operations
Units and the external Directive
Namespace Pollution
For More Information;
80x86 Integer Arithmetic Instructions
Arithmetic Expressions
Logical (Boolean) Expressions
Machine and Arithmetic Idioms
Floating-Point Arithmetic
Converting Floating-Point Expressions to Assembly Langggggguage
HLA Standard Library Support for Floating-Point Arithmetic
For More Information;
Low-Level Control Structures
Low-Level Control Structures
Statement Labels
Unconditional Transfer of Control (jmp)
The Conditional Jump Instructions
�Medium-Level� Control Structures: jt and jf
Implementing Common Control Structures in Assembly Language
Introduction to Decisions
State Machines and Indirect Jumps
Spaghetti Code
Performance Improvements
Hybrid Control Structures in HLA
For More Information;
Advanced Arithmetic
Multiprecision Operations
Operating on Different-Size Operands
Decimal Arithmetic
For More Information;
Macros And The Hla Compile-Time Language
Introduction to the Compile-Time Language (CTL)
The #print and #error Statements
Compile-Time Constants and Variables
Compile-Time Expressions and Operators
Compile-Time Functions
Conditional Compilation (Compile-Time Decisions)
Repetitive Compilation (Compile-Time Loops)
Macros (Compile-Time Procedures)
Writing Compile-Time �Programs�
Using Macros in Different Source Files
For More Information;
Bit Manipulation
What Is Bit Data, Anyway?
Instructions That Manipulate Bits
The Carry Flag as a Bit Accumulator
Packing and Unpacking Bit Strings
Coalescing Bit Sets and Distributing Bit Strings
Packed Arrays of Bit Strings
Searching for a Bit
Counting Bits
Reversing a Bit String
Merging Bit Strings
Extracting Bit Strings
Searching for a Bit Pattern
The HLA Standard Library Bits Module
For More Information;
The String Instructions
The 80x86 String Instructions
Performance of the 80x86 String Instructions
For More Information;
Classes And Objects
General Principles
Classes in HLA
Virtual Methods vs. Static Procedures
Writing Class Methods and Procedures
Object Implementation
Constructors and Object Initialization
HLA's _initialize_ and _finalize_ Strings
Abstract Methods
Runtime Type Information
Calling Base Class Methods
For More Information
Ascii Character Set