Learn LLVM 12: A beginner's guide to learning LLVM compiler tools and core libraries with C++

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Section 1 – The Basics of Compiler Construction with LLVM
Chapter 1: Installing LLVM
	Getting the prerequisites ready
		Ubuntu
		Fedora and RedHat
		FreeBSD
		OS X
		Windows
		Configuring Git
	Building with CMake
		Cloning the repository
		Creating a build directory
		Generating the build system files
	Customizing the build process
		Variables defined by CMake
		Variables defined by LLVM
	Summary
Chapter 2: Touring the LLVM Source
	Technical requirements
	Contents of the LLVM mono repository
		LLVM core libraries and additions
		Compilers and tools
		Runtime libraries
	Layout of an LLVM project
	Creating your own project using LLVM libraries
		Creating the directory structure
		Adding the CMake files
		Adding the C++ source files
		Compiling the tinylang application
	Targeting a different CPU architecture
	Summary
Chapter 3: Structure of a Compiler
	Technical requirements
	Building blocks of a compiler
	An arithmetic expression language
		Formalism for specifying the syntax of a programming language
		How grammar helps the compiler writer
	Lexical analysis
		A handwritten lexer
	Syntactical analysis
		A handwritten parser
		The abstract syntax tree
	Semantic analysis
	Generating code with the LLVM backend
		Textual representation of the LLVM IR
		Generating the IR from the AST
		The missing pieces – the driver and the runtime library
	Summary
Section 2 – From Source to Machine Code Generation
Chapter 4: Turning the Source File into an Abstract Syntax Tree
	Technical requirements
	Defining a real programming language
	Creating the project layout
	Managing source files and user messages
	Structuring the lexer
	Constructing a recursive descent parser
	Generating a parser and lexer with bison and flex
	Performing semantic analysis
		Handling the scope of names
		Using LLVM-style RTTI for the AST
		Creating the semantic analyzer
	Summary
Chapter 5: Basics of IR Code Generation
	Technical requirements
	Generating IR from the AST
		Understanding the IR code
		Knowing the load-and-store approach
		Mapping the control flow to basic blocks
	Using AST numbering to generate IR code in SSA form
		Defining the data structure to hold values
		Reading and writing values local to a basic block
		Searching the predecessor blocks for a value
		Optimizing the generated phi instructions
		Sealing a block
		Creating IR code for expressions
		Emitting the IR code for a function
		Controlling visibility with linkage and name mangling
		Converting types from an AST description to LLVM types
		Creating the LLVM IR function
		Emitting the function body
	Setting up the module and the driver
		Wrapping everything in the code generator
		Initializing the target machine class
		Emitting assembler text and object code
	Summary
Chapter 6: IR Generation for High-Level Language Constructs
	Technical requirements
	Working with arrays, structs, and pointers
	Getting the application binary interface right
	Creating IR code for classes and virtual functions
		Implementing single inheritance
		Extending single inheritance with interfaces
		Adding support for multiple inheritance
	Summary
Chapter 7: Advanced IR Generation
	Technical requirements
	Throwing and catching exceptions
		Raising an exception
		Catching an exception
		Integrating the exception-handling code into the application
	Generating metadata for type-based alias analysis
		Understanding the need for additional metadata
		Adding TBAA metadata to tinylang
	Adding debug metadata
		Understanding the general structure of debug metadata
		Tracking variables and their values
		Adding line numbers
		Adding debug support to tinylang
	Summary
Chapter 8: Optimizing IR
	Technical requirements
	Introducing the LLVM Pass manager
	Implementing a Pass using the new Pass manager
		Adding a Pass to the LLVM source tree
		Adding a new Pass as a plugin
	Adapting a Pass for use with the old Pass manager
	Adding an optimization pipeline to your compiler
		Creating an optimization pipeline with the new Pass manager
		Extending the Pass pipeline
	Summary
Section 3 – Taking LLVM to the Next Level
Chapter 9: Instruction Selection
	Technical requirements
	Understanding the LLVM target backend structure
	Using MIR to test and debug the backend
	How instruction selection works
		Specifying the target description in the TableGen language
		Instruction selection with the selection DAG
		Fast instruction selection – FastISel
		The new global instruction selection – GlobalISel
	Supporting new machine instructions
		Adding a new instruction to the assembler and code generation
		Testing the new instruction
	Summary
Chapter 10: JIT Compilation
	Technical requirements
	Getting an overview of LLVM's JIT implementation and use cases
	Using JIT compilation for direct execution
		Exploring the lli tool
		Implementing our own JIT compiler with LLJIT
		Building a JIT compiler class from scratch
	Utilizing a JIT compiler for code evaluation
		Identifying the language semantics
	Summary
Chapter 11: Debugging Using LLVM Tools
	Technical requirements
	Instrumenting an application with sanitizers
		Detecting memory access problems with the address sanitizer
		Finding uninitialized memory access with the memory sanitizer
		Pointing out data races with the thread sanitizer
	Finding bugs with libFuzzer
		Limitations and alternatives
	Performance profiling with XRay
	Checking the source with the Clang Static Analyzer
		Adding a new checker to the Clang Static Analyzer
	Creating your own Clang-based tool
	Summary
Chapter 12: Create Your Own Backend
	Technical requirements
	Setting the stage for a new backend
	Adding the new architecture to the Triple class
	Extending the ELF file format definition in LLVM
	Creating the target description
		Implementing the top-level file of the target description
		Adding the register definition
		Defining the calling convention
		Creating the scheduling model
		Defining the instruction formats and the instruction information
	Implementing the DAG instruction selection classes
		Initializing the target machine
		Adding the selection DAG implementation
		Supporting target-specific operations
		Configuring the target lowering
	Generating assembler instructions
	Emitting machine code
	Adding support for disassembling
	Piecing it all together
	Summary
Other Books You May Enjoy
Index