The Art of ARM Assembly, Volume 1: 64-Bit ARM Machine Organization and Programming

Cover
Title Page
Copyright
Dedication
About the Author and Technical Reviewer
Acknowledgments
Introduction
   0.1 A Brief History of the ARM CPU
   0.2 Why Learn ARM Assembly?
   0.3 Why Learn 64-Bit ARM?
   0.4 Expectations and Prerequisites
   0.5 Source Code
   0.6 Typography and Pedantry
   0.7 Organization
Part I: Machine Organization
   1. Hello, World of Assembly Language
      1.1 What You’ll Need
         1.1.1 Setting Up Gas
         1.1.2 Setting Up a Text Editor
         1.1.3 Understanding C/C++ Examples
      1.2 The Anatomy of an Assembly Language Program
      1.3 Running Your First Assembly Language Program
      1.4 Running Your First Gas/C++ Hybrid Program
      1.5 The aoaa.inc Include File
      1.6 The ARM64 CPU Architecture
         1.6.1 ARM CPU Registers
         1.6.2 The Memory Subsystem
      1.7 Declaring Memory Variables in Gas
         1.7.1 Associating Memory Addresses with Variables
         1.7.2 Aligning Variables
         1.7.3 Declaring Named Constants in Gas
         1.7.4 Creating Register Aliases in Gas and Substituting Text
      1.8 Basic ARM Assembly Language Instructions
         1.8.1 ldr, str, adr, and adrp
         1.8.2 mov
         1.8.3 add and sub
         1.8.4 bl, blr, and ret
      1.9 The ARM64 Application Binary Interface
         1.9.1 Register Usage
         1.9.2 Parameter Passing and Function Result Conventions
      1.10 Calling C Library Functions
         1.10.1 Assembling Programs Under Multiple OSes
         1.10.2 Writing a “Hello, World!” Program
      1.11 Moving On
      1.12 For More Information
   2. Data Representation and Operations
      2.1 Numbering Systems
         2.1.1 Decimal
         2.1.2 Binary
         2.1.3 Hexadecimal
      2.2 Numbers vs. Representation
      2.3 Data Organization
         2.3.1 Bits
         2.3.2 Nibbles
         2.3.3 Bytes
         2.3.4 Half Words
         2.3.5 Words
         2.3.6 Double Words and Quad Words
      2.4 Logical Operations on Bits
         2.4.1 AND
         2.4.2 OR
         2.4.3 XOR
         2.4.4 NOT
      2.5 Logical Operations on Binary Numbers and Bit Strings
      2.6 Signed and Unsigned Numbers
      2.7 Sign Extension and Zero Extension
      2.8 Sign Contraction and Saturation
      2.9 Loading and Storing Byte and Half-Word Values
      2.10 Control-Transfer Instructions
         2.10.1 Branch
         2.10.2 Instructions That Affect the Condition Code Flags
         2.10.3 Conditional Branch
         2.10.4 cmp and Corresponding Conditional Branches
      2.11 Shifts and Rotates
      2.12 Bit Fields and Packed Data
      2.13 IEEE Floating-Point Formats
         2.13.1 Single-Precision Format
         2.13.2 Double-Precision Format
      2.14 Normalized Floating-Point Values
         2.14.1 Nonnumeric Values
         2.14.2 Gas Support for Floating-Point Values
      2.15 Binary-Coded Decimal Representation
      2.16 Characters
         2.16.1 The ASCII Character Encoding
         2.16.2 Gas Support for ASCII Characters
      2.17 Gas Support for the Unicode Character Set
      2.18 Machine Code
      2.19 Operand2
         2.19.1 #immediate
         2.19.2 #pattern
         2.19.3 Register
         2.19.4 Shifted Register
         2.19.5 Extending Register
      2.20 Large Constants
         2.20.1 movz
         2.20.2 movk
         2.20.3 movn
      2.21 Moving On
      2.22 For More Information
   3. Memory Access and Organization
      3.1 Runtime Memory Organization
         3.1.1 The .text Section
         3.1.2 The .data Section
         3.1.3 Read-Only Data Sections
         3.1.4 The .bss Section
         3.1.5 The .section Directive
         3.1.6 Declaration Sections
         3.1.7 Memory Access and MMU Pages
         3.1.8 PIE and ASLR
         3.1.9 The .pool Section
      3.2 Gas Storage Allocation for Variables
      3.3 Little-Endian and Big-Endian Data Organization
      3.4 Memory Access
      3.5 Gas Support for Data Alignment
      3.6 The ARM Memory Addressing Modes
         3.6.1 PC-Relative
         3.6.2 Register-Indirect
         3.6.3 Indirect-Plus-Offset
         3.6.4 Scaled Indirect-Plus-Offset
         3.6.5 Pre-indexed
         3.6.6 Post-Indexed
         3.6.7 Scaled-Indexed
      3.7 Address Expressions
      3.8 Getting the Address of a Memory Object
      3.9 The Push and Pop Operations
         3.9.1 Using Double Loads and Stores
         3.9.2 Executing the Basic Push Operation
         3.9.3 Executing the Basic Pop Operation
         3.9.4 Preserving at Least Two Registers
         3.9.5 Preserving Register Values on the Stack
         3.9.6 Saving Function Return Addresses on the Stack
      3.10 Pushing and Popping Stack Data
         3.10.1 Removing Data from the Stack Without Popping It
         3.10.2 Accessing Data Pushed onto the Stack Without Popping It
      3.11 Moving On
      3.12 For More Information
   4. Constants, Variables, and Data Types
      4.1 Gas Constant Declarations
      4.2 The Location Counter Operator
      4.3 Data Types and Gas
      4.4 Pointer Data Types
         4.4.1 Pointer Usage in Assembly Language
         4.4.2 Pointer Declarations in Gas
         4.4.3 Pointer Constants and Expressions
         4.4.4 Pointer Variables and Dynamic Memory Allocation
         4.4.5 Common Pointer Problems
      4.5 Composite Data Types
      4.6 Character Strings
         4.6.1 Zero-Terminated Strings
         4.6.2 Length-Prefixed Strings
         4.6.3 String Descriptors
         4.6.4 Pointers to Strings
         4.6.5 String Functions
      4.7 Arrays
         4.7.1 Declaring Arrays in Gas Programs
         4.7.2 Accessing Elements of a Single-Dimensional Array
         4.7.3 Sorting an Array of Values
         4.7.4 Implementing Multidimensional Arrays
      4.8 Structs
         4.8.1 Dealing with Limited Gas Support for Structs
         4.8.2 Initializing Structs
         4.8.3 Creating Arrays of Structs
         4.8.4 Aligning Fields Within a Struct
      4.9 Unions
      4.10 Moving On
      4.11 For More Information
Part II: Basic Assembly Language
   5. Procedures
      5.1 Assembly Language Programming Style
      5.2 Gas Procedures
         5.2.1 Gas Local Labels
         5.2.2 bl, ret, and br
      5.3 Saving the State of the Machine
      5.4 Call Trees, Leaf Procedures, and the Stack
         5.4.1 Activation Records
         5.4.2 Objects in the Activation Record
         5.4.3 ARM ABI Parameter-Passing Conventions
         5.4.4 Standard Entry Sequence
         5.4.5 Standard Exit Sequence
      5.5 Local Variables
         5.5.1 Low-Level Implementation of Automatic Variables
         5.5.2 The locals Macro
      5.6 Parameters
         5.6.1 Passing by Value
         5.6.2 Passing by Reference
         5.6.3 Using Low-Level Parameter Implementation
         5.6.4 Accessing Reference Parameters on the Stack
      5.7 Functions and Function Return Results
      5.8 Recursion
      5.9 Procedure Pointers and Procedural Parameters
      5.10 A Program-Defined Stack
      5.11 Moving On
      5.12 For More Information
   6. Arithmetic
      6.1 Additional ARM Arithmetic Instructions
         6.1.1 Multiplication
         6.1.2 Division and Modulo
         6.1.3 cmp Revisited
         6.1.4 Conditional Instructions
      6.2 Memory Variables vs. Registers
         6.2.1 Volatile vs. Nonvolatile Register Usage
         6.2.2 Global vs. Local Variables
         6.2.3 Easy Access to Global Variables
      6.3 Arithmetic Expressions
         6.3.1 Simple Assignments
         6.3.2 Simple Expressions
         6.3.3 Complex Expressions
         6.3.4 Commutative Operators
      6.4 Logical Expressions
      6.5 Conditional Comparisons and Boolean Expressions
         6.5.1 Implementing Conjunction Using ccmp
         6.5.2 Implementing Disjunction Using ccmp
         6.5.3 Handling Complex Boolean Expressions
      6.6 Machine and Arithmetic Idioms
         6.6.1 Multiplying Without mul
         6.6.2 Dividing Without sdiv or udiv
         6.6.3 Implementing Modulo-N Counters with AND
         6.6.4 Avoiding Needlessly Complex Machine Idioms
      6.7 Floating-Point and Finite-Precision Arithmetic
         6.7.1 Basic Floating-Point Terminology
         6.7.2 Limited-Precision Arithmetic and Accuracy
         6.7.3 Errors in Floating-Point Calculations
         6.7.4 Floating-Point Value Comparisons
      6.8 Floating-Point Arithmetic on the ARM
         6.8.1 Neon Registers
         6.8.2 Control Register
         6.8.3 Status Register
      6.9 Floating-Point Instructions
         6.9.1 FPU Data Movement Instructions
         6.9.2 FPU Arithmetic Instructions
         6.9.3 Floating-Point Comparisons
         6.9.4 Floating-Point Conversion Instructions
      6.10 The ARM ABI and Floating-Point Registers
      6.11 Using C Standard Library Math Functions
      6.12 Moving On
      6.13 For More Information
   7. Low-Level Control Structures
      7.1 Statement Labels
      7.2 Initializing Arrays with Statement Labels
      7.3 Unconditional Transfer of Control
      7.4 Register-Indirect Branches
      7.5 Taking the Address of Symbols in Your Code
         7.5.1 Revisiting the lea Macro
         7.5.2 Statically Computing the Address of a Symbol
         7.5.3 Dynamically Computing the Address of a Memory Object
         7.5.4 Working with Veneers
      7.6 Implementing Common Control Structures in Assembly Language
         7.6.1 Decisions
         7.6.2 if…then…else Sequences
         7.6.3 Complex if Statements Using Complete Boolean Evaluation
         7.6.4 Short-Circuit Boolean Evaluation
         7.6.5 Short-Circuit vs. Complete Boolean Evaluation
         7.6.6 Efficient Implementation of if Statements in Assembly Language
         7.6.7 switch…case Statements
      7.7 State Machines and Indirect Jumps
      7.8 Loops
         7.8.1 while
         7.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 Loops
      7.9 Loop Performance Improvements
         7.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 On
      7.11 For More Information
Part III: Advanced Assembly Language
   8. Advanced Arithmetic
      8.1 Extended-Precision Operations
         8.1.1 Addition
         8.1.2 Subtraction
         8.1.3 Comparisons
         8.1.4 Multiplication
         8.1.5 Division
         8.1.6 Negation
         8.1.7 AND
         8.1.8 OR
         8.1.9 XOR
         8.1.10 NOT
         8.1.11 Shift Operations
      8.2 Operating on Different-Size Operands
      8.3 Moving On
      8.4 For More Information
   9. Numeric Conversion
      9.1 Converting Numeric Strings to Values
         9.1.1 Numeric Values to Hexadecimal Strings
         9.1.2 Extended-Precision Hexadecimal Values to Strings
         9.1.3 Unsigned Decimal Values to Strings
         9.1.4 Signed Integer Values to Strings
         9.1.5 Extended-Precision Unsigned Integers to Strings
         9.1.6 Formatted Conversions
      9.2 Converting Floating-Point Values to Strings
         9.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 Conversions
         9.3.1 Decimal Strings to Integers
         9.3.2 Hexadecimal Strings to Numeric Form
         9.3.3 String to Floating-Point
      9.4 Other Numeric Conversions
      9.5 Moving On
      9.6 For More Information
   10. Table Lookups
      10.1 Using Tables in Assembly Language
         10.1.1 Function Computation via Table Lookup
         10.1.2 Function Domains and Ranges
         10.1.3 Domain Conditioning
         10.1.4 Table Generation
      10.2 Table-Lookup Performance
      10.3 Moving On
      10.4 For More Information
   11. Neon and SIMD Programming
      11.1 The History of SIMD Instruction Extensions
      11.2 Vector Registers
      11.3 Vector Data Movement Instructions
         11.3.1 Data Movement Between Registers
         11.3.2 Vector Load Immediate Instructions
         11.3.3 Register or Lane Value Duplication
         11.3.4 Vector Load and Store
         11.3.5 Interleaved Load and Store
         11.3.6 Register Interleaving and Deinterleaving
         11.3.7 Table Lookups with tbl and tbx
         11.3.8 Endian Swaps with rev16, rev32, and rev64
      11.4 Vertical and Horizontal Operations
      11.5 SIMD Logical Operations
      11.6 SIMD Shift Operations
         11.6.1 Shift-Left Instruction
         11.6.2 Saturating Shift Left
         11.6.3 Shift-Left Long
         11.6.4 Shift and Insert
         11.6.5 Signed and Unsigned Shift Right
         11.6.6 Accumulating Shift Right
         11.6.7 Narrowing Shift Right
         11.6.8 Saturating Shift Right with Narrowing
         11.6.9 Shift by a Variable Number of Bits
      11.7 SIMD Arithmetic Operations
         11.7.1 SIMD Addition
         11.7.2 Subtraction
         11.7.3 Absolute Difference
         11.7.4 Vector Multiplication
         11.7.5 Vector Division
         11.7.6 Sign Operations
         11.7.7 Minimum and Maximum
      11.8 Floating-Point and Integer Conversions
         11.8.1 Floating-Point to Integer
         11.8.2 Integer to Floating-Point
         11.8.3 Conversion Between Floating-Point Formats
         11.8.4 Floating-Point Values Rounded to the Nearest Integral
      11.9 Vector Square-Root Instructions
      11.10 Vector Comparisons
         11.10.1 Vector Integer Comparisons
         11.10.2 Vector Floating-Point Comparisons
         11.10.3 Vector Bit Test Instructions
         11.10.4 Vector Comparison Results
      11.11 A Sorting Example Using SIMD Code
      11.12 A Numeric-to-Hex-String Example Using SIMD Code
      11.13 Use of SIMD Instructions in Real Programs
      11.14 Moving On
      11.15 For More Information
   12. Bit Manipulation
      12.1 What Is Bit Data, Anyway?
      12.2 Instructions That Manipulate Bits
         12.2.1 Isolating, Clearing, and Testing Bits
         12.2.2 Setting and Inserting Bits
         12.2.3 Clearing Bits
         12.2.4 Inverting Bits
         12.2.5 Shift and Rotate
         12.2.6 Conditional Instructions
         12.2.7 Counting Bits
         12.2.8 Bit Reversal
         12.2.9 Bit Insertion and Selection
         12.2.10 Bit Extraction with ubfx
         12.2.11 Bit Movement with ubfiz
         12.2.12 Bit Movement with ubfm
         12.2.13 Bit Extraction with extr
         12.2.14 Bit Testing with tbz and tbnz
      12.3 Flag Modification by Arithmetic and Logical Instructions
         12.3.1 The Zero Flag
         12.3.2 The Negative Flag
         12.3.3 The Carry and Overflow Flags
      12.4 Packing and Unpacking Bit Strings
         12.4.1 Inserting One Bit String into Another
         12.4.2 Extracting a Bit String
         12.4.3 Clearing a Bit Field
         12.4.4 Using bfm
      12.5 Common Bit Operations
         12.5.1 Coalescing Bit Sets and Distributing Bit Strings
         12.5.2 Creating Packed Arrays of Bit Strings
         12.5.3 Searching for Bits
         12.5.4 Merging Bit Strings
         12.5.5 Scattering Bits from a Bit String
         12.5.6 Searching for a Bit Pattern
      12.6 Moving On
      12.7 For More Information
   13. Macros and the Gas Compile-Time Language
      13.1 The Gas Compile-Time Language Interpreter
      13.2 The C/C++ Preprocessor
         13.2.1 The #warning and #error Directives
         13.2.2 Compile-Time Constant Definition with CPP
         13.2.3 CPP Compile-Time Expressions
         13.2.4 Conditional Assembly
         13.2.5 CPP Macros
      13.3 Components of the Gas CTL
         13.3.1 Errors and Warnings During Assembly
         13.3.2 Conditional Assembly
         13.3.3 Compile-Time Loops
         13.3.4 Gas Macros
      13.4 The aoaa.inc Header File
      13.5 Generating Macros by Another Macro
      13.6 Choosing Between Gas Macros and CPP Macros
      13.7 Moving On
      13.8 For More Information
   14. String Operations
      14.1 Zero-Terminated Strings and Functions
      14.2 A String Format for Assembly Language Programmers
         14.2.1 Dynamic String Allocation
         14.2.2 String Copy Function
         14.2.3 String Comparison Function
         14.2.4 Substring Function
         14.2.5 More String Functions
      14.3 The Unicode Character Set
         14.3.1 Unicode History
         14.3.2 Code Points and Code Planes
         14.3.3 Surrogate Code Points
         14.3.4 Glyphs, Characters, and Grapheme Clusters
         14.3.5 Normal Forms and Canonical Equivalence
         14.3.6 Encodings
         14.3.7 Combining Characters
      14.4 Unicode in Assembly Language
         14.4.1 Writing Console Applications with UTF-8 Characters
         14.4.2 Using Unicode String Functions
      14.5 Moving On
      14.6 For More Information
   15. Managing Complex Projects
      15.1 The .include Directive
      15.2 Ignoring Duplicate Include Operations
      15.3 Assembly Units and External Directives
      15.4 Creating a String Library with Separate Compilation
      15.5 Introducing Makefiles
         15.5.1 Basic Makefile Syntax
         15.5.2 Make Clean and Touch
      15.6 Generating Library Files with the Archiver Program
      15.7 Managing the Impact of Object Files on Program Size
      15.8 Moving On
      15.9 For More Information
   16. Stand-Alone Assembly Language Programs
      16.1 Portability Issues with System Calls
      16.2 Stand-Alone Code and System Calls
      16.3 The svc Interface and OS Portability
         16.3.1 Call Numbers
         16.3.2 API Parameters
         16.3.3 API Error Handling
      16.4 A Stand-Alone “Hello, World!” Program
      16.5 A Sample File I/O Program
         16.5.1 volatiles.S Functions
         16.5.2 files.S File I/O Functions
         16.5.3 stdio.S Functions
         16.5.4 File I/O Demo Application
      16.6 Calling System Library Functions Under macOS
      16.7 Creating Assembly Applications Without GCC
      16.8 For More Information
Part IV: Reference Materials
   A. The ASCII Character Set
   B. Glossary
   C. Installing and Using Gas
      C.1 macOS
      C.2 Linux
   D. The Bash Shell Interpreter
      D.1 Running Bash
      D.2 Command Lines
         D.2.1 Command Line Arguments
         D.2.2 Redirection and Piping Arguments
      D.3 Directories, Pathnames, and Filenames
      D.4 Built-in and External Bash Commands
      D.5 Basic Unix Commands
         D.5.1 man
         D.5.2 cd or chdir
         D.5.3 pwd
         D.5.4 ls
         D.5.5 file
         D.5.6 cat, less, more, and tail
         D.5.7 mv
         D.5.8 cp
         D.5.9 rm
         D.5.10 mkdir
         D.5.11 date
         D.5.12 echo
         D.5.13 chmod
      D.6 Shell Scripts
         D.6.1 Defining Shell Script Variables and Values
         D.6.2 Defining Special Shell Variables
         D.6.3 Writing Your Own Shell Scripts
      D.7 The build Script
      D.8 For More Information
   E. Useful C Language Functions
      E.1 String Functions
      E.2 Other C Stdlib and Unix Functions
   F. Answers to Questions
Index