book

Learn LLVM 17 - Second Edition

Name: Learn LLVM 17 - Second Edition
ISBN: 9781837631346

by Kai Nacke, Amy Kwan

January 2024

Beginner to intermediate

416 pages

9h 46m

English

Packt Publishing

Read now

Unlock full access

Learn LLVM 17
ContributorsAbout the authorsAbout the reviewers
Preface
What’s new in this editionWho this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1: The Basics of Compiler Construction with LLVM
Chapter 1: Installing LLVM
Compiling LLVM versus installing binariesGetting the prerequisites readyUbuntuFedora and RedHatFreeBSDOS XWindowsCloning the repository and building from sourceConfiguring GitCloning the repositoryCreating a build directoryGenerating the build system filesCompiling and installing LLVMCustomizing the build processVariables defined by CMakeUsing LLVM-defined build configuration variablesSummary
Chapter 2: The Structure of a Compiler
Building blocks of a compilerAn arithmetic expression languageFormalism for specifying the syntax of a programming languageHow does grammar help the compiler writer?Lexical analysisA hand-written lexerSyntactical analysisA hand-written parserThe abstract syntax treeSemantic analysisGenerating code with the LLVM backendTextual representation of LLVM IRGenerating the IR from the ASTThe missing pieces – the driver and the runtime librarySummary
Part 2: From Source to Machine Code Generation
Chapter 3: Turning the Source File into an Abstract Syntax Tree
Defining a real programming languageCreating the project layoutManaging the input files for the compilerHandling messages for the userStructuring the lexerConstructing a recursive descent parserPerforming semantic analysisHandling the scope of namesUsing an LLVM-style RTTI for the ASTCreating the semantic analyzerSummary
Chapter 4: Basics of IR Code Generation
Generating IR from the ASTUnderstanding the IR codeLearning about the load-and-store approachMapping the control flow to basic blocksUsing AST numbering to generate IR code in SSA formDefining the data structure to hold valuesReading and writing values local to a basic blockSearching the predecessor blocks for a valueOptimizing the generated phi instructionsSealing a blockCreating the IR code for expressionsEmitting the IR code for a functionControlling visibility with linkage and name manglingConverting a type from an AST description into LLVM typesCreating the LLVM IR functionEmitting the function bodySetting up the module and the driverWrapping all in the code generatorInitializing the target machine classEmitting assembler text and object codeSummary
Chapter 5: IR Generation for High-Level Language Constructs
Technical requirementsWorking with arrays, structs, and pointersGetting the application binary interface rightCreating IR code for classes and virtual functionsImplementing single inheritanceExtending single inheritance with interfacesAdding support for multiple inheritanceSummary
Chapter 6: Advanced IR Generation
Throwing and catching exceptionsRaising an exceptionCatching an exceptionIntegrating the exception handling code into the applicationGenerating metadata for type-based alias analysisUnderstanding the need for additional metadataCreating TBAA metadata in LLVMAdding TBAA metadata to tinylangAdding debug metadataUnderstanding the general structure of debug metadataTracking variables and their valuesAdding line numbersAdding debug support to tinylangSummary

Chapter 7: Optimizing IR
Technical requirementsThe LLVM pass managerImplementing a new passDeveloping the ppprofiler pass as a pluginAdding the pass to the LLVM source treeUsing the ppprofiler pass with LLVM toolsAdding an optimization pipeline to your compilerCreating an optimization pipelineExtending the pass pipelineSummary
Part 3: Taking LLVM to the Next Level
Chapter 8: The TableGen Language
Technical requirementsUnderstanding the TableGen languageExperimenting with the TableGen languageDefining records and classesCreating multiple records at once with multiclassesSimulating function callsGenerating C++ code from a TableGen fileDefining data in the TableGen languageImplementing a TableGen backendDrawbacks of TableGenSummary
Chapter 9: JIT Compilation
Technical requirementsLLVM’s overall JIT implementation and use casesUsing JIT compilation for direct executionExploring the lli toolImplementing our own JIT compiler with LLJITIntegrating the LLJIT engine into the calculatorCode generation changes to support JIT compilation via LLJITBuilding an LLJIT-based calculatorBuilding a JIT compiler class from scratchCreating a JIT compiler classUsing our new JIT compiler classSummary
Chapter 10: Debugging Using LLVM Tools
Technical requirementsInstrumenting an application with sanitizersDetecting memory access problems with the address sanitizerFinding uninitialized memory accesses with the memory sanitizerPointing out data races with the thread sanitizerFinding bugs with libFuzzerLimitations and alternativesPerformance profiling with XRayChecking the source with the clang static analyzerAdding a new checker to the clang static analyzerCreating your own clang-based toolSummary
Part 4: Roll Your Own Backend
Chapter 11: The Target Description
Setting the stage for a new backendAdding the new architecture to the Triple classExtending the ELF file format definition in LLVMCreating the target descriptionAdding the register definitionDefining the instruction formats and the instruction informationCreating the top-level file for the target descriptionAdding the M88k backend to LLVMImplementing the assembler parserCreating the disassemblerSummary
Chapter 12: Instruction Selection
Defining the rules of the calling conventionImplementing the rules of the calling conventionInstruction selection via the selection DAGImplementing DAG lowering – handling legal types and setting operationsImplementing DAG lowering – lowering formal argumentsImplementing DAG lowering – lowering return valuesImplementing DAG-to-DAG transformations within instruction selectionAdding register and instruction informationPutting an empty frame lowering in placeEmitting machine instructionsCreating the target machine and the sub-targetImplementing M88kSubtargetImplementing M88kTargetMachine – defining the definitionsImplementing M88kTargetMachine – adding the implementationGlobal instruction selectionLowering arguments and return valuesLegalizing the generic machine instructionsSelecting a register bank for operandsTranslating generic machine instructionsRunning an exampleHow to further evolve the backendSummary
Chapter 13: Beyond Instruction Selection
Adding a new machine function pass to LLVMImplementing the top-level interface for the M88k targetAdding the TargetMachine implementation for machine function passesDeveloping the specifics of the machine function passBuilding newly implemented machine function passesA glimpse of running a machine function pass with llcIntegrating a new target into the clang frontendImplementing the driver integration within clangImplementing ABI support for M88k within clangImplementing the toolchain support for M88k within clangBuilding the M88k target with clang integrationTargeting a different CPU architectureSummary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Overview

Dive into the fascinating world of compilers with 'Learn LLVM 17'. Through a step-by-step approach, this book will guide you in building your first compiler using the powerful LLVM framework. The comprehensive content will not only demonstrate how to get started with LLVM's libraries but also equip you with the know-how to extend and optimize compilers effectively.

What this Book will help me do

Understand the structure and components of a compiler, from source code to backend.
Master the LLVM Intermediate Representation (IR) to generate and optimize code.
Learn to extend LLVM with custom transformation passes and tooling.
Develop skills to create a backend targeting new architectures.
Familiarize yourself with JIT compilation and debugging tools within LLVM.

Author(s)

Kai Nacke, an experienced software engineer and compiler developer, has extensive expertise in using LLVM for real-world applications. Amy Kwan, a seasoned educator in programming languages and compiler construction, complements the practical approach with conceptual clarity. Together, they bring years of hands-on experience and an engaging teaching style to this book, making it accessible to learners at all levels.

Who is it for?

This book is tailored for software engineers, compiler enthusiasts, and developers with a basic understanding of C++ who aim to learn about LLVM and compilers. Whether you're a beginner exploring compiler development or a developer aiming to deepen your knowledge, 'Learn LLVM 17' equips you with the skills needed to excel in this field.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

The C++ Programming Language, 4th Edition

Publisher Resources

ISBN: 9781837631346

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills