To work with the LLVM code base, you need specific tools on your system. In this section, we list the required versions of these tools for the latest major LLVM release: 20.1.0.

Later, in Identifying the right version of the tools, you will learn how to find the version of the tools required to build a specific version of LLVM, including older and newer releases and the LLVM top-of-tree (that is, the actively developed repository). Additionally, you will learn how to install them.

With no further due, here are the versions of the tools required for LLVM 20.1.0:

In the Technical requirement section, we already listed which version of tools you needed to work with LLVM 20.1.0. However, LLVM is a lively project and what is required today may be different than what is required tomorrow. Also, to step back a bit, you may not know why you need these tools to begin with and/or how to get them.

This section addresses these questions, and you will learn the following in the process:

• The purpose of each required tool
• How to check that your environment has the proper tools
• How to install the proper tools

Depending on how familiar you are with development on Linux/macOS, this setup can be tedious or a walk in the park.

Ultimately, this section aims to teach you how to go beyond a fixed release of LLVM by giving you the knowledge required to find the information you need.

If you are familiar with package managers (e.g., the apt-get command-line tool on Linux and Homebrew...

In this section, we will introduce the different parts of what makes a compiler and how they relate to the LLVM code base. In the process, you will do the following:

• Understand the overall architecture of a compiler
• Learn how to build Clang from the source
• Be able to decide which components of LLVM you need to build

If you are already familiar with the components of a compiler toolchain and want to jump straight into the action, skip directly to the Building LLVM section.

What is a compiler?

The definition of a compiler means different things for different people. For instance, for a student in their first year of computer science, a compiler may be seen as a tool that translates a source language into executable code. This is a possible definition, but it is also a very coarse-grain one.

When you look closer at a compiler, you will find that it is a collection of different tools, or libraries, working together to achieve...

This is where your journey as a backend developer starts: you will learn how to build the core LLVM project.

Instead of just dropping a bunch of commands for you to run (we will do some of that too, we promise), you will discover the most relevant knobs that you can use to tailor the build process to your needs.

We believe this is important knowledge to gain as it will help you optimize your development process and increase your productivity by focusing on what you need to build/run for your use cases.

To set the context, the core LLVM project contains all the necessary pieces to build an optimizing backend from LLVM IR down to assembly code/an object file for 20+ different architectures. This is a lot of code and chances are that you do not care about all these architectures. Therefore, at the very least, learning how to build only the ones you care about will save you compile time and down the road will improve your development speed.

Configuring the...

In the previous section, you have learned how to run the core LLVM unit tests, but this is only the beginning of the story. There are two big missing pieces:

• How do you understand and reproduce a failing unit test?
• How do you go beyond unit testing?

Let us answer these questions in the following sections. However, first, we need a primer on some of the tools/infrastructure used for testing in LLVM.

Crash course on the Google test infrastructure

LLVM uses the Google test infrastructure (gtest) for some of its unit tests.

The tests based on gtest are regular C++ codes and produce regular executables. If you open one of the source files of the tests using this framework, you will find gtest-specific directives (e.g., EXPECT_EQ, TEST, etc.) but nothing complicated beyond that.

Running the related executable will directly reproduce whatever issue you may want to investigate and all the techniques you know for debugging C++ code...

In this section, you will learn the basics of how the LLVM folders are organized. This knowledge will come in handy when you start contributing to LLVM. This will help you shape patches that follow the philosophy behind the directory structure and hence, help you avoid unnecessary rounds of reviews where you would have to fix that.

High-level directory structure

At a high level, the LLVM code base is organized into projects: Clang, MLIR, the LLVM debugger (LLDB), and many more. Each project has its own directory, and its name matches the name of the related project in lowercase: clang, mlir, lldb, and so on.

You need to use these directory names in the LLVM_ENABLE_PROJECTS CMake variable to build the related projects.

The common theme around these projects is that they use or contribute to a part of the LLVM infrastructure.

Focusing on the core LLVM project

Unsurprisingly, the core LLVM project lives in the llvm directory...

In this chapter, you learned how to set up your development environment and how to find the required version of the different tools to build the different versions of the LLVM infrastructure, including the open-source repository. This is a necessary step to be able to get started with building the LLVM infrastructure.

Next, you discovered the main components that make a compiler toolchain, namely the driver, frontend, backend, linker, and standard library, and which LLVM project they map to. This information will come in handy when you decide what you want to build out of the LLVM infrastructure.

After that, you dove into the build configurations of the core LLVM project and learned how to tweak the CMake variables to tailor the build to your needs while balancing the debuggability of the produced artifacts and the build time. You also learned how to use Ninja, the driver of the build system, efficiently to reduce the turnaround time between development, building,...

Now that you have completed reading this chapter, answer the following questions to test your knowledge:

1. You have a pristine clone of the LLVM code base and yet the build fails with weird compiler errors. What could be the reason?

The most likely reasons are as follows:

• The LLVM code base is temporarily broken.
• Check the build bots at https://lab.llvm.org/buildbot/.
• Your environment is not properly set up.
• Check that your tools meet the expected minimal requirements. See Installing the right tools.

2. You have a C file, and you are curious about what the LLVM IR looks like without optimization. How can you print this IR using Clang?

You can run the following:

$ clang -S -O0 -emit-llvm myFile.c -o -

See Experimenting with Clang.

3. You want to build LLVM for just the AMDGPU and X86 backends. Which CMake variable should you set and how do you set it?

You want to set the variable...