LLVM and Clang in 30 Study Days

Roadmap

All 30 days in learning order. Open any day at any time; completion counts only required checks.

Days 1–7

Compiler foundations

Compiler concepts and a small expression frontend written in C++.

Days 8–12

LLVM IR

Basic LLVM IR and an end-to-end compiled toy program.

Days 13–21

Clang frontend

Clang source navigation, C++ diagnostics and regression tests.

Days 22–30

First contribution

Select, investigate, test and submit a small contribution.

Compiler foundations Days 1–7

Days 3–10 share one toy project: an integer expression language with let bindings, +, -, *, parentheses and source locations. It tokenizes, parses, resolves names, evaluates and emits LLVM IR. Values are unsigned 32-bit integers with wraparound. Source-language branches and loops stay optional; day 11 teaches their IR separately.

  1. Understand what a compiler does
    150 min
  2. Prepare a reproducible learning environment
    150 min
  3. Turn characters into tokens
    150 min
  4. Represent syntax with trees
    150 min
  5. Write a recursive descent parser
    150 min
  6. Check meaning before generating code
    150 min
  7. Consolidate the compiler foundations
    Checkpoint A150 min

LLVM IR Days 8–12

  1. Read LLVM intermediate representation
    150 min
  2. Generate IR from your AST
    150 min
  3. Compile and run a tiny program
    150 min
  4. Understand control flow and optimization
    150 min
  5. Connect IR learning to the C++ compiler
    Checkpoint B150 min

Clang frontend Days 13–21

  1. Navigate the Clang source tree
    150 min
  2. Inspect C++ AST nodes and types
    150 min
  3. Learn the LLVM regression test workflow
    150 min
  4. Write focused diagnostic tests
    150 min
  5. Use FileCheck and trace a diagnostic
    150 min
  6. Study one C++ semantic rule
    150 min
  7. Debug the frontend
    150 min
  8. Read the contribution rules and a small merged change
    150 min
  9. Check readiness for a first contribution
    Checkpoint C150 min

First contribution Days 22–30

  1. Choose a small useful contribution
    150 min
  2. Reduce the reproducer and establish expected behavior
    150 min
  3. Locate the smallest responsible code path
    150 min
  4. Capture the regression first
    150 min
  5. Implement the smallest correct change
    150 min
  6. Test the effect beyond the reproducer
    150 min
  7. Prepare and submit a reviewable contribution
    150 min
  8. Respond to review or strengthen the evidence
    150 min
  9. Publish a learning retrospective and choose the next month
    Checkpoint D150 min

Milestones

CheckpointEvidence to retain
A: day 7Lexer, parser, semantic checks and evaluator tests
B: day 12Verified IR and an executable generated from the toy frontend
C: day 21Current-main Clang build, diagnostic trace and a lit test
D: day 30Contribution or investigation, validation record and follow-up plan

Keep contribution status separate from learning completion. A submitted patch is not a merged patch, and an unmerged but carefully investigated contribution can still demonstrate real progress.

After day 30

Spend the next two weeks responding to review and deepening one area of Clang Sema, AST or diagnostics. Prefer two small follow-up investigations over starting a second large compiler project. Keep compiling examples and predicting behavior before looking at output.

Then select reading by need: chapter 5 for C++ object representation and ABI context; chapter 6 for exceptions and debug metadata; chapter 7 for optimization work; chapter 8 for more TableGen; later backend chapters only if target work becomes your goal. LibTooling and AST matchers (R19) can become a separate small tooling project, but clang-tidy or tooling experience does not automatically replace frontend contribution practice.

A useful end-of-month record includes a working tiny compiler, three Clang AST examples, one diagnostic trace, a regression test you understand, a contribution or investigation link, and a truthful status note. Measure progress by what you can explain and reproduce.