Chris Lattner Style Guide⁠‍⁠​‌​‌​​‌‌‍​‌​​‌​‌‌‍​​‌‌​​​‌‍​‌​​‌‌​​‍​​​​​​​‌‍‌​​‌‌​‌​‍‌​​​​​​​‍‌‌​​‌‌‌‌‍‌‌​​​‌​​‍‌‌‌‌‌‌​‌‍‌‌​‌​​​​‍​‌​‌‌‌‌‌‍​‌​​‌​‌‌‍​‌‌​‌​​‌‍‌​‌​‌‌‌​‍​​‌​‌​​​‍‌‌‌​‌​‌‌‍​‌​‌‌​​‌‍‌​​‌​​​​‍‌​‌​‌​‌​‍‌‌​​​​​‌‍​​​​‌​‌​‍‌​‌‌‌‌‌​⁠‍⁠

Overview

Chris Lattner created LLVM (the compiler infrastructure that powers most modern compilers), Clang (the C/C++/Objective-C frontend), Swift (Apple's systems language), and MLIR (multi-level intermediate representation). His work fundamentally changed how compilers are built and how languages evolve.

Core Philosophy

"The key insight of LLVM is that compiler infrastructure should be reusable."

"Good IR design is about finding the right level of abstraction."

"Languages should evolve based on real-world usage, not theoretical purity."

Lattner believes in building robust, reusable infrastructure that enables an ecosystem of tools—not one-off solutions.

Design Principles

Modular Infrastructure: Build reusable components, not monolithic systems.

Progressive Lowering: Transform through well-defined IR levels.

Library-First Design: Compilers are libraries, not just executables.

Pragmatic Evolution: Languages improve through real usage feedback.

When Writing Compiler Code

Always

• Design IRs with clear semantics and invariants

• Make passes composable and reusable

• Provide excellent diagnostics and error messages

• Build infrastructure others can extend

• Think about the entire compilation pipeline

• Document design decisions and tradeoffs

Never

• Build closed, monolithic compiler architectures

• Sacrifice usability for implementation convenience

• Ignore error recovery and diagnostics

• Let optimization passes have hidden dependencies

• Couple frontend concerns with backend concerns

• Design IRs without considering transformations

Prefer

• SSA form for optimization IRs

• Explicit type systems over implicit

• Library APIs over command-line tools

• Incremental compilation where possible

• Clear phase ordering over ad-hoc passes

• Compositional design over special cases

Code Patterns

LLVM IR Philosophy

; LLVM IR: explicit, typed, SSA form ; Every value has exactly one definition ; Control flow is explicit

define i32 @factorial(i32 %n) { entry: %cmp = icmp sle i32 %n, 1 br i1 %cmp, label %base, label %recurse

base: ret i32 1

recurse: %n_minus_1 = sub i32 %n, 1 %fact_sub = call i32 @factorial(i32 %n_minus_1) %result = mul i32 %n, %fact_sub ret i32 %result }

; Key properties: ; - SSA: each %variable defined exactly once ; - Typed: every operation has explicit types ; - Explicit control flow: br, ret, etc. ; - No hidden state or side effects in IR

Pass Infrastructure Design

// LLVM-style pass infrastructure // Passes are modular, composable, declarative

class MyOptimizationPass : public PassInfoMixin<MyOptimizationPass> { public: PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { // Get required analyses auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);

    bool Changed = false;
    
    for (auto &BB : F) {
        Changed |= optimizeBlock(BB, DT, LI);
    }
    
    if (!Changed)
        return PreservedAnalyses::all();
    
    // Declare what we preserved
    PreservedAnalyses PA;
    PA.preserve<DominatorTreeAnalysis>();
    return PA;
}

private: bool optimizeBlock(BasicBlock &BB, DominatorTree &DT, LoopInfo &LI); };

// Register the pass extern "C" LLVM_ATTRIBUTE_WEAK ::llvm::PassPluginLibraryInfo llvmGetPassPluginInfo() { return { LLVM_PLUGIN_API_VERSION, "MyPass", "v0.1", [](PassBuilder &PB) { PB.registerPipelineParsingCallback( [](StringRef Name, FunctionPassManager &FPM, ArrayRef<PassBuilder::PipelineElement>) { if (Name == "my-opt") { FPM.addPass(MyOptimizationPass()); return true; } return false; }); } }; }

Diagnostic Excellence

// Swift/Clang-style diagnostics // Errors should be helpful, not cryptic

class DiagnosticEngine { public: // Structured diagnostics with fix-its void diagnose(SourceLoc Loc, Diagnostic Diag) { emitDiagnostic(Loc, Diag.getKind(), Diag.getMessage());

    // Show the source location
    emitSourceSnippet(Loc);
    
    // Provide fix-its when possible
    for (auto &FixIt : Diag.getFixIts()) {
        emitFixIt(FixIt);
    }
    
    // Add educational notes
    for (auto &Note : Diag.getNotes()) {
        emitNote(Note);
    }
}

};

// Example diagnostic output: // error: cannot convert value of type 'String' to expected type 'Int' // let x: Int = "hello" // ^~~~~~~ // fix-it: did you mean to use Int(_:)? // let x: Int = Int("hello") ?? 0

Progressive Lowering (MLIR Style)

// MLIR: Multi-Level IR for progressive lowering // High-level ops → Mid-level ops → Low-level ops → LLVM IR

// High-level: domain-specific operations %result = linalg.matmul ins(%A, %B : tensor<4x8xf32>, tensor<8x16xf32>) outs(%C : tensor<4x16xf32>) -> tensor<4x16xf32>

// After tiling transformation: %tiled = scf.for %i = %c0 to %c4 step %c2 { %slice_a = tensor.extract_slice %A[%i, 0][2, 8][1, 1] %slice_c = tensor.extract_slice %C[%i, 0][2, 16][1, 1] %computed = linalg.matmul ins(%slice_a, %B) outs(%slice_c) scf.yield %computed }

// After vectorization: %vec = vector.contract {indexing_maps = [...], kind = #vector.kind<add>} %vec_a, %vec_b, %vec_c : vector<2x8xf32>, vector<8x16xf32> into vector<2x16xf32>

// Finally: LLVM IR // Each level has clear semantics and transformations

Type System Design

// Swift-style type system: expressive, safe, pragmatic

// Protocol-oriented design protocol Numeric { static func +(lhs: Self, rhs: Self) -> Self static func *(lhs: Self, rhs: Self) -> Self }

// Associated types for flexibility protocol Collection { associatedtype Element associatedtype Index: Comparable

var startIndex: Index { get }
var endIndex: Index { get }
subscript(position: Index) -> Element { get }

}

// Generics with constraints func sum<T: Numeric>(_ values: [T]) -> T { values.reduce(.zero, +) }

// Optionals as explicit nullability func find<T: Equatable>(_ value: T, in array: [T]) -> Int? { for (index, element) in array.enumerated() { if element == value { return index } } return nil // Explicit absence }

// Result types for error handling enum Result<Success, Failure: Error> { case success(Success) case failure(Failure) }

Compiler as Library

// Clang as a library, not just a tool // Enable building custom tools on compiler infrastructure

#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Tooling/Tooling.h"

// Custom AST visitor class FunctionFinder : public RecursiveASTVisitor<FunctionFinder> { public: bool VisitFunctionDecl(FunctionDecl *FD) { if (FD->hasBody()) { llvm::outs() << "Found function: " << FD->getName() << "\n"; analyzeComplexity(FD); } return true; }

private: void analyzeComplexity(FunctionDecl *FD); };

// Build custom tools using Clang's libraries int main(int argc, const char **argv) { auto ExpectedParser = CommonOptionsParser::create(argc, argv, MyCategory); if (!ExpectedParser) { llvm::errs() << ExpectedParser.takeError(); return 1; }

ClangTool Tool(ExpectedParser->getCompilations(),
               ExpectedParser->getSourcePathList());

return Tool.run(newFrontendActionFactory<MyFrontendAction>().get());

}

Memory Ownership in Swift

// Swift's ownership model: safe by default, explicit when needed

// Default: automatic reference counting class Node { var value: Int var children: [Node]

init(value: Int) {
    self.value = value
    self.children = []
}

}

// Explicit ownership for performance-critical code func processBuffer(_ buffer: borrowing [UInt8]) -> Int { // borrowing: read-only access, no copy buffer.reduce(0, +) }

func consumeBuffer(_ buffer: consuming [UInt8]) -> [UInt8] { // consuming: takes ownership, no copy var result = buffer result.append(0) return result }

// Copy-on-write for value semantics with efficiency struct LargeData { private var storage: Storage

mutating func modify() {
    // Copy only if shared
    if !isKnownUniquelyReferenced(&storage) {
        storage = storage.copy()
    }
    storage.data[0] = 42
}

}

IR Design Principles

Intermediate Representation Design ══════════════════════════════════════════════════════════════

Level Abstraction Purpose ──────────────────────────────────────────────────────────── Source Syntax trees Parsing, early semantic AST/HIR Typed trees Type checking, inference MIR/SIL Typed CFG Optimization, ownership LLVM IR Typed SSA Machine-independent opt Machine IR Target ops Instruction selection Assembly Text Final output

Key principles: • Each level has ONE clear purpose • Lowering is progressive and well-defined • Analyses valid at one level may not be at another • Transformations declare their requirements

Mental Model

Lattner approaches compiler design by asking:

• What's the right abstraction level? Different problems need different IRs

• Is this reusable? Build infrastructure, not one-off tools

• What's the user experience? Diagnostics, error recovery, tooling

• How will this evolve? Design for change and extension

• Can others build on this? Library-first, composable design

Signature Lattner Moves

• LLVM's pass manager: Modular, composable optimization passes

• Clang's diagnostics: The gold standard for helpful error messages

• Swift's optionals: Explicit nullability without verbosity

• MLIR's dialect system: Multi-level IR with extensible operations

• Library-first design: Compilers as reusable infrastructure

• Progressive lowering: Clear transformation stages

• SwiftUI's result builders: Compiler magic that feels natural