1. From C++ ranges to shorter template names: A C++ Debugging journey - Michael Buch
2. Target-aware vectorization for irregular loops or instruction patterns - Wei Wei, Mindong Chen
3. Mitigating lifetime issues for C++20 coroutines - Utkarsh Saxena
4. Loop Iteration Space Splitting - Ashutosh Nema
5. A Wishlist for Faster LLVM Back-ends - Alexis Engelke

From C++ ranges to shorter template names: A C++ Debugging journey -Michael Buch
LLDB’s expression evaluator permits execution of arbitrary C++ expressions. It relies on an interplay between a wide range of LLVM components - the Clang frontend, LLVM’s JIT APIs, DebugInfo, clang modules and more. This quick talk outlines how all of these components fit together by showcasing some recent work we have done on LLDB to improve C++ debugging experience. Namely we describe the process of how we added support for default template arguments and Clang's preferred_name attribute in the variable view.

Target-aware vectorization for irregular loops or instruction patterns -Wei Wei, Mindong Chen
This talk will introduce a target-aware vectorization approach for irregular loops or instruction patterns, with a focus on how to generate irregular or complicated vector instructions such as COMPACT, DOT-PRODUCT, HISTCNT, etc. In addition, some clever vectorization schemes are introduced, such as lowering some math library function calls into target-dependent vector instructions, or vectorizing interleaved memory accesses by structure load stores instructions. Finally, we will discuss the choice of implementation, whether based on the Vplan framework or relying on some target-dependent passes, such as loop idiom or inst-combine pass at the backend, which require cost trade-offs.

Mitigating lifetime issues for C++20 coroutines -Utkarsh Saxena
C++20 coroutines offer an elegant approach to asynchronous programming, streamlining code structure and avoiding callback complexity. However, subtle errors in handling reference parameters can lead to dangling references and use-after-free issues. A key requirement is ensuring the lifetime of reference parameters extends throughout the entire coroutine execution, not merely the first suspension point. We explore common lifetime pitfalls in coroutines, particularly when integrated with constructs like `std::function`. We introduce the [[clang::coro_lifetimebound]] attribute, extending Clang's lifetime bound analysis to identify these issues at compile time, significantly improving coroutine code safety.

Loop Iteration Space Splitting -Ashutosh Nema
Loop splitting as a general framework to enable various needs ! Loop iteration space splitting is the process of dividing a loop into several smaller loops, each handling a portion of the original loop's iterations. LLVM currently includes a pass called InductiveRangeCheckElimination that performs loop splitting to eliminate range checks. Beyond the current method of eliminating induction range checks, there are additional scenarios where employing loop splitting could facilitate further optimizations.

A Wishlist for Faster LLVM Back-ends -Alexis Engelke
LLVM's back-end is often associated with high performance but long compilation times, even for unoptimized builds. This talk shows where compile-time within the LLVM back-end is spent and outlines some ideas for future improvements.