Assembly Language Reimagined Programming the Intel X64 Microprocessor in Linux (John Schwartzman)（Z-Library）

# Assembly Language Reimagined: Programming the Intel X64 Microprocessor in Linux ## 【One-Line Pitch】 A hands-on, laboratory-style guide that teaches Intel x64 assembly on Linux by showing exactly what the CPU does when high-level C/C++ code runs, making you a more capable and versatile programmer. Ideal for embedded developers, engineers, hobbyists, and CS students who already know C or C++ and want to understand low-level programming from the ground up. ## 【Book Arc】 - **Opening (~0%–9%)**: Establishes why assembly matters—not for speed or portability, but for deeper understanding—and introduces core concepts like mnemonics, addressing modes, embedded programming constraints, and the CISC vs. RISC distinction. - **Early (~9%–25%)**: Dives into BIOS services and Linux syscalls, walking through the SYS_WRITE example with register marshaling (rdi, rsi, rdx, rax), the `lea` instruction, and using the DDD debugger to observe register changes step-by-step. - **Early (~25%–34%)**: Extends to the uname syscall, compares assembly output with equivalent C programs, and introduces Boolean logic gates, data types (byte, word, doubleword, quadword), and the C calling convention with callee-saved registers. - **Middle (~34%–44%)**: Shifts from BIOS to glibc calls, explaining the linker's role, .bss sections, and shell script integration (os-distro.sh), then moves to command-line argument handling with argc/argv and printf's variadic argument mechanism. - **Middle (~44%–47%+)**: Covers macros (like getSaveEnv) and passing arguments on the stack, including mixed C/assembly programs where assembly exports functions callable from C (e.g., printenv called from main). ## 【Key Takeaways】 - **Assembly is about understanding, not speed** (Opening): The book's core premise is that learning assembly makes you a better programmer by revealing what the processor can and can't do—not by making your code faster or more portable. - **Mnemonics simplify machine language** (Opening): Assembly substitutes numeric op codes with readable names like MOV, ADD, and JMP, and addressing modes (immediate, register, memory) are determined by the arguments you supply. - **Registers are the CPU's fast, named memory** (Early): The 64-bit registers like rdi (destination index) and rsi (source index) are special-purpose for strings, and marshaling arguments into the right registers before a syscall is the key to Linux kernel services. - **The `lea` instruction loads addresses, not values** (Early): Unlike `mov`, `lea rsi, [msg]` computes and loads the memory address of msg into a register, with the assembler handling arithmetic like `listIndex + 8 * rcx` for you. - **Syscalls use rax as the service selector** (Early): The `syscall` instruction always calls the same kernel entry point; the value in rax (e.g., SYS_WRITE=1, SYS_UNAME=63) tells Linux which service to perform, and arguments must be in the expected registers. - **glibc is preferred over raw BIOS calls** (Middle): The gcc linker handles glibc startup/shutdown modules automatically, making it easier to call printf and other C library functions from assembly than to use low-level syscalls directly. - **Data types have platform-specific meanings** (Early): Linux uses quadwords (64-bit) for long integers while Microsoft uses doublewords (32-bit), and all types except characters can be signed or unsigned with sign bits in the upper half. - **Mixed C/assembly programming is practical** (Middle): Assembly functions can be declared in C (e.g., `int printenv(const char*)`) and called from main, with macros like getSaveEnv reducing repetitive code for environment variable lookups. ## 【Reading Tips】 - **Skim the preface and early chapters** (~0%–9%) for motivation and terminology, but don't get bogged down in CISC vs. RISC debates—the practical syscall examples starting at ~9% are where the real learning begins. - **Deep-read the SYS_WRITE and uname examples** (~9%–34%): Follow along with the DDD debugger as the book suggests, stepping through instructions and watching registers change—this hands-on approach is essential for internalizing register marshaling. - **Pay special attention to the C calling convention** (~34%): Understanding callee-saved registers and how printf's variadic arguments work (format string in rdi, additional args in rsi, etc.) is critical for later chapters on macros and stack passing. - **Work through the Activities** at the end of each chapter (e.g., why `xor rax, rax` is used, creating a `zero` macro)—these reinforce the "why" behind each instruction and prepare you for the mixed C/assembly exercises. - **Use the provided makefiles and shell scripts** as templates: The book includes complete build infrastructure (yasm, ld, gcc) and scripts like os-distro.sh, so replicate these setups to avoid environment issues and focus on the assembly logic. ## 【Coverage Limits】 This guide covers the book's progression from BIOS syscalls to glibc integration, command-line handling, and macros, based on excerpts through ~47% of the book. Later chapters on advanced topics (e.g., floating-point, SIMD, or advanced debugging) are not covered by the available excerpts. ##