Raspberry Pi Assembly Language Programming ARM Processor Coding - Maker Innovations Series (Stephen Smith) (z-library.sk, 1lib.sk, z-lib.sk)

# Raspberry Pi Assembly Language Programming: ARM Processor Coding — Reading Guide ## 【One-Line Pitch】 A hands-on, project-driven introduction to ARM 64-bit Assembly Language on the Raspberry Pi, perfect for programmers who already know a high-level language like Python, C, or Java and want to understand what happens under the hood—from registers and memory to GPIO and code optimization. ## 【Book Arc】 - **Opening (~0%–9%)**: Sets up the 64-bit Raspberry Pi OS environment, introduces the ARM processor architecture, and explains how numbers, memory, and registers work—laying the foundation for everything that follows. - **Early (~9%–28%)**: Covers the core instruction set—MOV, ADD, SUB, shifts, and extension operators—with detailed walkthroughs of how the assembler translates high-level operations into actual ARM-64 machine code. - **Early (~28%–38%)**: Introduces GDB debugging, then moves into program flow control: loops, if/else constructs, condition codes, and bitwise logic, including practical patterns for implementing common high-level language constructs. - **Middle (~38%–47%)**: Explores memory operations in depth—loading/storing data, arrays, alignment, and the stack—then explains the ARM calling convention for functions, including register management and stack frames. - **Late (~47%–60%)**: Covers interfacing with the Raspberry Pi's hardware, particularly GPIO ports, and how to interoperate with C and Python code. - **Ending (~60%–100%)**: Delves into advanced topics: the NEON coprocessor for SIMD operations, code optimization techniques, and how to read and reverse-engineer existing machine code using tools like GCC, GDB, and Ghidra. ## 【Key Takeaways】 - **ARM-64 is a different beast from x86** (Early): The instruction set is regular and orthogonal—most instructions take the same operand forms—which makes it easier to learn than x86 once you grasp the patterns. This regularity pays off when you start reading ARM reference documentation. - **Registers are the star of the show** (Early): ARM-64 has 31 general-purpose registers (X0–X30) plus a dedicated stack pointer, and understanding how data moves between registers and memory is the core skill. The book emphasizes that most instructions execute in one clock cycle thanks to pipelining. - **Immediate operands have hidden complexity** (Early): The MOV instruction isn't as simple as it looks—the assembler converts it into ORR or MOVZ instructions depending on the value, and there are extension operators (uxtb, sxtw, etc.) for sign/zero-extending values. This matters when you're trying to understand disassembled code. - **The stack is your friend for function calls** (Middle): The ARM calling convention divides registers into caller-saved (X0–X18) and callee-saved (X19–X30) categories, and the book walks through exactly how to manage the stack pointer (SP) and link register (LR) when creating functions. - **Condition codes and branching are the heart of control flow** (Early): The book shows how to implement loops, if/else, and even SELECT/CASE constructs using CMP, SUBS, and conditional branches—patterns you'll reuse constantly in real assembly projects. - **Memory alignment matters on ARM** (Middle): The ARM processor often requires data to be aligned on word boundaries, and the book explains the .align directive and how to properly index into arrays with LDR/STR instructions. - **Optimization is about understanding trade-offs** (Late): The book covers practical techniques—avoiding branches, using conditional instructions, loop unrolling, keeping data small, and leveraging SIMD—while also warning about real-world issues like CPU overheating on the Pi. - **Reverse engineering is a learnable skill** (Late): By studying code generated by GCC and using tools like Ghidra, you can learn to read and understand machine code, which is invaluable for debugging and for taking control of the Pi's hardware. ## 【Reading Tips】 - **Skim the first chapter if you're comfortable with number systems**: The base-10 vs. base-2 explanation is thorough but basic; the real value starts with the instruction set walkthroughs in Chapter 2. - **Deep-read Chapters 2–4**: These cover the fundamental instructions (MOV, ADD, SUB, shifts) and control flow. Work through the exercises—especially the 128-bit addition/subtraction problems—because they force you to understand carry flags and register management. - **Use the accompanying code snippets**: The book references a codesnippets.s file for each chapter. Download these and step through them in GDB as you read—this is where the learning really sticks. - **Pay special attention to the register convention table in Chapter 6**: This is the single most important reference for writing functions that work correctly with the Linux ABI. Bookmark it. - **The optimization and reverse-engineering chapters (13–14) are skimmable on first read**: Come back to them when you have a specific performance problem or need to understand unfamiliar code—they're reference material more than sequential reading. ## 【Coverage Limits】 This guide covers the book's progression from fundamentals through advanced topics based on the available excerpts. The excerpts do not cover the full details of the GPIO interfacing chapters or the complete NEON coprocessor examples, though these are mentioned in the table of contents. ##