LLVM

https://llvm.org/docs/
Admin
LLVM is a compiler infrastructure project that supports a wide range of applications from...
Tokens:1,479,646
Snippets:11,111
Trust Score:9.5
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example: build stand-alone clang

Source: https://llvm.org/docs/GettingStarted.html

Complete shell script that builds and installs LLVM, then configures and builds clang as a stand-alone sub-project. Uses LLVM_EXTERNAL_LIT pointing to the LLVM build's utils/lit and LLVM_ROOT to the install prefix.

```shell
#!/bin/sh

build_llvm=`pwd`/build-llvm
build_clang=`pwd`/build-clang
installprefix=`pwd`/install
llvm=`pwd`/llvm-project
mkdir -p $build_llvm
mkdir -p $installprefix

cmake -G Ninja -S $llvm/llvm -B $build_llvm \
      -DLLVM_INSTALL_UTILS=ON \
      -DCMAKE_INSTALL_PREFIX=$installprefix \
      -DCMAKE_BUILD_TYPE=Release

ninja -C $build_llvm install

cmake -G Ninja -S $llvm/clang -B $build_clang \
      -DLLVM_EXTERNAL_LIT=$build_llvm/utils/lit \
      -DLLVM_ROOT=$installprefix

ninja -C $build_clang

```

--------------------------------

### Error and Diagnostic Messages: Good and avoid examples

Source: https://llvm.org/docs/AMDGPU/DeveloperGuideline.html

Examples of error message formatting: lowercase start and no trailing period.

```cpp
// Good
report_fatal_error("malformed block");

// Avoid
report_fatal_error("Malformed block");

```

--------------------------------

### Build and install LLVM distribution with DistributionExample.cmake

Source: https://llvm.org/docs/BuildingADistribution.html

Commands to configure and build a distribution using the DistributionExample.cmake cache file, then install it with the stage2-install-distribution target.

```shell
$ cmake -G Ninja -C <path to clang>/cmake/caches/DistributionExample.cmake <path to LLVM source>
$ ninja stage2-distribution
$ ninja stage2-install-distribution

```

--------------------------------

### Example output for a single-document mapping

Source: https://llvm.org/docs/YamlIO.html

Shows the YAML output produced by the dumpMyMapDoc example. It includes the document start marker '---' and end marker '...'.

```yaml
---
name:      Tom
hat-size:  7
...

```

--------------------------------

### Build and run commands for the Kaleidoscope JIT example

Source: https://llvm.org/docs/tutorial/BuildingAJIT2.html

Compile the toy.cpp example with clang++ linking LLVM core, orcjit, and native libraries, then run the resulting binary. Uses llvm-config to supply the required flags and libraries.

```shell
# Compile
clang++ -g toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core orcjit native` -O3 -o toy
# Run
./toy

```

--------------------------------

### Create venv and install buildbot dependencies

Source: https://llvm.org/docs/HowToAddABuilder.html

Creates a Python virtual environment and installs the buildbot packages and urllib3. Run from any directory before starting local testing.

```bash
python -m venv bbenv
source bbenv/bin/activate
pip install buildbot{,-console-view,-grid-view,-waterfall-view,-worker,-www}==3.11.7 urllib3

```

--------------------------------

### Example 4: BUILDID and FILE prefixes

Source: https://llvm.org/docs/CommandGuide/llvm-symbolizer.html

Example 4: uses FILE: and DATA BUILDID: prefixes. Output for data address shows symbol and value/size.

```bash
$ llvm-symbolizer "FILE:test.elf 0x400490" "DATA BUILDID:123456789abcdef 0x601028"
baz()
/tmp/test.cpp:11:0

bar
6295592 4

$ cat addr3.txt
FILE:test.elf 0x400490
DATA BUILDID:123456789abcdef 0x601028

$ llvm-symbolizer < addr3.txt
baz()
/tmp/test.cpp:11:0

bar
6295592 4

```

--------------------------------

### C example of memory object representation in AliasAnalysis

Source: https://llvm.org/docs/AliasAnalysis.html

Illustrates how memory objects are represented as a starting address and static size in alias analysis queries. The example shows a loop writing to C[0] from A[i] across iterations. Use it to understand why the starting address plus size representation matters for correct alias analyses.

```c
int i;
char C[2];
char A[10];
/* ... */
for (i = 0; i != 10; ++i) {
  C[0] = A[i];          /* ... */
}
```

--------------------------------

### Compatibility check example with tags foo:bar and foo:baz

Source: https://llvm.org/docs/MemoryModelRelaxationAnnotations.html

Shows two stores and a release store with tags. A is compatible with X so A happens-before X, while B is not compatible with X so it is not happens-before X.

```text
A: store %ptr1                 # foo:bar
B: store %ptr2                 # foo:baz
X: store atomic release %ptr3  # foo:bar

```

--------------------------------

### Compile command for CUDA driver example with clang++

Source: https://llvm.org/docs/NVPTXUsage.html

Compile the example with clang++, linking against the CUDA driver and specifying the include path. The path to libcuda.so is not needed because it is installed in a system location.

```bash
# clang++ sample.cpp -o sample -O2 -g -I/usr/local/cuda-5.5/include -lcuda

```

--------------------------------

### Build and run HelloWorld pass with opt

Source: https://llvm.org/docs/WritingAnLLVMNewPMPass.html

Builds opt, creates a sample IR file, and runs the pass with -passes=helloworld. The output shows the function names foo and bar printed to stderr.

```shell
$ ninja -C build/ opt
# or whatever build system/build directory you are using

$ cat /tmp/a.ll
define i32 @foo() {
  %a = add i32 2, 3
  ret i32 %a
}

define void @bar() {
  ret void
}

$ build/bin/opt -disable-output /tmp/a.ll -passes=helloworld
foo
bar

```

--------------------------------

### Install LNT client tools in a virtual environment

Source: https://llvm.org/docs/lnt/intro.html

Creates a virtual environment, activates it, and installs the latest stable release of LNT from PyPI. Recommended for installing the client-side tools.

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install llvm-lnt

```

--------------------------------

### YAML sequence example

Source: https://llvm.org/docs/YamlIO.html

Shows a basic YAML sequence where each item starts with a leading dash (-).

```yaml
# a sequence
- x86
- x86_64
- PowerPC

```

--------------------------------

### Example 1: addresses and object on command-line

Source: https://llvm.org/docs/CommandGuide/llvm-symbolizer.html

Example 1: passes addresses and object on the command line. Output shows symbol names and source locations.

```bash
$ llvm-symbolizer --obj=test.elf 0x4004d0 0x400490
foz
/tmp/test.h:1:0

baz()
/tmp/test.cpp:11:0

```

--------------------------------

### llvm-jitlink with multiple objects and -args

Source: https://llvm.org/docs/JITLink.html

Demonstrates linking multiple object files and passing arguments to the JIT'd main function using the -args option. The example includes two source files, compilation commands, and the expected output.

```text
% cat print-args.c
#include <stdio.h>

void print_args(int argc, char *argv[]) {
  for (int i = 0; i != argc; ++i)
    printf("arg %i is \"%s\"\n", i, argv[i]);
}

% cat print-args-main.c
void print_args(int argc, char *argv[]);

int main(int argc, char *argv[]) {
  print_args(argc, argv);
  return 0;
}

% clang -c -o print-args.o print-args.c
% clang -c -o print-args-main.o print-args-main.c
% llvm-jitlink print-args.o print-args-main.o -args a b c
arg 0 is "a"
arg 1 is "b"
arg 2 is "c"

```

--------------------------------

### Codegen: VarExprAST::codegen - start

Source: https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/LangImpl07.html

Begins code generation for var/in by saving old bindings and getting the current function.

```cpp
Value *VarExprAST::codegen() {
  std::vector<AllocaInst *> OldBindings;

  Function *TheFunction = Builder->GetInsertBlock()->getParent();

  // Register all variables and emit their initializer.
  for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
    const std::string &VarName = VarNames[i].first;
    ExprAST *Init = VarNames[i].second.get();

```

--------------------------------

### Kaleidoscope JIT full example (toy.cpp)

Source: https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.html

Complete Kaleidoscope language frontend implementation using LLVM's ORC JIT and optimizer. Includes all necessary LLVM headers and the KaleidoscopeJIT.h include.

```cpp
#include "../include/KaleidoscopeJIT.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Passes/StandardInstrumentations.h"
#include "llvm/Support/TargetSelect.h"
#include 
```

--------------------------------

### G_EXTRACT: Extract sub-register from larger register

Source: https://llvm.org/docs/GlobalISel/GenericOpcode.html

Extracts a register of specified size starting from a given bit index. The example extracts a 32-bit value from a 64-bit register starting at bit 32. This will likely be mapped to sub-register COPYs after register bank selection.

```llvm-mir
%3:_(s32) = G_EXTRACT %2:_(s64), 32

```

--------------------------------

### llvm.coro.promise usage example

Source: https://llvm.org/docs/Coroutines.html

Example showing how to use llvm.coro.promise to access a coroutine promise. The function f creates a coroutine with an i32 promise and returns its handle; main starts the coroutine, obtains the promise pointer, loads the stored value, prints it, and destroys the coroutine.

```llvm
define ptr @f(i32 %n) {
entry:
  %promise = alloca i32
  ; the second argument to coro.id points to the coroutine promise.
  %id = call token @llvm.coro.id(i32 0, ptr %promise, ptr null, ptr null)
  ...
  %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %alloc)
  ...
  store i32 42, ptr %promise ; store something into the promise
  ...
  ret ptr %hdl
}

define i32 @main() {
entry:
  %hdl = call ptr @f(i32 4) ; starts the coroutine and returns its handle
  %promise.addr = call ptr @llvm.coro.promise(ptr %hdl, i32 4, i1 false)
  %val = load i32, ptr %promise.addr ; load a value from the promise
  call void @print(i32 %val)
  call void @llvm.coro.destroy(ptr %hdl)
  ret i32 0
}
```

--------------------------------

### Help output with overview text

Source: https://llvm.org/docs/CommandLine.html

Example output of the -help command after adding an overview text. Shows the OVERVIEW section followed by USAGE and OPTIONS sections.

```text
**OVERVIEW: CommandLine compiler example

  This program blah blah blah...**

USAGE: compiler [options] <input file>

OPTIONS:
  ...
  -help             - display available options (-help-hidden for more)
  -o <filename>     - Specify output filename

```

--------------------------------

### Check clang version in container

Source: https://llvm.org/docs/Docker.html

Example output of running clang -v inside the container, showing the installed clang version and target information.

```bash
root@80f351b51825:/# clang -v
clang version 19.1.7 (trunk 524462)
Target: x86_64-unknown-linux-gnu
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /bin

```

--------------------------------

### Example -help output for positional options

Source: https://llvm.org/docs/CommandLine.html

Example -help output for a grep-like tool using the two positional options declared above. Shows the usage line and the options list.

```text
USAGE: spiffygrep [options] <regular expression> <input file>

OPTIONS:
  -help - display available options (-help-hidden for more)

```

--------------------------------

### Good error message example

Source: https://llvm.org/docs/CodingStandards.html

A good error message that provides useful context and follows the style guidelines: lowercase start, no period at the end.

```text
error: file.o: section header 3 is corrupt. Size is 10 when it should be 20

```
Tokens:
Raw