- LLDB: What's in a Register? -David Spickett
- Practical fuzzing for C/C++ compilers -Oliver Stannard
- Repurposing LLVM analyses in MLIR: Also there and back again across the tower of IRs -Henrich Lauko
- Life with Opaque Pointers from a Frontend Perspective -Sebastian Neubauer
- Debug information for macros -Adrian Prantl
LLDB: What's in a Register? -David Spickett
Every tool can disassemble instructions. So why do we not do the same for the contents of registers? Tired of using a manual and a calculator to find out what mode you’re in, where you’re going to branch, what your rounding mode is? Learn about a new feature in LLDB 18 that solves this problem by leveraging the power of Clang’s Abstract Syntax Tree.
Practical fuzzing for C/C++ compilers -Oliver Stannard
In this talk, I will give an overview of the fuzzers which I use to test Clang and GCC. These include open-source fuzzers like csmith, as well as some custom code-generators I have written to target specific parts of the compiler.
I'll also talk about how I run these fuzzers, testing a large number of compiler options. In particular, I have found this to be very useful for finding bugs caused by the interaction of seemingly unrelated compiler features.
Finally, I'll talk about some useful techniques for turning fuzzer failures into good bug reports, and how to continue running fuzzers before the bugs they find have been fixed.
Repurposing LLVM analyses in MLIR: Also there and back again across the tower of IRs -Henrich Lauko
LLVM IR boasts a rich history of tools and analyses, but with the emerging rise of MLIR, there is a challenge of transitioning these valuable legacy analyses to the new representation. Ideally, we would not have to touch them at all and repurpose them in MLIR seamlessly. Imagine being able to relate your analysis outcomes from LLVM IR directly to your MLIR dialect – pretty cool, right? In this talk, I will walk you through a solution that allows us to achieve precisely that using what we call a "tower of IRs," connecting LLVM representation to the desired MLIR dialect.
Life with Opaque Pointers from a Frontend Perspective -Sebastian Neubauer
Many frontends downstream of the LLVM project used to rely on semantically meaningful pointer element type information. The opaque pointer transition forced an end to this practice, creating a difficulty that keeps prompting questions on Discourse to this day. We present our experience moving SPIR-V and DXIL frontends to opaque pointers and a collection of solution patterns.
Debug information for macros -Adrian Prantl
When we were adding macros to the Swift language in Swift 5.9, we faced a challenge for how to represent them in debug info and surface them in consumers like LLDB. Like C preprocessor macros, Swift macro expansions can be nested. But unlike C preprocessor macros, Swift macros are AST transformations written in Swift that can either be standalone executables or compiler plugins. In this talk we will explain how we use inline debug information to allow LLDB and other debuggers to selectively step in or over macro expansions, and how we use an LLVM DWARF extension to capture the expanded macro source code in DWARF itself to make it available to debug info consumers that don't have access to the original project.