Llvm

LLVM IR and Tooling

Purpose

Guide agents through the LLVM IR pipeline: generating IR, running optimisation passes with opt, lowering to assembly with llc, and inspecting IR for debugging or performance work.

Triggers

• "Show me the LLVM IR for this function"
• "How do I run an LLVM optimisation pass?"
• "What does this LLVM IR instruction mean?"
• "How do I write a custom LLVM pass?"
• "Why isn't auto-vectorisation happening in LLVM?"

Workflow

1. Generate LLVM IR

# Emit textual IR (.ll)
clang -O0 -emit-llvm -S src.c -o src.ll

# Emit bitcode (.bc)
clang -O2 -emit-llvm -c src.c -o src.bc

# Disassemble bitcode to text
llvm-dis src.bc -o src.ll

2. Run optimisation passes with opt

# Apply a specific pass
opt -passes='mem2reg,instcombine,simplifycfg' src.ll -S -o out.ll

# Standard optimisation pipelines
opt -passes='default<O2>' src.ll -S -o out.ll
opt -passes='default<O3>' src.ll -S -o out.ll

# List available passes
opt --print-passes 2>&1 | less

# Print IR before and after a pass
opt -passes='instcombine' --print-before=instcombine --print-after=instcombine src.ll -S -o out.ll 2>&1 | less

3. Lower IR to assembly with llc

# Compile IR to object file
llc -filetype=obj src.ll -o src.o

# Compile to assembly
llc -filetype=asm -masm-syntax=intel src.ll -o src.s

# Target a specific CPU
llc -mcpu=skylake -mattr=+avx2 src.ll -o src.s

# Show available targets
llc --version

4. Inspect IR

Key IR constructs to understand:

5. Key passes

6. Debugging missed optimisations

# Why was a loop not vectorised?
clang -O2 -Rpass-missed=loop-vectorize -Rpass-analysis=loop-vectorize src.c

# Dump pass pipeline
clang -O2 -mllvm -debug-pass=Structure src.c -o /dev/null 2>&1 | less

# Print IR after each pass (very verbose)
opt -passes='default<O2>' -print-after-all src.ll -S 2>&1 | less

7. Useful llvm tools

For binutils equivalents, see skills/binaries/binutils.

Related skills

• Use skills/compilers/clang for source-level Clang flags
• Use skills/binaries/linkers-lto for LTO at link time
• Use skills/profilers/linux-perf combined with llvm-mca for micro-architectural analysis

LLVM IR Reference

Source: <https://llvm.org/docs/LangRef.html>

Table of Contents

1. Types 2. Instructions 3. Attributes and metadata 4. Opt pass names

---

Types

---

Instructions

Memory

%ptr = alloca i32, align 4           ; stack allocation
%val = load i32, ptr %ptr, align 4   ; load
store i32 42, ptr %ptr, align 4      ; store
%p2 = getelementptr i32, ptr %ptr, i64 1  ; pointer arithmetic

Arithmetic

%sum  = add  i32 %a, %b
%diff = sub  i32 %a, %b
%prod = mul  i32 %a, %b
%quot = sdiv i32 %a, %b   ; signed divide
%quot = udiv i32 %a, %b   ; unsigned divide
%rem  = srem i32 %a, %b   ; signed remainder
%shl  = shl  i32 %a, 3    ; shift left
%lsr  = lshr i32 %a, 3    ; logical shift right
%asr  = ashr i32 %a, 3    ; arithmetic shift right
%and  = and  i32 %a, %b
%or   = or   i32 %a, %b
%xor  = xor  i32 %a, %b

Comparison

%c = icmp eq  i32 %a, %b   ; integer compare: eq ne slt sle sgt sge ult ule ugt uge
%c = fcmp oeq float %a, %b  ; float compare: oeq one olt ole ogt oge ord uno

Control flow

br label %next                        ; unconditional branch
br i1 %cond, label %true, label %false  ; conditional branch
ret i32 %val
ret void
%ret = call i32 @foo(i32 %a, i32 %b)
switch i32 %val, label %default [ i32 0, label %case0
                                   i32 1, label %case1 ]

PHI nodes (SSA merging)

%result = phi i32 [ %val_from_block_a, %block_a ],
                   [ %val_from_block_b, %block_b ]

Type conversion

%i = trunc i64 %x to i32        ; truncate
%x = zext i32 %i to i64         ; zero-extend
%x = sext i32 %i to i64         ; sign-extend
%p = inttoptr i64 %addr to ptr   ; integer to pointer
%n = ptrtoint ptr %p to i64      ; pointer to integer
%f = sitofp i32 %i to float      ; signed int to float
%i = fptosi float %f to i32      ; float to signed int
%d = fpext float %f to double    ; float extend
%f = fptrunc double %d to float  ; float truncate

---

Attributes and metadata

; Function attributes
define i32 @foo(i32 %x) noinline nounwind readonly {

; Parameter attributes
define void @bar(i32 noundef %x, ptr nocapture nonnull %p) {

; Inline hint
define i32 @hot() alwaysinline {

; Alignment
%val = load i32, ptr %ptr, align 16

Common function attributes:

• noinline — never inline
• alwaysinline — always inline
• noreturn — never returns (like abort)
• nounwind — never throws an exception
• readonly — only reads memory
• readnone — does not access memory

---

Opt pass names (LLVM 14+ new pass manager)

Pipeline example:

opt -passes='mem2reg,instcombine,simplifycfg,gvn,licm' input.ll -S -o out.ll