book

The Art of ARM Assembly, Volume 1

Name: The Art of ARM Assembly, Volume 1
Author: Randall Hyde
ISBN: 9781718502826

by Randall Hyde

February 2025

Beginner to intermediate

1064 pages

26h

English

No Starch Press

Read now

Unlock full access

Title Page
Copyright
Dedication
About the Author and Technical Reviewer
Acknowledgments
Introduction
0.1 A Brief History of the ARM CPU0.2 Why Learn ARM Assembly?0.3 Why Learn 64-Bit ARM?0.4 Expectations and Prerequisites0.5 Source Code0.6 Typography and Pedantry0.7 Organization
Part I: Machine Organization
1. Hello, World of Assembly Language
1.1 What You’ll Need1.1.1 Setting Up Gas1.1.2 Setting Up a Text Editor1.1.3 Understanding C/C++ Examples1.2 The Anatomy of an Assembly Language Program1.3 Running Your First Assembly Language Program1.4 Running Your First Gas/C++ Hybrid Program1.5 The aoaa.inc Include File1.6 The ARM64 CPU Architecture1.6.1 ARM CPU Registers1.6.2 The Memory Subsystem1.7 Declaring Memory Variables in Gas1.7.1 Associating Memory Addresses with Variables1.7.2 Aligning Variables1.7.3 Declaring Named Constants in Gas1.7.4 Creating Register Aliases in Gas and Substituting Text1.8 Basic ARM Assembly Language Instructions1.8.1 ldr, str, adr, and adrp1.8.2 mov1.8.3 add and sub1.8.4 bl, blr, and ret1.9 The ARM64 Application Binary Interface1.9.1 Register Usage 1.9.2 Parameter Passing and Function Result Conventions 1.10 Calling C Library Functions1.10.1 Assembling Programs Under Multiple OSes1.10.2 Writing a “Hello, World!” Program1.11 Moving On1.12 For More Information
2. Data Representation and Operations
2.1 Numbering Systems2.1.1 Decimal2.1.2 Binary2.1.3 Hexadecimal2.2 Numbers vs. Representation2.3 Data Organization2.3.1 Bits2.3.2 Nibbles2.3.3 Bytes2.3.4 Half Words2.3.5 Words2.3.6 Double Words and Quad Words2.4 Logical Operations on Bits2.4.1 AND2.4.2 OR2.4.3 XOR2.4.4 NOT2.5 Logical Operations on Binary Numbers and Bit Strings2.6 Signed and Unsigned Numbers2.7 Sign Extension and Zero Extension2.8 Sign Contraction and Saturation2.9 Loading and Storing Byte and Half-Word Values2.10 Control-Transfer Instructions2.10.1 Branch2.10.2 Instructions That Affect the Condition Code Flags2.10.3 Conditional Branch2.10.4 cmp and Corresponding Conditional Branches2.11 Shifts and Rotates2.12 Bit Fields and Packed Data2.13 IEEE Floating-Point Formats2.13.1 Single-Precision Format2.13.2 Double-Precision Format2.14 Normalized Floating-Point Values2.14.1 Nonnumeric Values2.14.2 Gas Support for Floating-Point Values2.15 Binary-Coded Decimal Representation2.16 Characters2.16.1 The ASCII Character Encoding2.16.2 Gas Support for ASCII Characters2.17 Gas Support for the Unicode Character Set2.18 Machine Code2.19 Operand22.19.1 #immediate2.19.2 #pattern2.19.3 Register2.19.4 Shifted Register2.19.5 Extending Register2.20 Large Constants2.20.1 movz2.20.2 movk2.20.3 movn2.21 Moving On2.22 For More Information
3. Memory Access and Organization
3.1 Runtime Memory Organization3.1.1 The .text Section3.1.2 The .data Section3.1.3 Read-Only Data Sections3.1.4 The .bss Section3.1.5 The .section Directive3.1.6 Declaration Sections3.1.7 Memory Access and MMU Pages3.1.8 PIE and ASLR3.1.9 The .pool Section3.2 Gas Storage Allocation for Variables3.3 Little-Endian and Big-Endian Data Organization3.4 Memory Access3.5 Gas Support for Data Alignment3.6 The ARM Memory Addressing Modes3.6.1 PC-Relative 3.6.2 Register-Indirect 3.6.3 Indirect-Plus-Offset3.6.4 Scaled Indirect-Plus-Offset3.6.5 Pre-indexed3.6.6 Post-Indexed3.6.7 Scaled-Indexed3.7 Address Expressions3.8 Getting the Address of a Memory Object3.9 The Push and Pop Operations3.9.1 Using Double Loads and Stores3.9.2 Executing the Basic Push Operation3.9.3 Executing the Basic Pop Operation3.9.4 Preserving at Least Two Registers3.9.5 Preserving Register Values on the Stack3.9.6 Saving Function Return Addresses on the Stack3.10 Pushing and Popping Stack Data3.10.1 Removing Data from the Stack Without Popping It3.10.2 Accessing Data Pushed onto the Stack Without Popping It3.11 Moving On3.12 For More Information

4. Constants, Variables, and Data Types
4.1 Gas Constant Declarations4.2 The Location Counter Operator4.3 Data Types and Gas4.4 Pointer Data Types4.4.1 Pointer Usage in Assembly Language4.4.2 Pointer Declarations in Gas4.4.3 Pointer Constants and Expressions 4.4.4 Pointer Variables and Dynamic Memory Allocation4.4.5 Common Pointer Problems4.5 Composite Data Types4.6 Character Strings4.6.1 Zero-Terminated Strings4.6.2 Length-Prefixed Strings4.6.3 String Descriptors4.6.4 Pointers to Strings4.6.5 String Functions4.7 Arrays4.7.1 Declaring Arrays in Gas Programs 4.7.2 Accessing Elements of a Single-Dimensional Array 4.7.3 Sorting an Array of Values4.7.4 Implementing Multidimensional Arrays4.8 Structs4.8.1 Dealing with Limited Gas Support for Structs 4.8.2 Initializing Structs 4.8.3 Creating Arrays of Structs4.8.4 Aligning Fields Within a Struct 4.9 Unions4.10 Moving On4.11 For More Information
Part II: Basic Assembly Language
5. Procedures
5.1 Assembly Language Programming Style5.2 Gas Procedures5.2.1 Gas Local Labels5.2.2 bl, ret, and br5.3 Saving the State of the Machine5.4 Call Trees, Leaf Procedures, and the Stack5.4.1 Activation Records5.4.2 Objects in the Activation Record 5.4.3 ARM ABI Parameter-Passing Conventions5.4.4 Standard Entry Sequence5.4.5 Standard Exit Sequence5.5 Local Variables5.5.1 Low-Level Implementation of Automatic Variables5.5.2 The locals Macro5.6 Parameters5.6.1 Passing by Value5.6.2 Passing by Reference5.6.3 Using Low-Level Parameter Implementation5.6.4 Accessing Reference Parameters on the Stack5.7 Functions and Function Return Results5.8 Recursion5.9 Procedure Pointers and Procedural Parameters5.10 A Program-Defined Stack5.11 Moving On5.12 For More Information
6. Arithmetic
6.1 Additional ARM Arithmetic Instructions6.1.1 Multiplication6.1.2 Division and Modulo6.1.3 cmp Revisited6.1.4 Conditional Instructions6.2 Memory Variables vs. Registers6.2.1 Volatile vs. Nonvolatile Register Usage6.2.2 Global vs. Local Variables6.2.3 Easy Access to Global Variables6.3 Arithmetic Expressions6.3.1 Simple Assignments6.3.2 Simple Expressions6.3.3 Complex Expressions6.3.4 Commutative Operators6.4 Logical Expressions6.5 Conditional Comparisons and Boolean Expressions6.5.1 Implementing Conjunction Using ccmp6.5.2 Implementing Disjunction Using ccmp6.5.3 Handling Complex Boolean Expressions6.6 Machine and Arithmetic Idioms6.6.1 Multiplying Without mul6.6.2 Dividing Without sdiv or udiv6.6.3 Implementing Modulo-N Counters with AND6.6.4 Avoiding Needlessly Complex Machine Idioms6.7 Floating-Point and Finite-Precision Arithmetic6.7.1 Basic Floating-Point Terminology6.7.2 Limited-Precision Arithmetic and Accuracy6.7.3 Errors in Floating-Point Calculations6.7.4 Floating-Point Value Comparisons6.8 Floating-Point Arithmetic on the ARM6.8.1 Neon Registers6.8.2 Control Register6.8.3 Status Register6.9 Floating-Point Instructions6.9.1 FPU Data Movement Instructions6.9.2 FPU Arithmetic Instructions6.9.3 Floating-Point Comparisons6.9.4 Floating-Point Conversion Instructions6.10 The ARM ABI and Floating-Point Registers6.11 Using C Standard Library Math Functions6.12 Moving On6.13 For More Information
7. Low-Level Control Structures
7.1 Statement Labels7.2 Initializing Arrays with Statement Labels7.3 Unconditional Transfer of Control7.4 Register-Indirect Branches7.5 Taking the Address of Symbols in Your Code7.5.1 Revisiting the lea Macro7.5.2 Statically Computing the Address of a Symbol7.5.3 Dynamically Computing the Address of a Memory Object7.5.4 Working with Veneers7.6 Implementing Common Control Structures in Assembly Language7.6.1 Decisions7.6.2 if…then…else Sequences7.6.3 Complex if Statements Using Complete Boolean Evaluation7.6.4 Short-Circuit Boolean Evaluation7.6.5 Short-Circuit vs. Complete Boolean Evaluation7.6.6 Efficient Implementation of if Statements in Assembly Language7.6.7 switch…case Statements7.7 State Machines and Indirect Jumps7.8 Loops7.8.1 while7.8.2 repeat…until 7.8.3 forever/endfor 7.8.4 for 7.8.5 break and continue 7.8.6 ARM Looping Instructions 7.8.7 Register Usage and Loops7.9 Loop Performance Improvements7.9.1 Moving the Termination Condition to the End of a Loop 7.9.2 Executing the Loop Backward 7.9.3 Eliminating Loop-Invariant Calculations 7.9.4 Unraveling Loops 7.9.5 Using Induction Variables 7.10 Moving On7.11 For More Information
Part III: Advanced Assembly Language
8. Advanced Arithmetic
8.1 Extended-Precision Operations8.1.1 Addition8.1.2 Subtraction8.1.3 Comparisons8.1.4 Multiplication8.1.5 Division8.1.6 Negation8.1.7 AND8.1.8 OR8.1.9 XOR8.1.10 NOT8.1.11 Shift Operations8.2 Operating on Different-Size Operands8.3 Moving On8.4 For More Information
9. Numeric Conversion
9.1 Converting Numeric Strings to Values9.1.1 Numeric Values to Hexadecimal Strings9.1.2 Extended-Precision Hexadecimal Values to Strings9.1.3 Unsigned Decimal Values to Strings9.1.4 Signed Integer Values to Strings9.1.5 Extended-Precision Unsigned Integers to Strings9.1.6 Formatted Conversions9.2 Converting Floating-Point Values to Strings9.2.1 Floating-Point Exponent to String of Decimal Digits 9.2.2 Floating-Point Mantissa to String of Digits 9.2.3 Strings in Decimal and Exponential Format 9.2.4 Double-Precision Values to Strings 9.3 String-to-Numeric Conversions9.3.1 Decimal Strings to Integers9.3.2 Hexadecimal Strings to Numeric Form9.3.3 String to Floating-Point9.4 Other Numeric Conversions9.5 Moving On9.6 For More Information
10. Table Lookups
10.1 Using Tables in Assembly Language10.1.1 Function Computation via Table Lookup10.1.2 Function Domains and Ranges10.1.3 Domain Conditioning10.1.4 Table Generation10.2 Table-Lookup Performance10.3 Moving On10.4 For More Information
11. Neon and SIMD Programming
11.1 The History of SIMD Instruction Extensions11.2 Vector Registers11.3 Vector Data Movement Instructions11.3.1 Data Movement Between Registers11.3.2 Vector Load Immediate Instructions11.3.3 Register or Lane Value Duplication11.3.4 Vector Load and Store11.3.5 Interleaved Load and Store11.3.6 Register Interleaving and Deinterleaving11.3.7 Table Lookups with tbl and tbx11.3.8 Endian Swaps with rev16, rev32, and rev6411.4 Vertical and Horizontal Operations11.5 SIMD Logical Operations11.6 SIMD Shift Operations11.6.1 Shift-Left Instruction11.6.2 Saturating Shift Left11.6.3 Shift-Left Long11.6.4 Shift and Insert11.6.5 Signed and Unsigned Shift Right11.6.6 Accumulating Shift Right11.6.7 Narrowing Shift Right11.6.8 Saturating Shift Right with Narrowing11.6.9 Shift by a Variable Number of Bits11.7 SIMD Arithmetic Operations11.7.1 SIMD Addition11.7.2 Subtraction11.7.3 Absolute Difference11.7.4 Vector Multiplication11.7.5 Vector Division11.7.6 Sign Operations11.7.7 Minimum and Maximum11.8 Floating-Point and Integer Conversions11.8.1 Floating-Point to Integer11.8.2 Integer to Floating-Point11.8.3 Conversion Between Floating-Point Formats11.8.4 Floating-Point Values Rounded to the Nearest Integral11.9 Vector Square-Root Instructions11.10 Vector Comparisons11.10.1 Vector Integer Comparisons11.10.2 Vector Floating-Point Comparisons11.10.3 Vector Bit Test Instructions11.10.4 Vector Comparison Results11.11 A Sorting Example Using SIMD Code11.12 A Numeric-to-Hex-String Example Using SIMD Code11.13 Use of SIMD Instructions in Real Programs11.14 Moving On11.15 For More Information
12. Bit Manipulation
12.1 What Is Bit Data, Anyway?12.2 Instructions That Manipulate Bits12.2.1 Isolating, Clearing, and Testing Bits12.2.2 Setting and Inserting Bits12.2.3 Clearing Bits12.2.4 Inverting Bits12.2.5 Shift and Rotate12.2.6 Conditional Instructions12.2.7 Counting Bits12.2.8 Bit Reversal12.2.9 Bit Insertion and Selection12.2.10 Bit Extraction with ubfx12.2.11 Bit Movement with ubfiz12.2.12 Bit Movement with ubfm12.2.13 Bit Extraction with extr12.2.14 Bit Testing with tbz and tbnz12.3 Flag Modification by Arithmetic and Logical Instructions12.3.1 The Zero Flag12.3.2 The Negative Flag12.3.3 The Carry and Overflow Flags12.4 Packing and Unpacking Bit Strings12.4.1 Inserting One Bit String into Another12.4.2 Extracting a Bit String12.4.3 Clearing a Bit Field12.4.4 Using bfm12.5 Common Bit Operations12.5.1 Coalescing Bit Sets and Distributing Bit Strings12.5.2 Creating Packed Arrays of Bit Strings12.5.3 Searching for Bits12.5.4 Merging Bit Strings12.5.5 Scattering Bits from a Bit String12.5.6 Searching for a Bit Pattern12.6 Moving On12.7 For More Information
13. Macros and the Gas Compile-Time Language
13.1 The Gas Compile-Time Language Interpreter13.2 The C/C++ Preprocessor13.2.1 The #warning and #error Directives13.2.2 Compile-Time Constant Definition with CPP13.2.3 CPP Compile-Time Expressions13.2.4 Conditional Assembly13.2.5 CPP Macros13.3 Components of the Gas CTL13.3.1 Errors and Warnings During Assembly13.3.2 Conditional Assembly13.3.3 Compile-Time Loops13.3.4 Gas Macros13.4 The aoaa.inc Header File13.5 Generating Macros by Another Macro13.6 Choosing Between Gas Macros and CPP Macros13.7 Moving On13.8 For More Information
14. String Operations
14.1 Zero-Terminated Strings and Functions14.2 A String Format for Assembly Language Programmers14.2.1 Dynamic String Allocation14.2.2 String Copy Function14.2.3 String Comparison Function14.2.4 Substring Function14.2.5 More String Functions14.3 The Unicode Character Set14.3.1 Unicode History14.3.2 Code Points and Code Planes14.3.3 Surrogate Code Points14.3.4 Glyphs, Characters, and Grapheme Clusters14.3.5 Normal Forms and Canonical Equivalence14.3.6 Encodings14.3.7 Combining Characters14.4 Unicode in Assembly Language14.4.1 Writing Console Applications with UTF-8 Characters14.4.2 Using Unicode String Functions14.5 Moving On14.6 For More Information
15. Managing Complex Projects
15.1 The .include Directive15.2 Ignoring Duplicate Include Operations15.3 Assembly Units and External Directives15.4 Creating a String Library with Separate Compilation15.5 Introducing Makefiles15.5.1 Basic Makefile Syntax15.5.2 Make Clean and Touch15.6 Generating Library Files with the Archiver Program15.7 Managing the Impact of Object Files on Program Size15.8 Moving On15.9 For More Information
16. Stand-Alone Assembly Language Programs
16.1 Portability Issues with System Calls16.2 Stand-Alone Code and System Calls16.3 The svc Interface and OS Portability16.3.1 Call Numbers16.3.2 API Parameters16.3.3 API Error Handling16.4 A Stand-Alone “Hello, World!” Program16.5 A Sample File I/O Program16.5.1 volatiles.S Functions16.5.2 files.S File I/O Functions16.5.3 stdio.S Functions16.5.4 File I/O Demo Application16.6 Calling System Library Functions Under macOS16.7 Creating Assembly Applications Without GCC16.8 For More Information
Part IV: Reference Materials
A. The ASCII Character Set
B. Glossary
C. Installing and Using Gas
C.1 macOSC.2 Linux
D. The Bash Shell Interpreter
D.1 Running BashD.2 Command LinesD.2.1 Command Line ArgumentsD.2.2 Redirection and Piping ArgumentsD.3 Directories, Pathnames, and FilenamesD.4 Built-in and External Bash CommandsD.5 Basic Unix CommandsD.5.1 manD.5.2 cd or chdirD.5.3 pwdD.5.4 lsD.5.5 fileD.5.6 cat, less, more, and tailD.5.7 mvD.5.8 cpD.5.9 rmD.5.10 mkdirD.5.11 dateD.5.12 echoD.5.13 chmodD.6 Shell ScriptsD.6.1 Defining Shell Script Variables and ValuesD.6.2 Defining Special Shell VariablesD.6.3 Writing Your Own Shell ScriptsD.7 The build ScriptD.8 For More Information
E. Useful C Language Functions
E.1 String FunctionsE.2 Other C Stdlib and Unix Functions
F. Answers to Questions
Index

Overview

This book is the latest in Randall Hyde’s iconic series on assembly language programming. A comprehensive masterclass on 64-bit ARM, it guides you through the instruction set for the increasingly popular 64-bit ARM CPU, teaching you to translate high-level language operations into assembly language, write powerful programs unique to ARM, and handle the development of large software projects easily.

This book’s “quick-start” chapter lets you hit the ground running, showing you how to begin writing simple programs right away. After learning basic 64-bit ARM architecture and syntax for the GNU assembler, Hyde goes in-depth on the fundamentals of machine organization, computer data representation and operations, and memory access. After building a strong foundational knowledge for mastering GAS, control structures, and arithmetic functions, in later chapters you’ll be ready to dive into advanced ARM programming—and that’s when the real fun begins.

Full of illuminating illustrations, portable source code, and hands-on exercises that test your skills, The Art of ARM Assembly is an essential reference guide from the world’s foremost expert on the subject.

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

Publisher Resources

ISBN: 9798341620018Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills