The Art of Assembly Language, 2nd Edition

by Hyde, Randall

• ISBN13: 9781593272074
• ISBN10: 1593272073
• eBook ISBN(s): 9781593273019
• Edition: 2nd
• Format: Paperback
• Copyright: 2010-03-01
• Publisher: No Starch Press
• More Book Details
• Purchase Benefits

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.

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.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

Rewards Program

Currently unavailable

×

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.