9781593272074

The Art of Assembly Language

by
  • ISBN13:

    9781593272074

  • ISBN10:

    1593272073

  • Edition: 2nd
  • Format: Paperback
  • Copyright: 3/15/2010
  • Publisher: Oreilly & Associates Inc
  • Purchase Benefits
  • Free Shipping On Orders Over $59!
    Your order must be $59 or more to qualify for free economy shipping. Bulk sales, PO's, Marketplace items, eBooks and apparel do not qualify for this offer.
  • Get Rewarded for Ordering Your Textbooks! Enroll Now
List Price: $59.95 Save up to $8.99
  • Buy New
    $50.96

    IN STOCK USUALLY SHIPS IN 24-48 HOURS

Supplemental Materials

What is included with this book?

  • The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

Summary

Widely respected by hackers of all kinds, The Art of Assembly Language teaches programmers how to understand assembly language and how to use it to write powerful, efficient code. Using the proven High Level Assembler (HLA) as its primary teaching tool, The Art of Assembly Language leverages your knowledge of high level programming languages to make it easier for you to quickly grasp basic assembly concepts. Among the most comprehensive references to assembly language every published, The Art of Assembly Language, 2nd Edition has been thoroughly updated to reflect recent changes to the HLA language. All code from the book is portable to the Windows, Linux, Mac OS X, and FreeBSD operating systems.

Author Biography

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.

Table of Contents

Praise For The First Edition Of The Art Of Assembly Language
Acknowledgments
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
Characters
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
Arrays
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
Records
Record Constants
Arrays of Records
Arrays/Records as Record Fields
Aligning Fields Within a Record
Pointers to Records
Unions
Anonymous Unions
Variant Types
Namespaces
Dynamic Arrays in Assembly Language
For More Information;
Procedures And Units
Procedures
Saving the State of the Machine
Prematurely Returning from a Procedure
Local Variables
Other Local and Global Symbol Types
Parameters
Functions and Function Results
Recursion
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;
Arithmetic
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
Loops
Performance Improvements
Hybrid Control Structures in HLA
For More Information;
Advanced Arithmetic
Multiprecision Operations
Operating on Different-Size Operands
Decimal Arithmetic
Tables
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
Objects
Inheritance
Overriding
Virtual Methods vs. Static Procedures
Writing Class Methods and Procedures
Object Implementation
Constructors and Object Initialization
Destructors
HLA's _initialize_ and _finalize_ Strings
Abstract Methods
Runtime Type Information
Calling Base Class Methods
For More Information
Ascii Character Set
Colophon
Updates
Table of Contents provided by Publisher. All Rights Reserved.

Rewards Program

Write a Review