1. What's new in LLDB on Windows - Charles Zablit
2. Compact Unwind Information for ELF - Alexis Engelke
3. Engineering a Hybrid Rust and MLIR Toolchain for AI Agents - Miguel Cárdenas
4. STRTAB Hash & Slash: Reducing STRTAB size by hashing its entries - Vy Nguyen
5. Reproducible Large-Workload Recipes for BOLT with Nixpkgs - Peter Waller
6. Using MLIR Linalg Category Ops for Smarter Compilation - Javed Absar
7. Highlighting function names in LLDB backtraces - Michael Buch
8. Improving DemandedBits Analysis for Shift Operations in LLVM - Panagiotis Karouzakis
9. Extending Lifetime Safety: Verification of [[clang:noescape]] annotation - Abhinav Pradeep
10. Coverage directed codebase reduction for the procedural generation of LIT tests - Freya Fewtrell

What’s new in LLDB on Windows
Speaker(s): Charles Zablit
We've been improving LLDB and LLDB-DAP on Windows, adding key features like STDIO support, Unicode handling, better Python integration, and switching to an open-source PDB implementation to bring Windows debugging up to par with other platforms.

Engineering a Hybrid Rust and MLIR Toolchain for AI Agents
Speaker(s): Miguel Cárdenas, Isaac David Bermudez Lara
Developing a compiler for Agentic AI workloads presents a unique challenge because the runtime demands the safety and ergonomics of Rust while the optimization pipeline requires the mature infrastructure of MLIR. This talk presents the architecture of a toolchain designed to leverage the strengths of both ecosystems. We discuss how we structured a hybrid build system where Rust drives the compilation process and defines runtime semantics, while C++ manages the core MLIR dialect and transformations. The session covers the practical engineering required to bridge these worlds, from orchestrating CMake and Cargo to managing the boundary between Rust runtime metadata and MLIR operation definitions. We share lessons learned about the complexity of linking, the tradeoffs of code generation, and the reality of maintaining a custom dialect across the language barrier.

Compact Unwind Information for ELF
Speaker(s): Alexis Engelke
ELF unwind information is encoded as DWARF bytecode for most architectures, which results in a large size overhead and is complex to interpret, precluding its use in e.g. tracing profilers. This talk will present a compact format for asynchronous unwind info that can accurately represent almost all functions generated by LLVM -O3 for x86-64 with a substantially smaller size. We will also discuss portability to other architectures, differences from other unwinding/tracing formats, and interoperability with other toolchains.

STRTAB Hash & Slash: Reducing STRTAB size by hashing its entries
Speaker(s): Vy Nguyen
The string table(STRTAB) accounts for a significant portion of object file overhead at Google, with long mangled names, such as those from Protos, frequently reaching 35% of the total file size. Optimizing this space is the key to faster builds and leaner binaries. In this talk, we propose an approach to reduce the string table through hashing its entries, demonstrating a reduction in overall binary size

Reproducible Large-Workload Recipes for BOLT with Nixpkgs
Speaker(s): Peter Waller
BOLT needs large, realistic binaries for integration testing, but distributing binaries directly creates governance and supply-chain problems and makes it hard to reproduce the exact toolchains and build flags that shape BOLT behaviour. We show our pinned, auditable Nixpkgs build recipes (including emit-relocs Chromium) and discuss how this enables teams to reproduce identical workloads, generate provenance/SBOMs, and compare results consistently across machines and CI.

Using MLIR Linalg Category Ops for Smarter Compilation
Speaker(s): Javed Absar
Linalg dialect of MLIR recently added `category ops` as an intermediate abstraction between the two existing forms: named ops and generic ops. A mechanism (-linalg-morph-ops=_-to-_) to move between these forms was also introduced. When something new appears, adoption is often slow due to existing workflows and lack of awareness.
This talk will:
(a) Motivate the reason for this additional representation
(b) Explain what now exists and how to benefit from it
(c) Show how category ops can help certain compilation flows.

Highlighting function names in LLDB backtraces
Speaker(s): Michael Buch
C++ backtraces tend to be hard to read because function names are hidden amongst many layers of namespaces, template arguments and function parameters. In the debugger, a user often wants to simply get a quick overview of the function callstack. But traditionally this has been difficult to decipher. To improve readability, LLDB recently gained the ability to selectively hide or format various parts of C++ function names. This talk describes how we implemented this by extending the LLVM demangler and how other language plugins can take advantage of this infrastructure.

Improving DemandedBits Analysis for Shift Operations in LLVM
Speaker(s): Panagiotis Karouzakis
The DemandedBits analysis is utilized in some optimization passes, such as vectorization and dead code elimination; a similar analysis is employed in InstCombine. We improve DemandedBits reasoning for all basic shift operations, enabling more precise bit-level information propagation. Our improvements reduced code size, enabled additional loop-invariant code motion, and lead to more instruction-level simplifications.

Extending Lifetime Safety: Verification of [[clang:noescape]] annotation
Speaker(s): Abhinav Pradeep
Clang features an intra-procedural, flow-sensitive lifetime analysis designed to catch temporal safety errors like use-after-free, use-after-scope, and use-after-return. The talk presents work on leveraging this analysis to verify [[clang::noescape]] annotations. This effort focuses on applying the "Origins and Loans" model to enforce memory safety guarantees that were previously unverified by the compiler.

Coverage directed codebase reduction for the procedural generation of LIT tests
Speaker(s): Freya Fewtrell
The LIT test suite, whilst extensive, still leaves many parts of the LLVM codebase uncovered. Compiling large real-world C++ code from Sony Interactive Entertainment’s downstream integration test suite routinely exercises code paths that the upstream LIT suite never reaches. To shift this testing leftwards, we have built a tool that uses coverage-directed reduction to automatically turn such high-coverage sources into minimal, self-contained LLVM IR fragments suitable for inclusion as upstream LIT tests. This lightning talk describes how the tool works, the challenges encountered when trying to automate test reduction at scale, and whether increasing coverage alone is sufficient motivation for new upstream LIT tests.