The Art of Assembly Language
2nd Edition
Will be published approx. on 1. March 2010
Book
Paperback/Softback
XX, 737 pages
978-1-59327-207-4 (ISBN)
Description
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 hight-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 HLA programs
- 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 Editon is your essential guide to learning this complex, low-level language.
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 hight-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 HLA programs
- 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 Editon is your essential guide to learning this complex, low-level language.
Reviews / Votes
"The previous edition of Hyde's book has been my go-to book for assembly language for years, and there's little doubt this edition will be similarly long-lived."-SD Times: Software Development News
"Considering the fact that many people seem to have difficulties in learning assembler, this book is a very good read and effectively introduces the reader to this fascinating topic."
-The Ethical Hacker Network
"The Art of Assembly Language is a welcome addition to the bookshelf of any programmer who has yet to experience and appreciate deeper understanding of HLA gained as a result of reading the book."
-Dr. Dobb's
"The beauty of this book and HLA is that the HLA compiler insulates the beginner from the drudgery and trickery of getting started from zero knowledge."
-A.P. Lawrence
"And yes, people still do write in Assembly Language. And now, if you want to try this out for yourself, there is a great new book available to help you out. This is the second edition of Randall Hyde's The Art of Assembly Language."
-Scienceblogs.com
"I was reading The Art of Asssembly Language, 2nd Edition by Randall Hyde the other day and really enjoyed his approach to teaching the assembly language programming."
-Hex Blog
"As I remarked in respect of the first edition, if you want to use assembly language, or add it to your list of programming skills, this is the book to have."
-Linux Users of Victoria
"If you are a beginner and want to find your way into lower level programming and gain an understanding of how a machine's hardware works then this is a good way to get into things."
-I Programmer
"By the end of the book, readers will be pretty comfortable writing in programs using HLA and will have a new understanding of how computers operate."
-YYZtech.ca
"The Art of Assembly Language is a good book for teaching you the basics of Assembly through the use of HLA as Assembly 'training wheels.'"
-The Durham University Computing Society
More details
Edition
2nd Edition
Language
English
Place of publication
Heidelberg
Germany
Target group
Professional and scholarly
Programmers looking to enhance their skills or resumes
- University students and professors
- Hackers, reverse engineers, embedded programmers
Product notice
Unsewn / adhesive bound
Dimensions
Height: 23.3 cm
Width: 17.7 cm
ISBN-13
978-1-59327-207-4 (9781593272074)
Schweitzer Classification
Other editions
Additional editions
Randall Hyde
The Art of Assembly Language, 2nd Edition
E-Book
03/2010
No Starch Press
€46.99
Available for download
Previous edition
Randall Hyde
The Art of Assembly Language
Book
09/2003
1st Edition
No Starch Press
€60.00
Article exhausted; check for reprint
Person
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.
Content
PRAISE FOR THE FIRST EDITION OF THE ART OF ASSEMBLY LANGUAGE; ACKNOWLEDGMENTS;; Chapter 1: HELLO, WORLD OF ASSEMBLY LANGUAGE; 1.1 1.1 The Anatomy of an HLA Program; 1.2 1.2 Running Your First HLA Program; 1.3 1.3 Some Basic HLA Data Declarations; 1.4 1.4 Boolean Values; 1.5 1.5 Character Values; 1.6 1.6 An Introduction to the Intel 80x86 CPU Family; 1.7 1.7 The Memory Subsystem; 1.8 1.8 Some Basic Machine Instructions; 1.9 1.9 Some Basic HLA Control Structures; 1.10 1.10 Introduction to the HLA Standard Library; 1.11 1.11 Additional Details About try..endtry; 1.12 1.12 High-Level Assembly Language vs. Low-Level Assembly Language; 1.13 1.13 For More Information; Chapter 2: DATA REPRESENTATION; 2.1 2.1 Numbering Systems; 2.2 2.2 The Hexadecimal Numbering System; 2.3 2.3 Data Organization; 2.4 2.4 Arithmetic Operations on Binary and Hexadecimal Numbers; 2.5 2.5 A Note About Numbers vs. Representation; 2.6 2.6 Logical Operations on Bits; 2.7 2.7 Logical Operations on Binary Numbers and Bit Strings; 2.8 2.8 Signed and Unsigned Numbers; 2.9 2.9 Sign Extension, Zero Extension, Contraction, and Saturation; 2.10 2.10 Shifts and Rotates; 2.11 2.11 Bit Fields and Packed Data; 2.12 2.12 An Introduction to Floating-Point Arithmetic; 2.13 2.13 Binary-Coded Decimal Representation; 2.14 2.14 Characters; 2.15 2.15 The Unicode Character Set; 2.16 2.16 For More Information; Chapter 3: MEMORY ACCESS AND ORGANIZATION; 3.1 3.1 The 80x86 Addressing Modes; 3.2 3.2 Runtime Memory Organization; 3.3 3.3 How HLA Allocates Memory for Variables; 3.4 3.4 HLA Support for Data Alignment; 3.5 3.5 Address Expressions; 3.6 3.6 Type Coercion; 3.7 3.7 Register Type Coercion; 3.8 3.8 The stack Segment and the push and pop Instructions; 3.9 3.9 The Stack Is a LIFO Data Structure; 3.10 3.10 Accessing Data You've Pushed onto the Stack Without Popping It; 3.11 3.11 Dynamic Memory Allocation and the Heap Segment; 3.12 3.12 The inc and dec Instructions; 3.13 3.13 Obtaining the Address of a Memory Object; 3.14 3.14 For More Information; Chapter 4: CONSTANTS, VARIABLES, AND DATA TYPES; 4.1 4.1 Some Additional Instructions: intmul, bound, into; 4.2 4.2 HLA Constant and Value Declarations; 4.3 4.3 The HLA Type Section; 4.4 4.4 enum and HLA Enumerated Data Types; 4.5 4.5 Pointer Data Types; 4.6 4.6 Composite Data Types; 4.7 4.7 Character Strings; 4.8 4.8 HLA Strings; 4.9 4.9 Accessing the Characters Within a String; 4.10 4.10 The HLA String Module and Other String-Related Routines; 4.11 4.11 In-Memory Conversions; 4.12 4.12 Character Sets; 4.13 4.13 Character Set Implementation in HLA; 4.14 4.14 HLA Character Set Constants and Character Set Expressions; 4.15 4.15 Character Set Support in the HLA Standard Library; 4.16 4.16 Using Character Sets in Your HLA Programs; 4.17 4.17 Arrays; 4.18 4.18 Declaring Arrays in Your HLA Programs; 4.19 4.19 HLA Array Constants; 4.20 4.20 Accessing Elements of a Single-Dimensional Array; 4.21 4.21 Sorting an Array of Values; 4.22 4.22 Multidimensional Arrays; 4.23 4.23 Allocating Storage for Multidimensional Arrays; 4.24 4.24 Accessing Multidimensional Array Elements in Assembly Language; 4.25 4.25 Records; 4.26 4.26 Record Constants; 4.27 4.27 Arrays of Records; 4.28 4.28 Arrays/Records as Record Fields; 4.29 4.29 Aligning Fields Within a Record; 4.30 4.30 Pointers to Records; 4.31 4.31 Unions; 4.32 4.32 Anonymous Unions; 4.33 4.33 Variant Types; 4.34 4.34 Namespaces; 4.35 4.35 Dynamic Arrays in Assembly Language; 4.36 4.36 For More Information; Chapter 5: PROCEDURES AND UNITS; 5.1 5.1 Procedures; 5.2 5.2 Saving the State of the Machine; 5.3 5.3 Prematurely Returning from a Procedure; 5.4 5.4 Local Variables; 5.5 5.5 Other Local and Global Symbol Types; 5.6 5.6 Parameters; 5.7 5.7 Functions and Function Results; 5.8 5.8 Recursion; 5.9 5.9 Forward Procedures; 5.10 5.10 HLA v2.0 Procedure Declarations; 5.11 5.11 Low-Level Procedures and the call Instruction; 5.12 5.12 Procedures and the Stack; 5.13 5.13 Activation Records; 5.14 5.14 The Standard Entry Sequence; 5.15 5.15 The Standard Exit Sequence; 5.16 5.16 Low-Level Implementation of Automatic (Local) Variables; 5.17 5.17 Low-Level Parameter Implementation; 5.18 5.18 Procedure Pointers; 5.19 5.19 Procedural Parameters; 5.20 5.20 Untyped Reference Parameters; 5.21 5.21 Managing Large Programs; 5.22 5.22 The #include Directive; 5.23 5.23 Ignoring Duplicate #include Operations; 5.24 5.24 Units and the external Directive; 5.25 5.25 Namespace Pollution; 5.26 5.26 For More Information; Chapter 6: ARITHMETIC; 6.1 6.1 80x86 Integer Arithmetic Instructions; 6.2 6.2 Arithmetic Expressions; 6.3 6.3 Logical (Boolean) Expressions; 6.4 6.4 Machine and Arithmetic Idioms; 6.5 6.5 Floating-Point Arithmetic; 6.6 6.6 Converting Floating-Point Expressions to Assembly Langggggguage; 6.7 6.7 HLA Standard Library Support for Floating-Point Arithmetic; 6.8 6.8 For More Information; Chapter 7: LOW-LEVEL CONTROL STRUCTURES; 7.1 7.1 Low-Level Control Structures; 7.2 7.2 Statement Labels; 7.3 7.3 Unconditional Transfer of Control (jmp); 7.4 7.4 The Conditional Jump Instructions; 7.5 7.5 "Medium-Level" Control Structures: jt and jf; 7.6 7.6 Implementing Common Control Structures in Assembly Language; 7.7 7.7 Introduction to Decisions; 7.8 7.8 State Machines and Indirect Jumps; 7.9 7.9 Spaghetti Code; 7.10 7.10 Loops; 7.11 7.11 Performance Improvements; 7.12 7.12 Hybrid Control Structures in HLA; 7.13 7.13 For More Information; Chapter 8: ADVANCED ARITHMETIC; 8.1 8.1 Multiprecision Operations; 8.2 8.2 Operating on Different-Size Operands; 8.3 8.3 Decimal Arithmetic; 8.4 8.4 Tables; 8.5 8.5 For More Information; Chapter 9: MACROS AND THE HLA COMPILE-TIME LANGUAGE; 9.1 9.1 Introduction to the Compile-Time Language (CTL); 9.2 9.2 The #print and #error Statements; 9.3 9.3 Compile-Time Constants and Variables; 9.4 9.4 Compile-Time Expressions and Operators; 9.5 9.5 Compile-Time Functions; 9.6 9.6 Conditional Compilation (Compile-Time Decisions); 9.7 9.7 Repetitive Compilation (Compile-Time Loops); 9.8 9.8 Macros (Compile-Time Procedures); 9.9 9.9 Writing Compile-Time "Programs"; 9.10 9.10 Using Macros in Different Source Files; 9.11 9.11 For More Information; Chapter 10: BIT MANIPULATION; 10.1 10.1 What Is Bit Data, Anyway?; 10.2 10.2 Instructions That Manipulate Bits; 10.3 10.3 The Carry Flag as a Bit Accumulator; 10.4 10.4 Packing and Unpacking Bit Strings; 10.5 10.5 Coalescing Bit Sets and Distributing Bit Strings; 10.6 10.6 Packed Arrays of Bit Strings; 10.7 10.7 Searching for a Bit; 10.8 10.8 Counting Bits; 10.9 10.9 Reversing a Bit String; 10.10 10.10 Merging Bit Strings; 10.11 10.11 Extracting Bit Strings; 10.12 10.12 Searching for a Bit Pattern; 10.13 10.13 The HLA Standard Library Bits Module; 10.14 10.14 For More Information; Chapter 11: THE STRING INSTRUCTIONS; 11.1 11.1 The 80x86 String Instructions; 11.2 11.2 Performance of the 80x86 String Instructions; 11.3 11.3 For More Information; Chapter 12: CLASSES AND OBJECTS; 12.1 12.1 General Principles; 12.2 12.2 Classes in HLA; 12.3 12.3 Objects; 12.4 12.4 Inheritance; 12.5 12.5 Overriding; 12.6 12.6 Virtual Methods vs. Static Procedures; 12.7 12.7 Writing Class Methods and Procedures; 12.8 12.8 Object Implementation; 12.9 12.9 Constructors and Object Initialization; 12.10 12.10 Destructors; 12.11 12.11 HLA's _initialize_ and _finalize_ Strings; 12.12 12.12 Abstract Methods; 12.13 12.13 Runtime Type Information; 12.14 12.14 Calling Base Class Methods; 12.15 12.15 For More Information; ASCII CHARACTER SET; COLOPHON; UPDATES;