Using LLVM 20.1.8 Toolset

Red Hat Developer Tools 1

Installing and using LLVM 20.1.8 Toolset

Red Hat Customer Content Services

Abstract

LLVM Toolset is a Red Hat offering for developers on the Red Hat Enterprise Linux (RHEL) operating system. Use this guide for an overview of LLVM Toolset, to learn how to invoke and use different versions of LLVM tools, and to find resources with more in-depth information.

Providing feedback on Red Hat documentation

We appreciate your feedback on our documentation. Let us know how we can improve it.

Submitting feedback through Jira (account required)

  1. Log in to the This content is not included.Jira website.
  2. Click Create in the top navigation bar.
  3. Enter a descriptive title in the Summary field.
  4. Enter your suggestion for improvement in the Description field. Include links to the relevant parts of the documentation.
  5. Click Create at the bottom of the dialogue.

Chapter 1. LLVM Toolset

LLVM Toolset is a Red Hat offering for developers on Red Hat Enterprise Linux (RHEL). It provides the LLVM compiler infrastructure framework, the Clang compiler for the C and C++ languages, the LLDB debugger, and related tools for code analysis.

LLVM Toolset is available as a module for RHEL 8 and as packages for RHEL 9 and 10.

1.1. LLVM Toolset components

LLVM Toolset includes the Clang compiler, LLDB debugger, compiler-rt, LLVM core, libomp, LLD linker, and python-lit, all at version 20.1.8. The table lists each component and its version.

NameVersionDescription

clang

20.1.8

An LLVM compiler front end for C and C++.

lldb

20.1.8

A C and C++ debugger using portions of LLVM.

compiler-rt

20.1.8

Runtime libraries for LLVM and Clang.

llvm

20.1.8

A collection of modular and reusable compiler and toolchain technologies.

libomp

20.1.8

A library for using Open MP API specification for parallel programming.

lld

20.1.8

An LLVM linker.

python-lit

20.1.8

A software testing tool for LLVM- and Clang-based test suites.

Note

The CMake build manager is not part of LLVM Toolset. CMake is available in the system repository. For more information on how to install CMake, see Installing the CMake build manager.

1.2. LLVM Toolset compatibility

LLVM Toolset is available for Red Hat Enterprise Linux on AMD and Intel 64-bit (x86_64), 64-bit ARM (aarch64), IBM Power Systems Little Endian (ppc64le), and 64-bit IBM Z (s390x) architectures.

1.3. Installing LLVM Toolset

Install LLVM Toolset and all dependent packages on Red Hat Enterprise Linux by enabling the llvm-toolset module on RHEL 8 or installing the llvm-toolset package on RHEL 9 and 10. LLVM Toolset provides the Clang compiler, LLDB debugger, and related tools.

Prerequisites

  • All available Red Hat Enterprise Linux updates are installed.

Procedure

  1. Install LLVM Toolset:

    • On RHEL 8, enter: 

      # yum module install llvm-toolset

    • On RHEL 9 and 10, enter: 

      # dnf install llvm-toolset

  2. To also install the LLDB debugger and the python3-lit package, enter: 

    # dnf install lldb python3-lit

1.4. LLVM Toolset documentation

The official LLVM Toolset documentation is available upstream. The llvm-doc package provides a reference to the Content from releases.llvm.org is not included.upstream documentation.

Note

The llvm-doc package provides only a reference to the upstream documentation.

1.5. Installing the CMake build manager

The CMake build manager is a tool that manages the build process of your source code independently from your compiler. CMake generates a native build environment to compile source code, create libraries, generate wrappers, and build executable files. Install it by installing the cmake package on your system.

Prerequisites

Procedure

  • Install CMake: 

    # yum install cmake

Additional resources

1.6. Installing the CMake documentation

You can install documentation for the CMake build manager on your local system. Install the cmake-doc package to add the CMake documentation.

Prerequisites

Procedure

  • Install the cmake-doc package: 

    # dnf install cmake-doc

Verification

  • Open /usr/share/doc/cmake/html/index.html in a browser that is installed on the same host.

1.7. Additional resources

Chapter 2. The Clang compiler

Clang is an LLVM compiler front end for the C-based languages C, C++, Objective C/C++, OpenCL, and Cuda.

LLVM Toolset is distributed with Clang 20.1.8.

Note

To compile a C++ program, use clang++ instead of clang.

2.1. Prerequisites

2.2. Compiling a source file

Use the Clang compiler to compile source files and assembly language source files. Clang creates an executable binary file as a result of compiling. To be able to debug your code, enable debug information by adding the -g flag to your Clang commands.

Note

To compile a C++ program, use clang++ instead of clang.

Procedure

  • Compile your program: 

    $ clang -g -o <binary_file> <source_file>

    Replace <binary_file> with the name of your output file and <source_file> with the name of your source file.

2.3. Running a program

The Clang compiler creates an executable binary file as a result of compiling. Run your program by executing the binary from the directory that contains it.

Prerequisites

Procedure

  • To run your program, enter in the directory containing the executable file: 

    $ ./<binary_file>

    Replace <binary_file> with the name of your executable file.

2.4. Linking object files together

By linking object files together, you can compile only source files that contain changes instead of your entire project. This approach can reduce build time when you update a subset of sources.

When you are working on a project that consists of several source files, use the Clang compiler to compile an object file for each of the source files. As a next step, link those object files together. Clang automatically generates an executable file containing your linked object files. After compilation, link your object files together again.

Note

To compile a C++ program, use clang++ instead of clang.

Procedure

  1. Compile a source file to an object file: 

    $ clang -o <object_file> -c <source_file>

    Replace <object_file> with the name of your object file and <source_file> with the name of your source file.

  2. Link object files together: 

    $ clang -o <output_file> <object_file_0> <object_file_n>

    Replace <output_file> with the name of your output file and <object_file> with the names of the object files you want to link.

    Important

    At the moment, certain library features are statically linked into applications built with LLVM Toolset to support their execution on multiple versions of Red Hat Enterprise Linux. This creates a small security risk. Red Hat will issue a security erratum in case you need to rebuild your applications due to this risk.

    Do not statically link your entire application.

2.5. Additional resources

Chapter 3. The LLDB debugger

The LLDB debugger is a command-line tool for debugging C and C++ programs. Use LLDB to inspect memory within the code being debugged, control the execution state of the code, and detect the execution of particular sections of code.

LLVM Toolset is distributed with LLDB 20.1.8.

3.1. Prerequisites

3.2. Starting a debugging session

Use LLDB to start an interactive debugging session. You can then set breakpoints, step through code, and inspect program state.

Procedure

  1. Run LLDB on a program you want to debug: 

    $ lldb <binary_file>

    Replace <binary_file> with the name of your compiled program.

    You have started your LLDB debugging session in interactive mode. Your command-line terminal now displays the default prompt (lldb).

  2. To quit the debugging session and return to the shell prompt: 

    (lldb) quit

3.3. Executing your program during a debugging session

Use LLDB to run your program during your debugging session. The execution of your program stops when the first breakpoint is reached, when an error occurs, or when the program terminates.

Prerequisites

Procedure

  • Run the program you are debugging: 

    (lldb) run

    Alternatively, run the program you are debugging by using a specific argument: 

    (lldb) run <argument>

    Replace <argument> with the command-line argument you want to use.

3.4. Using breakpoints

Use breakpoints to pause the execution of your program at a set point in your source code. When execution reaches a breakpoint, LLDB stops the program so you can inspect its state.

Prerequisites

Procedure

  • To set a new breakpoint on a specific line, enter: 

    (lldb) breakpoint set --file <source_file_name> --line <line_number>

    Replace <source_file_name> with the name of your source file and <line_number> with the line number you want to set your breakpoint at.

  • To set a breakpoint on a specific function, enter: 

    (lldb) breakpoint set --name <function_name>
    • Replace <function_name> with the name of the function you want to set your breakpoint at.

  • To display a list of currently set breakpoints, enter: 

    (lldb) breakpoint list

  • To delete a breakpoint, run: 

    (lldb) breakpoint clear -f <source_file_name> -l <line_number>
    • Replace <source_file_name> with the name of your source file and <line_number> with line number of the breakpoint you want to delete.

  • To resume the execution of your program after it reached a breakpoint, enter: 

    (lldb) continue

  • To skip a specific number of breakpoints, enter: 

    (lldb) continue -i <breakpoints_to_skip>
    • Replace <breakpoints_to_skip> with the number of breakpoints you want to skip. To skip a loop, set the <breakpoints_to_skip> to match the loop iteration count.

3.5. Stepping through code

You can use LLDB to step through the code of your program to run only one line of code after the line pointer.

Prerequisites

Procedure

  1. Set your line pointer to the line you want to run.

  2. Enter: 

    (lldb) step

3.6. Listing source code

Before you run the program you are debugging, the LLDB debugger automatically displays the first 10 lines of source code. Each time the execution of the program is stopped, LLDB displays the line of source code on which it stopped and its surrounding lines. You can use LLDB to manually trigger the display of source code during your debugging session.

Prerequisites

Procedure

  • To list the first 10 lines of the source code of the program you are debugging, enter: 

    (lldb) list
    (lldb) list <source_file_name>:<line_number>

    Replace <source_file_name> with the name of your source file and <line_number> with the number of the line you want to display.

3.7. Displaying current program data

The LLDB debugger provides data on variables of any complexity, any valid expressions, and function call return values. You can use LLDB to display data relevant to the program state.

Prerequisites

Procedure

  • Display the current value of a certain variable, expression, or return value: 

    (lldb) print <data_name>

    Replace <data_name> with data you want to display.

3.8. Additional resources

Chapter 4. Container images with LLVM Toolset

You can build your own LLVM Toolset container images on top of Red Hat Universal Base Images by using container files. Use these images as a base and add LLVM Toolset packages to create custom development or build environments.

4.1. Creating a custom UBI-based container with LLVM Toolset

LLVM Toolset packages are part of the Red Hat Universal Base Images (UBIs) repositories. To keep the container image size small, install only individual packages instead of the entire LLVM Toolset.

Prerequisites

Procedure

  • To create a container image containing LLVM Toolset, add the following to your container file:

    • For an image based on RHEL 8, enter: 

      FROM registry.access.redhat.com/ubi8/ubi:latest

RUN yum module install -y llvm-toolset

    • For an image based on RHEL 9, enter: 

      FROM registry.access.redhat.com/ubi9/ubi:latest

RUN yum install -y llvm-toolset

    • For an image based on RHEL 10, enter: 

      FROM registry.access.redhat.com/ubi10/ubi:latest

RUN yum install -y llvm-toolset

4.2. Additional resources

Chapter 5. Changes in LLVM Toolset 20.1.8

RHEL is distributed with the LLVM Toolset version 20.1.8. This version includes notable updates to the LLVM compiler and the Clang front end.

Notable changes of the LLVM compiler:

  • LLVM now includes an IRNormalizer pass that aims to output LLVM IR in a canonical form.
  • The llvm.experimental.stepvector intrinsic has been standardized.
  • SPIR-V is now a first-class backend.

Notable updates of the Clang:

  • Support for C++2c has been improved, including implementation of "The Oxford variadic comma" (P3176R1).
  • C++23 support has been enhanced, including removal of restrictions on literal types in constexpr functions.
  • Clang now defaults to emitting distinct type-based alias analysis (TBAA) tags for incompatible pointers.

For more information, see the Content from releases.llvm.org is not included.LLVM release notes and Content from releases.llvm.org is not included.Clang release notes.

LLVM Toolset is a rolling Application Stream, and only the latest version is supported. For more information, see the Red Hat Enterprise Linux Application Streams Life Cycle document.

Legal Notice

Copyright © Red Hat.
Except as otherwise noted below, the text of and illustrations in this documentation are licensed by Red Hat under the Creative Commons Attribution–Share Alike 3.0 Unported license . If you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, the Red Hat logo, JBoss, Hibernate, and RHCE are trademarks or registered trademarks of Red Hat, LLC. or its subsidiaries in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
XFS is a trademark or registered trademark of Hewlett Packard Enterprise Development LP or its subsidiaries in the United States and other countries.
The OpenStack® Word Mark and OpenStack logo are trademarks or registered trademarks of the Linux Foundation, used under license.
All other trademarks are the property of their respective owners.