The Art of ARM Assembly, Volume 1 64-Bit ARM Machine Organization and Programming (Randall Hyde)（Z-Library） (1)

【One-Line Pitch】 A hands-on, Gas-centered course in 64-bit ARM assembly that teaches you how real machines organize memory, data, and control flow—best for programmers who already know a high-level language and want to understand what the compiler actually emits. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the case for learning ARM assembly (Apple Silicon, Raspberry Pi, mobile/embedded), introduces the GNU Assembler (Gas) and the ARM lineage from the 6502/RISC heritage, then lays the data-representation groundwork: binary/hex, signed vs. unsigned, extension and saturation, IEEE floating point, BCD, ASCII/Unicode, and the Operand2 forms behind immediate and shifted-register operands. - **Early (~10%–30%)**: Moves into machine organization—runtime memory sections (.text, .data, .bss, .pool), endianness, alignment, the full set of ARM addressing modes, push/pop and stack discipline—then builds the programmer's toolkit: constants, pointers, strings, arrays, structs, unions, procedures with activation records and ABI parameter passing, and floating-point/FPU arithmetic. - **Middle (~30%–50%)**: Covers low-level control structures (branches, if/else, switch, state machines, loops and loop optimization), advanced arithmetic on extended-precision and mixed-size operands, numeric conversion between strings and values, and table-lookup techniques—the "translate HLL constructs into instruction sequences" core of the book. - **Late (~50%–75%)**: Shifts to advanced material: Neon/SIMD vector programming (loads, shuffles, vertical/horizontal ops, shifts), bit manipulation with bitfield instructions, and the Gas compile-time language including C preprocessor macros and conditional assembly. - **Ending (~75%–100%)**: Applies everything to real projects—string libraries and Unicode handling, multi-file assembly with .include/extern directives, makefiles and archiver-built libraries, and stand-alone programs using the svc system-call interface across Linux and macOS; reference appendices cover ASCII, a glossary, Gas installation, Bash, and useful C functions. 【Book Arc note】The excerpts are dominated by the table of contents and front matter; percentages above are inferred from chapter ordering rather than confirmed position markers. 【Key Takeaways】 - **Assembly is taught as machine organization, not just syntax** (Opening): the stated rationale is that understanding the underlying machine helps you write and debug better high-level code—speed, space, and bit-twiddling are the practical payoffs. - **Gas is the assumed toolchain throughout** (Opening): examples, directives, and macro facilities are tied to the GNU Assembler, with installation guidance for macOS and Linux, so setup matters before chapter one. - **Data representation is treated as first-class** (Opening): sign/zero extension, saturation, IEEE formats, BCD, and character encodings are covered before serious programming, because ARM operands and conversions depend on them. - **Memory layout and addressing modes are the hinge of the book** (Early): sections, PIE/ASLR, endianness, alignment, and the seven-plus addressing modes (PC-relative, pre/post-indexed, scaled-indexed) are what let you actually reach variables. - **Procedures follow the ARM ABI explicitly** (Early): activation records, leaf procedures, standard entry/exit sequences, and parameter-passing conventions are spelled out rather than left implicit. - **HLL constructs are rebuilt from branches and flags** (Middle): if/else, short-circuit vs. complete Boolean evaluation, switch, state machines, and loop optimizations show how compilers think—and where you can beat them. - **Advanced topics go beyond scalar code** (Late): extended-precision arithmetic, numeric conversion, table lookups, Neon SIMD, bitfield instructions, and Gas macro programming extend the toolkit substantially. - **The book ends in engineering practice** (Ending): separate compilation, makefiles, static libraries, and stand-alone svc-based programs (including a "Hello, World!" and file I/O demo) turn exercises into buildable projects. 【Reading Tips】 - **Skim the front matter and appendices first** to confirm your Gas setup (macOS vs. Linux) and Bash familiarity; the main text assumes a working toolchain. - **Deep-read Chapters 2–4 (data representation, memory, addressing)**—everything later depends on Operand2, addressing modes, and stack discipline; this is where most readers stall. - **Treat Parts II–III as a translation exercise**: after each control-structure or arithmetic section, write the equivalent in C and compare with compiler output to internalize the mapping. - **Don't skip the macro/compile-time chapter if you plan real projects**; the string library and makefile chapters build directly on it. - **Use the appendices as reference, not narrative**—ASCII tables, glossary, and C function lists are lookup material. 【Coverage Limits】 This guide is synthesized from stratified excerpts that are largely the table of contents and front matter; specific code examples, exercise content, and chapter-level depth are not covered, so treat chapter-level claims as structural rather than verified detail.