LLVM Cookbook (Mayur Pandey, Suyog Sarda)（Z-Library）

【One-Line Pitch】 A practical, recipe-driven guide for compiler programmers and performance-minded developers who want to master LLVM's infrastructure—from IR generation and optimization passes to backend code generation—by building a working compiler step by step. 【Book Arc】 - **Opening (~0%–10%)**: Introduces LLVM's modular architecture and core toolchain. Readers learn to generate IR from C code using Clang, compile IR to assembly with llc, and link bitcode files with llvm-link—establishing the fundamental workflow. - **Early (~10%–23%)**: Builds a complete TOY language frontend. This section walks through lexer/parser design, AST class hierarchies, and the grammar rules needed to handle expressions, function declarations, and calls—giving readers a hands-on compiler construction experience. - **Early–Middle (~23%–39%)**: Focuses on IR code generation and optimization integration. Readers implement Codegen() methods for expressions and functions, then add optimization passes like instruction combining and GVN through the PassManager—showing how to improve generated code quality. - **Middle (~39%–48%)**: Extends the TOY language with control flow (if/then/else, loops) and user-defined operators (binary/unary). This section also introduces JIT support and transitions into LLVM's optimization framework, covering pass writing, registration, and analysis passes. - **Late (~48%–end)**: Covers backend development and practical applications. Excerpts show instruction selection, encoding, frame lowering, and subtarget support, plus real-world uses like exception handling and sanitizers—completing the journey from frontend to production-ready compiler features. 【Key Takeaways】 - **LLVM's modular design is its superpower** (Opening): The toolchain separates frontend (Clang), optimizer (opt), and backend (llc), allowing each stage to be used independently or combined. This means you can plug in custom components at any level. - **IR is the universal intermediate representation** (Early): LLVM IR sits between source and assembly, in SSA form where each variable assignment creates a new variable. Understanding IR is essential because all optimizations and backend work operate on this representation. - **Building a lexer/parser is systematic** (Early): The TOY language example shows a clear pattern: define token types, write recursive descent parsers for each grammar rule, and build AST nodes. This structure scales from simple expressions to full function definitions. - **Code generation follows AST structure** (Early–Middle): Each AST node gets a Codegen() method that emits LLVM IR using the Builder API. The pattern is consistent—generate code for children, combine results, and return a Value*—making it easy to extend with new language features. - **Optimization passes are composable** (Middle): LLVM provides a rich set of passes (instruction combining, reassociation, GVN) that can be chained in a FunctionPassManager. You control which passes run and their order, giving you fine-grained control over code quality. - **Control flow requires basic block management** (Middle): Implementing if/then/else and loops involves creating BasicBlocks, setting insert points, and using conditional branches. This teaches the fundamental pattern for all control flow in LLVM IR. - **Backend development is a multi-step process** (Late): From instruction selection to encoding and frame lowering, each backend component has a specific role. The recipe format makes it approachable, showing how to add a new target or extend an existing one. 【Reading Tips】 - **Skim the toolchain chapters (Opening)**: If you're already familiar with Clang and llc, quickly review the command examples and focus on the llvm-link workflow, which is less commonly covered elsewhere. - **Deep-read the TOY language chapters (Early)**: This is the heart of the book. Follow along with the code—type out the AST classes and parser functions yourself. The pattern of "define grammar → build AST → generate IR" will stick better through hands-on practice. - **Pay attention to Codegen() patterns (Middle)**: The way each AST node emits IR is the key transferable skill. Notice how the Builder tracks the current insert point and how values flow between expressions. - **Use the optimization chapters as reference (Middle)**: You don't need to memorize every pass. Instead, understand the pass manager architecture and how to write a custom pass—then look up specific passes when you need them. - **Treat backend chapters as advanced material (Late)**: These recipes are valuable but assume solid LLVM knowledge. Skim initially to understand the scope, then return when you're ready to work on a specific backend component. 【Coverage Limits】 The excerpts cover the frontend (TOY language), IR generation, optimization passes, and early backend topics well, but do not fully detail JIT implementation, exception handling internals, or sanitizer usage—these sections appear in the table of contents but lack substantive content in the available material.