1. Shader Debugging - Utilizing LLVM for enabling live debugging of a shader program on an NVIDIA GPU — Laxman Sole, Matt Davis

2. Profiling the AI Compiler Stack: Attributing GPU assembly to TileIR and MLIR — Alex Yermolovich

3. Debug Info at Scale: Making Split DWARF Work for Very Large C++ Binaries — Ke Liu

4. The state of WebAssembly debugging in LLDB — Jonas Devlieghere

5. The State of ClangIR: An update on the Upstreaming and Implementation Effort — Erich Keane, Andy Kaylor

6. ClangIR in 2026: Benchmarks, Self-Hosting, and Compile Time — Bruno Cardoso Lopes

7. An SROA bug that inflates compile time across the whole pipeline — when the hottest pass is not the culprit — Jiatong Zhang

8. Null safety in C/C++: Adding null-pointer dereference warnings to Clang — Chad Smith

9. The New Pass Manager for CodeGen: An Update — Aiden Grossman

10. Calling Windows DLLs from JIT-Linked COFF — No Import Library Required — Milica Kovacevic

1. Shader Debugging - Utilizing LLVM for enabling live debugging of a shader program on an NVIDIA GPU — Laxman Sole, Matt Davis
Oh no! The cow is green! This talk presents a high-level overview of how shader applications can be made debuggable via an LLVM-driven compilation pipeline. While shader programs and traditional GPU compute programs are similar, this talk will cast light(!) on the differences in how such graphics programs execute, share data, and are debugged. 

2. Profiling the AI Compiler Stack: Attributing GPU assembly to TileIR and MLIR — Alex Yermolovich
As AI kernels lower through DSL → TileIR/MLIR → LLVM IR → GPU assembly, profilers can attribute hot code to the high-level source but not the intermediate IRs where bottlenecks often live. This talk presents a small, general LLVM debug-info extension that maps a single machine instruction back to multiple levels of the compilation stack.

3. Debug Info at Scale: Making Split DWARF Work for Very Large C++ Binaries — Ke Liu
Split DWARF moves most debug information out of the main binary, but very large C++ applications can still push the remaining skeleton CUs, DWO rewriting, DWP packaging, and DWARF32 section layout close to their limits. This talk follows a sequence of LLVM fixes motivated by that pressure: avoiding skeleton-CU template-parameter data that symbolizers usually do not need, preserving DWP string-table sharing when BOLT rewrites DWO files, making llvm-dwp overflow behavior explicit, and preparing lld for mixed DWARF32/DWARF64 debug sections. The focus is on the engineering tradeoffs behind these fixes, and on how large debug-info pipelines can be scaled incrementally instead of treating DWARF64 as a single global switch.

4. The state of WebAssembly debugging in LLDB — Jonas Devlieghere
WebAssembly has been a first-class LLVM target for years, and Swift made it official in Swift 6.2, but debugging that code with LLDB is very recent and has taken a substantial, sustained engineering effort. Earlier this year at the LLVM Dev Room at FOSDEM, I argued for extending the GDB Remote Serial Protocol to debug native languages compiled to Wasm and presented the LLDB work needed to make it real. This talk covers what comes next: moving that capability from working to reliable, toward first-class debugging support. The GDB remote approach championed by LLDB is now converging into an industry standard. Alongside existing support in WAMR and V8, WebKit has adopted it, and Wasmtime's accepted debugging RFC reverses an earlier plan to endorse this exact approach. To ensure correctness, we set out to get the LLDB test suite passing against Wasm, compiling our test programs and running them under a Wasm runtime. That surfaced a long tail of concrete bugs we have been fixing for the 23.x release, and once the suite is green it will run in CI to keep support from regressing.

5. The State of ClangIR: An update on the Upstreaming and Implementation Effort — Erich Keane, Andy Kaylor
Clang IR, the MLIR Dialect for C based languages, has been under active development for nearly 4 years. More recently, it has made significant strides to work as the code generation path for significant workloads. This talk is an update on the progress upstreaming from the incubation project, as well as implementation, plus a quick tutorial on how to enable it for your own projects!

6. ClangIR in 2026: Benchmarks, Self-Hosting, and Compile Time — Bruno Cardoso Lopes
ClangIR (CIR) is an MLIR-based IR in Clang that sits between the AST and LLVM IR, reachable today with `-fclangir`. The incubator-to-upstream move is essentially done, and CIR is now advancing independently in upstream — but how much real C and C++ can it actually compile today, and what does it cost? For most of 2026 we have tracked ClangIR against upstream `main` each month across the LLVM test-suite, SPEC CPU 2017, the libc++ conformance suite, the CIR unit tests, and a per-translation-unit self-hosting build of Clang itself. This talk presents where things stand and how the picture has evolved over the year: the benchmark and self-hosting trends (and what "pass" really means), a look at `-fclangir`'s compile-time overhead, and the top blockers standing between CIR and a Clang that can compile itself.

7. An SROA bug that inflates compile time across the whole pipeline — when the hottest pass is not the culprit — Jiatong Zhang
When building our datacenter applications on distributed build clusters, we regularly encountered individual C++ source files generated by tools such as Thrift and Protobuf that took more than 20 minutes each to compile. Profiling pointed at a few hot passes such as JumpThreading and CorrelatedValuePropagation, but speeding them up in place barely helped. The real culprit turned out to be far upstream: a single over-conservative rewrite in SROA produces redundant IR that mem2reg then turns into large dead PHI webs. They are cheap to create and expensive for every later pass that has to reason about them. We will explain why per-pass, local fixes cannot address this class of problem, present two complementary and already-merged fixes — one that stops the IR from being generated at the source and one that makes the core IR operation cheap enough to survive — and describe the automated nightly pipeline we use to catch such compile-time regressions on real workloads and attribute them to a specific pass.

8. Null safety in C/C++: Adding null-pointer dereference warnings to Clang — Chad Smith
C and C++ compilers do not warn on potentially-null pointer dereferences. This talk describes a fork of Clang I made that adds flow-sensitive nullability tracking using Clang's control-flow graph. This talk shows what the analysis catches, what the warnings look like, and how it works. It demonstrates that in-compiler null-safety checking for C/C++ is possible.

9. The New Pass Manager for CodeGen: An Update — Aiden Grossman
The migration to the new pass manager has been in progress for about 15 years. While the migration to the NewPM in the middle end was completed a while ago, the migration is still not complete for the back end. This talk will outline what exactly the benefits of this migration are, the current status, and outline the migration plan to completely drop the legacy pass manager once and for all.

10. Calling Windows DLLs from JIT-Linked COFF — No Import Library Required — Milica Kovacevic
Two new JITLink and ORC additions — an IAT synthesis pass and AutoImportGenerator — make it possible to JIT-link COFF objects that call Windows DLL functions without building or loading any import library.