1.4 opo25 2025-09-26 2025-09-28 3 00:05 https://conf.gnu-tools-cauldron.org Portugal Main auditorium (400) Birds of a Feather (BoF) 2025-09-26T09:00:00+01:00 09:00 01:00 GPU threads operate in SIMT/SIMD (Single Instruction Multiple Thread / Single Instruction Multiple Data) mode: They are composed of "lanes" that execute the same instruction together in lock-step manner, but operate on different data. To show the execution state to the user, a debugger would need to be aware of lanes, so that program objects (e.g. local variables, function arguments, displayed expressions, etc.) are evaluated not only in a thread and call frame context, but also the lane context. In GNU Tools Cauldron 2024, a BoF session was organized jointly by AMD and Intel, who have downstream debuggers that implement lane support. Since then the developer teams of the two vendors compiled a common document that includes their suggested extensions to GDB commands and the user interface to introduce unified lane support to GDB. This session presents their consensus and opens it up for discussion. opo25-78079-lane-support-in-gdb-for-debugging-gpus Baris AktemurLancelot Six en false Video of the talk Lane support in GDB https://conf.gnu-tools-cauldron.org/opo25/talk/FN7FKL/ https://conf.gnu-tools-cauldron.org/opo25/talk/FN7FKL/feedback/ Main auditorium (400) Talk 2025-09-26T10:30:00+01:00 10:30 01:00 This talk will go through some of the in progress and planned AArch64 performance work for GCC 16 and GCC 17. Giving the community and partners a heads up on what to expect from Arm. opo25-75646-aarch64-performance-work Tamar Christina en false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/FZTXVZ/ https://conf.gnu-tools-cauldron.org/opo25/talk/FZTXVZ/feedback/ Main auditorium (400) Talk 2025-09-26T11:30:00+01:00 11:30 01:00 In this talk I will discuss recent improvements to GLIBC malloc, how it compares with other popular allocators, and what we could do to make malloc better - not only faster, but also safer, more maintainable and use less memory. opo25-78082-malloc-past-present-and-future Wilco Dijkstra en false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/Y7NMHZ/ https://conf.gnu-tools-cauldron.org/opo25/talk/Y7NMHZ/feedback/ Main auditorium (400) Tutorial 2025-09-26T13:30:00+01:00 13:30 01:30 This presentation is aimed at wannabe contributors to GCCs vectorizer. It should give an elaborate overview on the innards of the vectorizer, from user up to target interaction. After a thorough overview on the parts of the vectorizer we follow examples from loop and basic-block vectorization through the vectorizers code base, highlighting differences and commonalities. opo25-75504-vectorizer-for-beginners Richard Biener en false Video of the talk Slides from the talk https://conf.gnu-tools-cauldron.org/opo25/talk/SCJ9LH/ https://conf.gnu-tools-cauldron.org/opo25/talk/SCJ9LH/feedback/ Main auditorium (400) Talk 2025-09-26T16:00:00+01:00 16:00 01:00 GCC machine descriptions are straightforward to implement if someone has been involved in gcc development for a while. GCC Internals is a comprehensive resource but it assumes/requires prior knowledge. As a relative newcomer to the project (RISC-V backend) I've struggled with MD patterns (and still do). The LISPy syntax doesn't initially help either. This is my attempt to collect my learning of the last few years. If you don't know what a "Bridge" pattern is or confused between define_split and define_insn_and_split, this is the talk for you ! opo25-80727-gcc-machine-descriptions-for-the-confused Vineet Gupta en false Video of the talk GNU Cauldron 2025: GCC Machine Descriptions for the Confused https://conf.gnu-tools-cauldron.org/opo25/talk/RUTTG9/ https://conf.gnu-tools-cauldron.org/opo25/talk/RUTTG9/feedback/ Auditorium B032 (80) Talk 2025-09-26T09:00:00+01:00 09:00 01:00 I will discuss recent progress on AutoFDO. This feature was originally contributed by Google in 2014 and allows to use of profiles generated by low-overhead profiling (perf) to guide optimisation. I will discuss work needed to make AutoFDO to cooperate with link-time optimisation and the changes needed to modernise the infrastructure for the current GCC. opo25-78288-autofdo-recent-improvements jan Hubička en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/YV7F3H/ https://conf.gnu-tools-cauldron.org/opo25/talk/YV7F3H/feedback/ Auditorium B032 (80) Talk 2025-09-26T10:30:00+01:00 10:30 01:00 Critical performance regions of applications are often improved by offloading them onto specialized accelerators. This process requires selecting an adequate region of the program, subject to any eventual data dependencies, communication overheads, and the nature of the computations done in that region. Due to the complexity of this problem and the high variability of downstream vendor tools, an automated approach to this problem invites the use of a source-to-source compiler as the first stage of the compilation pipeline, preserving the source code's readability and retargetability. To this end, we propose using the Clava C/C++ source-to-source compiler to take in any C or C++ application, find and optimize adequate regions for offloading, and output those regions as separate translation units. By leveraging Clang's Abstract Syntax Tree (AST), Clava allows for a developer to write highly composable extensions that perform analysis and transformations over that AST, using modern scripting languages such as JavaScript and TypeScript. We demonstrate an entire source-to-source compilation flow for accelerating a C/C++ application, including extensions ranging from source code transformations such as function outlining and struct flattening; generation of a task graph representation of any C/C++ application; and selecting and extracting code regions for different types of accelerators, including the automatic generation of the communication layer using different APIs. opo25-81905-source-to-source-compilation-for-hardware-software-codesign Tiago Santos en false Reproducible demo Video of the talk Presentation slides https://conf.gnu-tools-cauldron.org/opo25/talk/3PGTEY/ https://conf.gnu-tools-cauldron.org/opo25/talk/3PGTEY/feedback/ Auditorium B032 (80) Lightning Talks 2025-09-26T11:30:00+01:00 11:30 00:15 Its very common that CPU's with fancy extensions and features overwhelmingly run code that is compiled for a baseline arch without any of the features enabled. Function multi versioning is a compiler framework for GCC generating multiple versions of a function, and dispatching the correct version according to the host system at load time. This talk will discuss recent developments, and the dreams for the future. opo25-75043-function-multi-versioning-developments-and-goals-for-the-future Alfie Richards en We'll talk through the current state of function multi versioning, why we view it as important, and why it needs help for the wider GCC community. Then will discuss what our ambitions/hopes are for the future and try get some feedback from others in the community. false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/XYMAKN/ https://conf.gnu-tools-cauldron.org/opo25/talk/XYMAKN/feedback/ Auditorium B032 (80) Lightning Talks 2025-09-26T11:45:00+01:00 11:45 00:15 Compare currently GCC and LLVM performance difference using FFmpeg as benchmark. Tested on a RISC-V develop board, contains vectorization performance improvement results. opo25-75627-using-ffmpeg-as-benchmark-to-verify-performance-of-gcc-and-llvm Jiawei Chen en We will introduce how to use FFmpeg as a benchmark, to compare GCC and LLVM performance on it with different situation. The test is mainly based on the RISC-V development board Muse Pi Pro with RVV1.0 feature. In addition, some problems that need to be solved will also be briefly introduced. false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/MA8Z7C/ https://conf.gnu-tools-cauldron.org/opo25/talk/MA8Z7C/feedback/ Auditorium B032 (80) Lightning Talks 2025-09-26T12:00:00+01:00 12:00 00:15 In this short talk, I look at how data mining of repository activity and mailing lists can give insight to the health of a community project. The talk offers no prescriptions, its purpose is to share techniques that may be useful to the community. opo25-80833-measuring-the-health-of-the-gcc-community Jeremy Bennett en All the interactions of an open source project are publicly visible. This includes commits to repositories, activity on bug trackers and interactions on mailing lists. In this talk I will show how this data can be mined to measure the health of community. Which backends are healthy, and which are languishing, how large are the groups maintaining different parts of the project. We can even start to consider factors such as how inclusive our community is. false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/VFLCJJ/ https://conf.gnu-tools-cauldron.org/opo25/talk/VFLCJJ/feedback/ Auditorium B032 (80) Talk 2025-09-26T13:30:00+01:00 13:30 01:00 This contribution explores possible improvements in GCC code generation for RISC-V. We collected dynamic instruction counts from selected SPEC CPU 2017 benchmarks and compared the results with AArch64. Findings reveal that prominent compiler weaknesses include missing instruction patterns, extra move instructions, unused load offsets, and functionally dead code. Additionally, vectorising library functions, like memset and mathematical operations, are crucial for maximising RISC-V efficiency. opo25-79262-comparative-analysis-of-gcc-codegen-for-aarch64-and-risc-v /media/opo25/submissions/NM7MDT/rise_logo_zWNrz27.svg Paul-Antoine Arras en This work has been carried out as a collaboration between BayLibre and Rivos Inc., and funded by the RISE Project. false Slides (GDrive) Video of the talk Slides (PDF) https://conf.gnu-tools-cauldron.org/opo25/talk/NM7MDT/ https://conf.gnu-tools-cauldron.org/opo25/talk/NM7MDT/feedback/ Auditorium B032 (80) Birds of a Feather (BoF) 2025-09-26T14:30:00+01:00 14:30 01:00 GCC has participated in the Google Summer of Code (GSoC) program since 2006 (with one year gap) but for a long time we have not shared experiences, best practices and ideas for improvements in some organized form among the mentors and GSoC "org-admins." The idea of this BoF is to do exactly that. opo25-78154-gcc-google-summer-of-code-bof Martin Jambor en We may focus on the following bullet points as well as anything that comes up during the BoF. 1. Better selection of candidates. It occasionally happens that a selected GSoC contributor needs too much hand-holding from their mentor(s) which can lead to decreased willingness of mentors to participate in the program in next years or their outright burn-out. 2. Make contributors engage with the community more. Often it feels that that accepted contributors are unwilling to ask questions on the mailing list and either communicate just with their mentor(s) in private emails or wait until their next meeting. This slows projects down and puts the entire guidance burden on the mentor(s) where community would often be able to help. 3. We might want to coordinate more when it comes to evaluations, outlining at least some common criteria for these. In fact, we may want to be stricter and fail more projects. 4. We should talk about anything that makes mentoring easier and more fun. 5. We should try to retain more contributors as long(er) term contributors to GCC. While we have gained a few important long-term community members through the program and some folk stick around for a few months, we should probably try to retain more. false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/FHSXQA/ https://conf.gnu-tools-cauldron.org/opo25/talk/FHSXQA/feedback/ Auditorium B032 (80) Talk (Short) 2025-09-26T16:00:00+01:00 16:00 00:30 This presentation covers a design of a new thread-local storage (TLS) allocator for the GNU C Library (glibc). The goal of this project is to unify the allocation algorithm for initial-exec TLS, global-dynamic TLS, and POSIX thread-specific data (as created by `pthread_key_create`). It unifies ideas that have been circulated within the glibc community for many years. opo25-80992-new-tls-allactors-for-glibc Florian Weimer en In glibc, we currently have two different algorithms for initial-exec TLS allocation, depending on the TCB layout. Global-dynamic TLS uses a completely different, lazy allocation approach. POSIX TSD (`pthread_key_create`) is based on yet another separate algorithm with its own data structures. The proposal is for a new allocator that explicitly keeps track of the gaps between allocations, and use that everywhere. TCB differences will be handled by presenting the gaps available for allocation to the allocator, based on architecture-specific details. Global-dynamic TLS and `pthread_key_create` can use part of the initial-exec TLS area, but will eventually switch to separate slices of TLS memory. These slices follow an exponential growth policy, so only a small number of them will ever be needed, and pointers to these slices can be kept in a fixed-size array directly in the TCB. The changes will eliminate lazy TLS memory allocation and slow paths from TLS accessor functions. Memory allocation failures will be reported upfront (at `dlopen` or `pthread_create`), and no longer via process termination. A previous attempt to make similar changes had to be reverted because Address Sanitizer was broken by it, and could not be fixed in time for the release. For this new effort, it should be possible to achieve Address Sanitizer compatibility by using its `malloc` to allocate TLS memory (after detecting that Address Sanitizer is active). false Video of the talk glibc TLS allocator slides glibc TLS allocator slides source code (LaTeX, TikZ) https://conf.gnu-tools-cauldron.org/opo25/talk/LQTU3G/ https://conf.gnu-tools-cauldron.org/opo25/talk/LQTU3G/feedback/ Auditorium B032 (80) Lightning Talks 2025-09-26T16:30:00+01:00 16:30 00:15 This session showcases the [glibc heap dumper](https://gitlab.com/fweimer-rh/heapdumper), a tool to obtain information about active memory allocations and `malloc` heap layout from coredumps. opo25-80993-a-heap-dumper-for-glibc Florian Weimer en false Video of the talk glibc heap dumper slides glibc heap dumper slides LaTeX source code https://conf.gnu-tools-cauldron.org/opo25/talk/8NUW3L/ https://conf.gnu-tools-cauldron.org/opo25/talk/8NUW3L/feedback/ I-105 (30) Lightning Talks 2025-09-26T10:30:00+01:00 10:30 00:15 We have made progress building Linux kernel with LTO by solving issues with top-level assembly. This is an overview of how you can build the Linux kernel with LTO today and what are the remaining issues. opo25-80827-building-linux-kernel-with-lto Michal Jireš en false Video of the talk slides https://conf.gnu-tools-cauldron.org/opo25/talk/YSGAPE/ https://conf.gnu-tools-cauldron.org/opo25/talk/YSGAPE/feedback/ I-105 (30) Birds of a Feather (BoF) 2025-09-26T10:45:00+01:00 10:45 01:30 Author: Steven Rostedt (Kernel maintainer) Author: Paul E. McKenney (Kernel maintainer) Author: Alexei Starovoitov (Kernel maintainer) Author: Jose E. Marchesi (GNU toolchain) The Linux kernel, which is by far one of the biggest, more complex and more important programs around, is (still) mainly built using the GNU Toolchain. There is an intimate relationship between toolchain and kernel. Compiling a huge, complex and specialized program such as the kernel often implies facing challenging or unusual requirements on the toolchain side. This includes security related requirements. Also, some of the toolchain components interface directly with the kernel. In the case of glibc, it even provides the main visible interface from the kernel to userland programs. The support for BPF is also mainly Linux kernel specific. This relationship benefits both projects. For example, an actively maintained toolchain can quickly include kernel specific enhancements. And vice versa, the toolchain benefits from the associated relevance that makes corporations support its development. It is certainly not unusual for a feature introduced primarily for kernel usage to also be very useful to other programs. Examples of this are the support for patchable function entries, "asm goto", fentry , and several security related features. In order to improve this relationship a Toolchains Track has been organized for some years now at the Linux PLumbers Conference. The aim of the track is to fix particular toolchain (both GNU and LLVM) issues which are of interest to the kernel and, ideally, find and agree on solutions right away, during the track, making the best use of the opportunity to discuss the issues live with kernel developers and maintainers. The LPC toolchains track is proving very useful, although it is not always easy to bring toolchain hackers there, given it is a kernel specific conference. We propose to have a Toolchain and Linux Kernel BoF during Cauldron this year, with the participation of at least one Linux kernel maintainer. The goals of the BoF are (a) to discuss about particular requirements, desired features and on-going developments that are relevant to the kernel and (b) to gather kernel related questions/input/feedback from the toolchain developers so we can bring the issues to the LPC Toolchains Track, which will be held later in the year after Cauldron. opo25-75134-toolchain-and-linux-kernel Jose MarchesiPaul McKenneyAlexeiSteven Rostedt en false Video of the talk Slides for Kernel Recipes 2025 talk by Thomas Schwinge Slides for BTF inline from Alan Maguire https://conf.gnu-tools-cauldron.org/opo25/talk/SBMUWN/ https://conf.gnu-tools-cauldron.org/opo25/talk/SBMUWN/feedback/ I-105 (30) Birds of a Feather (BoF) 2025-09-26T13:30:00+01:00 13:30 01:00 In this BoF we will be discussing topics related to the BPF target in the GNU Toolchain. opo25-80005-bpf-bof Jose Marchesi en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/9KJV9X/ https://conf.gnu-tools-cauldron.org/opo25/talk/9KJV9X/feedback/ I-105 (30) Birds of a Feather (BoF) 2025-09-26T16:00:00+01:00 16:00 01:00 Patch review bandwidth has been identified as a bottleneck for GCC development many times over the years. We have taken steps to address it, such as appointing people in reviewer roles. But we can do more to reduce the friction for contributors to try patch review. I will present some motivation to start reviewing patches and address common perceived barriers to doing so. One take away from advocating for upstream patch review among colleagues is that there are no good set of guidelines to refer to when reviewing patches. In this talk I propose a set of baseline guidelines for patch review for the GCC project that can act as a starting point for budding reviewers. These can include technical design conventions that we want to maintain, common mistakes to look out for, testing and benchmarking considerations, commit message reviews, deployment concerns, and more high-level, social etiquette and procedural considerations. I am interested in feedback on these guidelines and ideas on how and where we may want to advertise them for newcomers. opo25-80278-introduction-to-upstream-patch-review-in-gcc Kyrill Tkachov en false Video of the talk Introduction to upstream patch review in GCC https://conf.gnu-tools-cauldron.org/opo25/talk/LZHWTK/ https://conf.gnu-tools-cauldron.org/opo25/talk/LZHWTK/feedback/ Auditorium B032 (80) Talk 2025-09-27T09:00:00+01:00 09:00 01:00 This presentation exposes the improvements of the Libabigail framework that occurred since the end of the 2024, across the 2.7 and 2.8 releases. As many of those improvements were about improving the signal to noise ratio of ABI change reports, the talk presents the internals of the middle-end and how it relates to categorizing ABI changes in such a way that the back-ends that generate ABI change reports can be better equipped to lower the rate of false positives. Besides the deep dive in the middle-end internals, the talk walks through the user-facing improvements of the tools written using the framework in the 2.7 and 2.8 releases. The talk ends with some considerations about future perspectives of improvements that still needs to be addressed. opo25-80784-abi-change-analysis-in-libabigail-2-8 Dodji Seketeli en false Video of the talk PDF of the presentation https://conf.gnu-tools-cauldron.org/opo25/talk/7VGPWL/ https://conf.gnu-tools-cauldron.org/opo25/talk/7VGPWL/feedback/ Auditorium B032 (80) Talk (Short) 2025-09-27T10:30:00+01:00 10:30 00:30 Tasked with identifying safer optimization flags and GCC releases to use, we've developed techniques to extract information from the PR database and from the testsuite. We've found that the growing PR density over time is not intuitively correlated with quality, but that running "future" torture testsuites with extra optimization flags on "past" releases can provide useful insights about relevant points of instability. Slides at https://www.lx.oliva.nom.br/slides/timetravel.en.pdf opo25-79953-time-traveling-through-the-gcc-pr-database-and-testsuite Alexandre Oliva en Though higher PRs/quarter, /month, /week, /day could intuitively correlate with higher instability, we find that it correlates with stricter scrutiny: it amounts to more eyes collaborating to shake bugs out, rather than more bugs being introduced. Indeed, PR frequency has been on the rise, and that correlates with higher rather than lower stability. We've resorted to a time-traveling technique to identify (un)safer optimizations: adding optimization-disabling flags to torture options of newer testsuites, and running them with older compiler releases, so as to identify flags that most avoid problems that would only be uncovered in the future. false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/FNC8SK/ https://conf.gnu-tools-cauldron.org/opo25/talk/FNC8SK/feedback/ Auditorium B032 (80) Talk 2025-09-27T11:00:00+01:00 11:00 01:00 How can users add new instructions without knowledge on GCC internals? Integrating custom instructions into a RISC-V processor typically requires deep familiarity with GCC internals, particularly its RTL and backend architecture. This talk presents APEX, an approach for defining custom RISC-V instructions in GCC directly from C using pragmas, or assembly source code. Rather than modifying the compiler internals directly, users can define new operations using a simple "#pragma" and a function declaration, which are then parsed by the front end and transformed into GCC’s internal RTL (RTX) representation. This approach eliminates the need for manual backend modifications, making custom instruction support more accessible to users. We will explore the APEX pipeline in detail - from parsing APEX input C-code to instruction emission and encoding in Binutils, understand how APEX instructions are handled by the assembler, disassembler/debugger. This presentation targets compiler engineers, toolchain maintainers and hardware architects interested in extending RISC-V with domain-specific instructions while working within the GNU ecosystem. APEX reduces the need to dig into GCC internals, allowing contributors to prototype, experiment, and upstream new ideas with less effort. opo25-80741-simplifying-custom-instruction-integration-in-gcc-for-risc-v-processors Luis Silva en false Video of the talk slides https://conf.gnu-tools-cauldron.org/opo25/talk/YZTJNG/ https://conf.gnu-tools-cauldron.org/opo25/talk/YZTJNG/feedback/ Auditorium B032 (80) Talk (Short) 2025-09-27T12:00:00+01:00 12:00 00:20 RISC-V's rapid growth to more than 100 extensions and 1000 instructions creates maintenance challenges across the ecosystem. Tools like Binutils, QEMU, and the Linux kernel each maintain separate definitions for standard and custom instructions and extensions, leading to fragmentation and repetitive maintenance burden. The RISC-V Unified Database (UDB) is a machine-readable source of truth for instructions and CSRs, containing ~90% of RISC-V instructions. We built a framework that continuously validates UDB against Binutils data and ensures both stay in sync. Moreover, we created a generator that converts UDB data into Binutils and QEMU definitions, reducing effort for developers porting new or custom extensions. This talk will demonstrate UDB's toolchain verification, cross-validation results, and how developers can leverage UDB to port new RISC-V extensions into the GNU toolchain. opo25-80873-risc-v-unified-database-automating-extension-integration-across-binutils-qemu-and-beyond Afonso Oliveira en false UDB Repo Video of the talk Talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/YTTYJE/ https://conf.gnu-tools-cauldron.org/opo25/talk/YTTYJE/feedback/ Auditorium B032 (80) Talk (Short) 2025-09-27T13:30:00+01:00 13:30 00:30 Profile-guided optimizations are not new, but also not that popular. Why? Maybe because your build workflow can't easily include profile gathering - and every time. What if we could share profile data with each other, so you could take advantage of public crowdsourcing? What if you could easily contribute back your workload profiles? What if we can integrate this into distro build systems? Let's try with profiledb: a bit of glue between git, profilers, and linkers. opo25-80847-profiledb-optimize-your-distro-builds-with-crowdsourced-profile-corpus Frank Ch. Eigler en false Video of the talk slides https://conf.gnu-tools-cauldron.org/opo25/talk/XL3XQD/ https://conf.gnu-tools-cauldron.org/opo25/talk/XL3XQD/feedback/ Auditorium B032 (80) Talk (Short) 2025-09-27T14:00:00+01:00 14:00 00:30 This session will discuss the performance benchmark results of the new wide set implementation in gm2. It will also report on the approach taken to implement this data type and how this technique will be used to implement M2R10 and ISO generics. opo25-80308-modula-2-new-wide-set-implementation-performance-results-and-direction-of-travel Gaius Mulley en This talk presents the performance results for the new wideset implemented in gm2. The technique follows the design shown in the M2R10 proposed standard, namely using a module to contain the operators for a base datatype. The talk will conclude by discussing the M2R10 pragmas and how they will be used to enable module inlining and Modula-2 dialect choice. Therefore allowing mixed dialect projects to be whole program optimized and potentially more base type operators could be implemented as an inline module. false Video of the talk Slides used during presentation https://conf.gnu-tools-cauldron.org/opo25/talk/V7QCDW/ https://conf.gnu-tools-cauldron.org/opo25/talk/V7QCDW/feedback/ Auditorium B032 (80) Talk 2025-09-27T14:30:00+01:00 14:30 01:00 Introduction to RISC-V auto vectorization. Basic building blocks, supported features, concepts, idiosyncrasies/quirks and more. Overview of what has been done, what's currently cooking and what's planned for the future. Topics include, riscv vector modes and patterns, else operands, vector-vector and vector-scalar variants, vsetvl placement etc. opo25-80825-risc-v-auto-vectorization-101 Robin Dapp en false Video of the talk RVV 101 Slides https://conf.gnu-tools-cauldron.org/opo25/talk/89QXSR/ https://conf.gnu-tools-cauldron.org/opo25/talk/89QXSR/feedback/ Auditorium B001 (170) Birds of a Feather (BoF) 2025-09-27T09:00:00+01:00 09:00 01:00 The proposal is for a BoF on GCC and AI, with the goal of opening up discussion on: - Current and emerging use cases where GCC intersects with AI/ML workloads, including compiler optimisations for AI kernels. - Challenges in supporting AI accelerators and heterogeneous compute through GCC. - Open questions for the community: to what extent should GCC evolve in this area, and where should external tooling take the lead? The idea is to bring together community members interested in this intersection of GCC and AI, share experiences, and identify where GCC could play a meaningful role. opo25-81904-bof-on-gcc-and-ai Jeremy BennettPietra Ferreira en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/3URW7F/ https://conf.gnu-tools-cauldron.org/opo25/talk/3URW7F/feedback/ Auditorium B001 (170) Talk 2025-09-27T10:30:00+01:00 10:30 01:00 An update of the current status of OpenMP, OpenACC and offloading in GCC, including what has been achieved last year. A few highlights and, additionally, an outlook for next years is given of the tasks that are planned or that should be done in the near term. opo25-79269-parallel-computing-offloading-openmp-and-openacc Tobias BurnusThomas Schwinge en false Video of the talk Slides of Talk on Parallel Computing, Offloading, OpenMP and OpenACC https://conf.gnu-tools-cauldron.org/opo25/talk/EKDPEH/ https://conf.gnu-tools-cauldron.org/opo25/talk/EKDPEH/feedback/ Auditorium B001 (170) Birds of a Feather (BoF) 2025-09-27T11:30:00+01:00 11:30 01:00 BoF discussing inter-procedural optimization, link-time optimization and profile feedback in GCC opo25-78286-ipa-lto-and-profile-feedback-bof jan Hubička en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/P7HWJ9/ https://conf.gnu-tools-cauldron.org/opo25/talk/P7HWJ9/feedback/ Auditorium B001 (170) Talk 2025-09-27T13:30:00+01:00 13:30 01:00 Hear our experiences on mentoring new contributors, what common hurdles they face, and how we try to address them. Then, let’s discuss how to reduce the barrier to entry. opo25-75644-uncomplicating-new-contributions Arjun ShankarGuinevere en While our contribution process may seem familiar and uncomplicated to us, it is very different to what most new developers expect, which leads to several stumbling blocks. That is not a failure of our process, we just need to be explicit what is different, so that these new developers feel able to navigate it on their own. We, Guinevere Larsen and Arjun Shankar, have been attempting to get new contributors in our respective projects, GDB and glibc, and have collected a series of common stumbling blocks for first time contributors. The first half of this talk aims to present these stumbling blocks, and then suggestions on how projects can reduce or remove them without affecting established developer workflows. The second half will be dedicated to open discussions on those suggestions and new ones that may come up. false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/ZMC7QR/ https://conf.gnu-tools-cauldron.org/opo25/talk/ZMC7QR/feedback/ Auditorium B001 (170) Birds of a Feather (BoF) 2025-09-27T14:30:00+01:00 14:30 01:00 Discussion of topics related to parallel computing and accelerator offloading in GCC. In particular, related to OpenMP and OpenACC and to offloading to AMD and Nvidia GPUs. But also other topics like additional offloading targets or base-language parallelization features of C, C++, Fortran, or other languages are welcome. Planned topics include completion of OpenMP 5.x and addition of more 6.x features, OpenACC extension, improving performance, but also support for a GPU kernel language (programming at the abstraction level of CUDA/HIP – as proposed for the next OpenMP version). opo25-79270-bof-on-parallel-computing-offloading-openmp-and-openacc Tobias BurnusThomas SchwingeJakub Jelinek en _While some discussion points will be prepared, this is an open BoF and other related topics can be raised. A slide or two will be prepared as a starting point for discussion or to illustrate a to-be-discussed item. If you want or have such an item, feel free to send the slide to the BoF organizers for including it._ false Video of the talk Slides of BoF on Parallel Computing, Offloading, OpenMP and OpenACC https://conf.gnu-tools-cauldron.org/opo25/talk/CY3BMC/ https://conf.gnu-tools-cauldron.org/opo25/talk/CY3BMC/feedback/ Auditorium B001 (170) Birds of a Feather (BoF) 2025-09-27T16:00:00+01:00 16:00 01:00 Q&A panel discussion of development processes in GNU Toolchain projects – GCC, Glibc, GDB, Binutils, etc. – and how they affect our developer community. We will discuss 4 topics: - Onboarding new developers - Growth, roles, and reputation. How to become a maintainer? - Governance, and how decisions are made - Infrastructure and tools for developers opo25-78867-processes-and-barriers Carlos O'DonellMaxim Kuvyrkov en Confirmed panelists are: - Richard Biener - Nick Clifton - Adhemerval Zanella - Maxim Kuvyrkov (moderator) - Carlos O'Donell (moderator) ... and we are waiting for confirmation from other panelists. false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/BAWVZM/ https://conf.gnu-tools-cauldron.org/opo25/talk/BAWVZM/feedback/ Auditorium B002 (170) Talk 2025-09-27T09:00:00+01:00 09:00 01:00 The glibc math library aims to provide the required functions and macros from C standard math.h and related headers (fenv.h, float.h, and complex.h). The glibc supports multiple architectures and floating-point types, and also provides vectorized routines for some architectures. The math library is actively working to support newer extensions and features. On this, I will demonstrate the recent optimization of multiple parts of the math libraries, explaining how we achieve it by utilizing new algorithms adapted for new hardware, as well as by leveraging external projects with improved implementations. I will also present recent work that supports the newer C23 functions and outline possible future work for optimizations. Also, I will talk and ask about future extensions and what to focus on. Should we aim to provide implementation with better precision, and what is the expected tradeoff between performance and precision? Should we extend the support for newer types, for instance, float16_t? And what about decimal floating point support? Should we add a platform neutral skeleton vector math library to be used by other archictures? opo25-78080-latest-glibc-math-improvements-and-the-future Adhemerval Zanella Netto en false Video of the talk Presentation slides https://conf.gnu-tools-cauldron.org/opo25/talk/BKRJGY/ https://conf.gnu-tools-cauldron.org/opo25/talk/BKRJGY/feedback/ Auditorium B002 (170) Talk 2025-09-27T10:30:00+01:00 10:30 01:00 As memory and performance capabilities of computer have increased, virtualization has been the preferred approach to exploit all those resources. To efficiently use such a system it is required to maximize the number of concurrent applications. This makes it extremely important to fully optimize any running application not only for time (cpu) but also space (memory). Moreover, high reliability and large data multi-threaded applications require not only an efficient allocation strategy but also a reliable and fast concurrency mechanism. The solution for parallelism in glibc malloc (arenas) is based on minimizing concurrency through isolation, splitting the memory space through different threads using virtual memory as an abstraction layer. This solution defers memory management to the kernel rather than keeping the responsibility to explicitly perform minimum virtual allocation. Glibc malloc has been identified by projects such as MySQL and JVM as using more memory than required, and this has justified the adoption of other more multi-threaded friendly allocators, such as jemalloc and tcmalloc. This talk will present MySQL performance and data size analysis using both glibc malloc and other competitive allocators, and show how recent improvements in the glibc malloc implementation greatly reduce virtual memory consumption in real-world MySQL usage, making it unnecessary to resort to other specialized allocators. Further possible improvements will also be discussed, which can make glibc the best allocator for high availability large data multi-threaded applications. opo25-78341-improving-glibc-malloc-for-high-reliability-large-data-multi-threaded-applications Cupertino Miranda en false RSS growing reproducer in mysql Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/LXPUYR/ https://conf.gnu-tools-cauldron.org/opo25/talk/LXPUYR/feedback/ Auditorium B002 (170) Birds of a Feather (BoF) 2025-09-27T11:30:00+01:00 11:30 01:00 The GNU C Library is used as the C library in the GNU systems and many other systems with the Linux kernel. The library is primarily designed to be a portable and high performance C library. It aims to follows all relevant standards including ISO C17 and POSIX.1-2008. It is also internationalized and has one of the most complete internationalization interfaces known. opo25-73227-gnu-c-library-bof Carlos O'Donell en This BoF aims to bring together developers of other components that have dependencies on glibc and glibc developers to talk about the following topics: * Planning for glibc 2.43 and what work needs to be done between September 2025 and February 2026. * Planning for glibc 2.44 and what work needs to be done between February 2026 and August 2026. * Can we try month-to-month feature planning again? ... and more. false Video of the talk GNU Tools Cauldron 2025 - GNU C Library BoF.pdf https://conf.gnu-tools-cauldron.org/opo25/talk/HEZF9L/ https://conf.gnu-tools-cauldron.org/opo25/talk/HEZF9L/feedback/ Auditorium B002 (170) Talk 2025-09-27T13:30:00+01:00 13:30 01:00 The talk will provide an overview of the different stack tracing methods (un-)available on s390 for user space. It will cover: Why stack tracing using *frame pointer* is virtually impossible on s390 and why compiler option `-fno-omit-frame-pointer` should better be avoided on s390. The limitations of stack tracing using the s390-specific alternative of *back chain*. Why *[SFrame](https://sourceware.org/binutils/wiki/sframe)* stack trace information is expected to considerably improve stack tracing of user space on s390. Finally it will provide an overview of the current state of SFrame support on s390 64-bit (s390x): The s390-specific SFrame stack trace format extensions, s390 support for generating SFrame stack trace information in Binutils 2.45, work-in-progress s390 support for SFrame in Glibc backtrace, and work-in-progress s390 support for SFrame in Linux Kernel and perf to sample stack traces of user space. opo25-79187-s390-stack-tracing-using-frame-pointer-back-chain-and-sframe Jens Remus en false Video of the talk Presentation Slides https://conf.gnu-tools-cauldron.org/opo25/talk/Y3CVHY/ https://conf.gnu-tools-cauldron.org/opo25/talk/Y3CVHY/feedback/ Auditorium B002 (170) Talk 2025-09-27T14:30:00+01:00 14:30 01:00 This talk provides an overview of recent developments in the SFrame stack tracing format over the past year. We discuss some of the enhancements to the SFrame stack trace format that are currently being looked at. Some of these desirable features in the planned SFrame V3 version help make the format more future-proof and more amenable to overall smoother adoption in the wider GNU/Linux community. opo25-80010-sframe-for-effective-userspace-stack-tracing Indu Bhagat en false Video of the talk Presentation Slides https://conf.gnu-tools-cauldron.org/opo25/talk/ADVMH7/ https://conf.gnu-tools-cauldron.org/opo25/talk/ADVMH7/feedback/ Auditorium B003 (170) Talk 2025-09-27T09:00:00+01:00 09:00 01:00 This is a talk about all things "unload", my removal of the old reload code. opo25-75075-unload Segher en This is a talk about all things "unload", my removal of the old reload code. What made it take five years? What things remain? Both in what work still remains to be done, as well as what code of the old reload remains? What are the things that can be done now that we always have LRA, instead of the old reload? We cannot have subregs of memory anymore, but no doubt other things are better now as well! false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/B7WFVR/ https://conf.gnu-tools-cauldron.org/opo25/talk/B7WFVR/feedback/ Auditorium B003 (170) Talk 2025-09-27T10:30:00+01:00 10:30 00:30 Similar to register asm but still distinct, hard register constraints are another way to force operands of inline asm into specific machine registers. In this talk we will have a brief look at hard register constraints and compare them to register asm. We will look at how to use them, how they might help write more robust code, their current (implementation) limitations, practical experiments, and have a lookout for improvements. opo25-79869-hard-register-constraints Stefan Schulze Frielinghaus en true Slides https://conf.gnu-tools-cauldron.org/opo25/talk/A3LNUZ/ https://conf.gnu-tools-cauldron.org/opo25/talk/A3LNUZ/feedback/ Auditorium B003 (170) Talk (Short) 2025-09-27T11:00:00+01:00 11:00 00:30 Since bunsen was first presented at Cauldron 2019, work and workload has exploded. Bunsen on sourceware is processing the test results from hundreds of daily builds of a dozen of our favorite projects, It features CLI and web front-ends for clever searches, plus downloadable archives so you can play along at home. Recently, it has learned to connect project upstream git repos and commit histories to build/test histories. Putting all that info together, it can call on an AI to analyze causal factors of regressions. Let me show you how the tool may already be useful to you. opo25-80850-bunsen-testsuite-result-analysis-depot-with-a-sprinkling-of-ai Frank Ch. EiglerMartin Cermak en false database browser project Video of the talk slides https://conf.gnu-tools-cauldron.org/opo25/talk/7FJALC/ https://conf.gnu-tools-cauldron.org/opo25/talk/7FJALC/feedback/ Auditorium B003 (170) Talk 2025-09-27T11:30:00+01:00 11:30 01:00 Algol 68 was designed by the Working Group 2.1 of the International Federation for Information Processing (IFIP) during the late 1960s and early 1970s, leaded by Adriaan van Wijngaarden. The goal of the working group was to provide a programming language suitable to communicate algorithms, to execute them efficiently on a variety of different computers, and to aid in teaching them to students. The resulting language was in principle expected to be an evolved version of Algol 60, known shortcomings addressed, and generally improved. However, what was initially supposed to be an improved version of Algol 60 turned out to be something very different: an extremely powerful programming language, more modern and more expressive than most programming languages today, whose design exercised almost to the limit the newly invented notion of orthogonality in programming languages. Algol 68 is not like Algol 60, an important but old fashioned programming language superseded in almost every aspect by its successors, only relevant nowadays as a historical curiosity. Despite of many people claiming otherwise, Algol 68 has no successors. The GNU Algol 68 Working Group is a group of hackers whose purpose is to bring Algol 68 back to the first line of programming where it belongs, to provide modern implementations of the language well integrated in today's operating systems and computers (like the GCC Algol 68 front-end), to produce documentation to help people to learn this fascinating language, and to explore extensions and evolve the language with the rigor, respect and seriousness that it deserves and demands. In January 2025 a first work-in-progress patch series implementing an Algol 68 front-end for GCC got sent to gcc-patches. Since then, the development has continued at a steady pace and by now most of the language has been implemented. In this talk we will introduce the front-end and the world domination plan associated with it, will highlight and discuss some interesting aspects of the implementation (Algol 68 is a notoriously difficult to implement language) and will make a case for the inclusion of the front-end in the main GCC tree. We will also briefly look at some of the tangent projects like the Algol 68 support in the autotools and the a68 Emacs mode, as time allows. References: - Front-end development homepage: https://gcc.gnu.org/wiki/Algol68FrontEnd - Git repository: https://forge.sourceware.org/gcc/gcc-a68 - Algol 68 homepage: https://algol68-lang.org opo25-75766-ga68-the-gnu-algol-68-compiler /media/opo25/submissions/VMJQCK/logo_9u9t95j.jpg Jose Marchesi en false Video of the talk talk slides https://conf.gnu-tools-cauldron.org/opo25/talk/VMJQCK/ https://conf.gnu-tools-cauldron.org/opo25/talk/VMJQCK/feedback/ Auditorium B003 (170) Talk 2025-09-27T13:30:00+01:00 13:30 01:00 I'll be talking about developments in GCC 16: * those affecting GCC's diagnostic subsystem, and * those affecting the static analyzer (-fanalyzer) opo25-75074-what-s-new-with-diagnostics-in-gcc-16 David Malcolm en false Video of the talk Slides: "What's new with diagnostics in GCC 16" https://conf.gnu-tools-cauldron.org/opo25/talk/NQNCEW/ https://conf.gnu-tools-cauldron.org/opo25/talk/NQNCEW/feedback/ Auditorium B003 (170) Birds of a Feather (BoF) 2025-09-27T14:30:00+01:00 14:30 01:00 An opportunity for the GDB community to meet to discuss all things related to the GNU Debugger project. opo25-78540-the-gdb-bof Pedro Alves en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/8CAXUU/ https://conf.gnu-tools-cauldron.org/opo25/talk/8CAXUU/feedback/ Auditorium B032 (80) Birds of a Feather (BoF) 2025-09-28T10:30:00+01:00 10:30 01:00 As the FSF's licensing and compliance manager, I will address licensing-related questions from the maintainers and developers of the toolchain projects. This will be an informal, interactive exchange about the topics collected through RFCs before GNU Cauldron but you are welcome to ask a question during the session as well. It will also be an opportunity to learn about FSF's Licensing and Compliance Lab recent work. We plan to cover topics such as LLM-generated contributions to GNU, following notice and attribution requirements, and GPL compliance in different technical setups. opo25-78405-licensing-birds-of-a-feather Krzysztof Siewicz en One of the FSF's Licensing and Compliance Lab's priorities is to support the GNU Project in any licensing-related challenges, collecting copyright assignments and copyright maintenance, as well as working with identified GPL violations to ensure software freedom in GNU programs is respected by distributors. You can always send us a question at <licensing@fsf.org> but we would love to use every possible opportunity to meet and talk in person. This proposed session for the FSF licensing BoF at Cauldron will help us to get to know each other better and understand what are the best ways to be of help to the GNU Project's developers. We have reached out to the maintainers and developers of the toolchain projects with RFCs, and already received some suggestions of topics to cover during this BoF, like: Licensing challenges in accepting LLM-generated source code; Practical approach to observing notice and attribution requirement in licenses of preexisting code used in GNU programs; and GPL compliance in the context of software containers. All pertinent topics we look forward to addressing and openly discussing at GNU Cauldron. People can send us more suggestions until the Cauldron and if time permits, we are also prepared to brief you about the Lab's recent work, in particular in the GPL stewardship and compliance area. false Video of the talk Siewicz - Licensing BoF presentation https://conf.gnu-tools-cauldron.org/opo25/talk/VMWHG7/ https://conf.gnu-tools-cauldron.org/opo25/talk/VMWHG7/feedback/ Auditorium B032 (80) Talk 2025-09-28T11:30:00+01:00 11:30 01:00 This year the Rust front end completed multiple major milestones: the name resolution rework is now complete, the desugaring pass has brought support for a lot of new features, and we were lucky enough to get two amazing GSOC students who greatly improved the capabilities of the front end. Being able to compile more Rust led to some unexpected discoveries and opened the way for previously unhandled complex edge cases to be fixed. Our next step involves iterating towards compiling Rust-for-Linux, which we will begin experimenting with in September. This talk will cover what has recently changed in the Rust front end and what will be done this year, as well as a few surprises we had along the way. The talk will conclude with an update of the upstream synchronization process and the communication with the wider GCC community. opo25-80753-rust-front-end-post-libcore Pierre-Emmanuel Patry en false Video of the talk Slides used during the talk https://conf.gnu-tools-cauldron.org/opo25/talk/VM3GNC/ https://conf.gnu-tools-cauldron.org/opo25/talk/VM3GNC/feedback/ Auditorium B032 (80) Talk 2025-09-28T13:30:00+01:00 13:30 01:00 In my work on [smtgcc](https://github.com/kristerw/smtgcc) to formalize the semantics of GIMPLE, I have found several cases where optimization passes perform invalid transformations, as well as cases where the GIMPLE semantics do not allow optimization passes to express what they need (see [PR120980](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=120980) for an example). In this talk, I will present the current status of the formalization and discuss the issues I have found during the process. opo25-81014-formalizing-the-semantics-of-gimple Krister Walfridsson en false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/M7GYBJ/ https://conf.gnu-tools-cauldron.org/opo25/talk/M7GYBJ/feedback/ Auditorium B032 (80) Talk 2025-09-28T14:30:00+01:00 14:30 01:00 The BPF verifier has troubles when verifying loops. This talk will cover: - historical evolution of loops handling by verifier; - problems with current state of things (too crude widening, no bounds for induction variables); - describe DFA based liveness analysis that landed last week; - describe further steps adding DFA-based value range analysis to the verifier (a very hand-waving part). We are interested in the feedback of the GNU toolchain community, especially when it comes to range analysis. opo25-81900-moving-bpf-verifier-towards-classic-data-flow-analysis-techniques Eduard Zingerman en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/WJNXAP/ https://conf.gnu-tools-cauldron.org/opo25/talk/WJNXAP/feedback/ Auditorium B001 (170) Talk 2025-09-28T09:00:00+01:00 09:00 01:00 An opportunity for a GNU Toolchain community conversation with the members of the Steering Committees of the GNU Toolchain projects (GCC, GLIBC, Binutils, GDB). opo25-78131-steering-committee-q-a David Edelsohn en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/DUAJWT/ https://conf.gnu-tools-cauldron.org/opo25/talk/DUAJWT/feedback/ Auditorium B001 (170) Talk (Short) 2025-09-28T10:30:00+01:00 10:30 00:30 GNAT already offered mechanisms to handle C++ exceptions, but they were limited to exact class type matches. This presentation covers the extensions to Ada syntax, runtime and library to enable Ada subprograms to catch and handle C++ exceptions hierarchies, and to reference the raised C++ (sub-)object. Slides at https://www.lx.oliva.nom.br/slides/adacxxcept.en.pdf opo25-79952-handling-c-exception-hierarchies-in-ada Alexandre Oliva en The presentation will contrast Ada's and C++'s exception models, go through the preexisting implementation and its constraints, how we've extended exception declarations, relaxed handler constraints, exposed C++ RTTI and used it in the runtime and the library to catch C++ derived objects by Ada exceptions associated with the C++ base class, and to gain access to the caught C++ sub-objects. false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/SBAAAL/ https://conf.gnu-tools-cauldron.org/opo25/talk/SBAAAL/feedback/ Auditorium B001 (170) Talk (Short) 2025-09-28T11:00:00+01:00 11:00 00:30 When compiling OpenMP constructs, the bodies of OpenMP regions are outlined into separate functions, which are later called indirectly by libgomp built-ins. This outlining process disables interprocedural optimizations for the kernels. In this short talk, we outline a mechanism to partially restore interprocedural optimization capabilities for the kernels, starting with constant propagation, and we discuss its applications beyond OpenMP. opo25-80061-interprocedural-optimization-of-openmp-kernels Josef Melcr en false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/3VZ9BE/ https://conf.gnu-tools-cauldron.org/opo25/talk/3VZ9BE/feedback/ Auditorium B001 (170) Talk (Short) 2025-09-28T11:30:00+01:00 11:30 00:30 Everyone wants to improve the code quality of GCC yet many small patches, suggested improvements, and larger refactoring projects remain unaddressed. In some cases without any updates in over 20 years! It becomes very discouraging to attempt to develop these patches when there is no set guidelines for what is acceptable. To that end, we will take a brief look at past efforts to identify the pain points of developing, reviewing, and finally approving these patches. From here we look at what we can do to reduce friction for developers and maintainers, with a focus on quantifying impacts on GCC's compile duration, run time performance and debug-ability. opo25-80944-quantifying-abstraction-costs-in-gcc Alex (Waffl3x) en This talk also serves as a soft prerequisite to my BOF as the motivations for it are covered in this talk, if you're interested in attending it you should consider being here for this one. false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/3PTT7K/ https://conf.gnu-tools-cauldron.org/opo25/talk/3PTT7K/feedback/ Auditorium B001 (170) Birds of a Feather (BoF) 2025-09-28T13:30:00+01:00 13:30 01:00 In continuation from my talk on quantifying abstractions by objective costs, we also need to evaluate the more subjective costs and benefits of this work, as well as where that work should be directed. Ideally this will form the basis of a design document that developers can refer to for guidance, further reducing friction between developers and maintainers by making expectations more clear. We will talk about and evaluate: - acceptability and like/dislike of different abstractions and practices - what is most important to refactor/rewrite/modernize, and the risks of doing so - refresh our state on goals, ImprovementProjects, and rearch plans (some of this is very old) - figure out what changes we really want - and very importantly, what we do NOT want our code base to become To help stimulate discussion, I will prepare examples of code with potential refactors (some intentionally bad). opo25-80955-gcc-bof-reviewing-refactoring-goals-and-acceptable-abstractions Alex (Waffl3x) en This builds on top of my previous talk "Quantifying Abstraction Costs in GCC", if you plan on attending this BOF it would be beneficial to attend that talk to develop more background. false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/GWSYPJ/ https://conf.gnu-tools-cauldron.org/opo25/talk/GWSYPJ/feedback/ Auditorium B002 (170) Talk (Short) 2025-09-28T10:30:00+01:00 10:30 00:30 The RTL SSA framework is a relatively new component of GCC that enables SSA-based analysis on RTL. In this talk, I will present a dead code elimination (DCE) implementation built on top of this framework, intended to replace the existing UD-chain based DCE. opo25-80987-developing-a-dead-code-elimination-pass-with-rtl-ssa Ondřej Machota en For my bachelor’s thesis, I implemented a dead code elimination (DCE) pass using the RTL SSA framework in GCC. This talk aims to explain the SSA based DCE algorithm in detail, outline key aspects of the implementation and highlight the challenges and decisions encountered during development. false Video of the talk Presentation https://conf.gnu-tools-cauldron.org/opo25/talk/8H8U3C/ https://conf.gnu-tools-cauldron.org/opo25/talk/8H8U3C/feedback/ Auditorium B002 (170) Lightning Talks 2025-09-28T11:00:00+01:00 11:00 00:15 Profile-Guided Optimization (PGO) is a powerful technique for achieving performance gains, yet its instrumentation-based implementation imposes a high overhead that limits its adoption in production environments. AutoFDO solves this by using low-overhead hardware based sampling to gather profile data, making it an ideal approach for continuous, real-world optimization. This presentation details the work required to enable AutoFDO for AArch64 within the GNU toolchain and a state of the world for AutoFDO. We will cover the key architectural features that make efficient, sampling-based profiling possible. We cover the hardware pre-requisites and implications of using the various hardware units available on the AArch64 architecture (namely SPE and BRBE). We will discuss the specific technical challenges encountered, including the crucial task of accurately annotating the pre-optimization IR representation using a profile gathered from an already optimized binary. We will detail the fixes implemented in the AutoFDO tools and GCC to handle the discrepancies that arise from this process. This ensures that the profile data correctly drives optimizations like inlining and block reordering, even with significant opo25-80933-bringing-autofdo-to-aarch64-low-overhead-profile-guided-optimization-for-aarch64 Kugan Vivekanandarajah en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/MSLAKP/ https://conf.gnu-tools-cauldron.org/opo25/talk/MSLAKP/feedback/ Auditorium B002 (170) Lightning Talks 2025-09-28T11:15:00+01:00 11:15 00:15 In this talk, I will give a quick overview of some of the current existing RISC-V testing infrastructure, focusing on our pre/post commit CI and automated fuzzing system. I will briefly show how these tools have helped identify regressions early and provide faster feedback to developers. opo25-80932-ci-and-fuzzing-for-risc-v Edwin Lu en false Video of the talk slides https://conf.gnu-tools-cauldron.org/opo25/talk/SNB8BU/ https://conf.gnu-tools-cauldron.org/opo25/talk/SNB8BU/feedback/ Auditorium B002 (170) Birds of a Feather (BoF) 2025-09-28T11:30:00+01:00 11:30 01:00 The session starts with a brief (15-20 min) presentation on - the motivations and requirements people have communicated for using a forge - what forgejo provides and what's missing - an overview of how existing workflows can gradually migrate to the forge The majority of time will be used to gather feedback from the community. opo25-78097-sourceware-forge-contribution-workflows-with-forgejo Claudio BantaloukasMark J. Wielaard en false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/SBAG78/ https://conf.gnu-tools-cauldron.org/opo25/talk/SBAG78/feedback/ Auditorium B002 (170) Birds of a Feather (BoF) 2025-09-28T13:30:00+01:00 13:30 01:00 The annual opportunity to review and discuss anything about the RISC-V backend. opo25-80831-risc-v-bof Jeremy Bennett en false Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/9NFAJJ/ https://conf.gnu-tools-cauldron.org/opo25/talk/9NFAJJ/feedback/ Auditorium B003 (170) Birds of a Feather (BoF) 2025-09-28T10:30:00+01:00 10:30 01:00 After short updates on vectorizer work from contributors this is the chance to discuss larger work going forward. opo25-75062-vectorizer-bof Richard BienerTamar Christina en false Video of the talk Slides from the BOF https://conf.gnu-tools-cauldron.org/opo25/talk/3SXARL/ https://conf.gnu-tools-cauldron.org/opo25/talk/3SXARL/feedback/ Auditorium B003 (170) Talk 2025-09-28T11:30:00+01:00 11:30 01:00 A proof-of-concept demonstration of a language-independent metadata database to support source-code interrogation and navigation. Such a database could support little-understood source-code analysis and functionality that is not available today at any price. I propose that GCC be extended to produce such a database, probably from the gimple tree, as an affordance to tool developers. opo25-79595-source-code-analysis-and-navigation-the-metadatabase James K. Lowden en Tool development for C++ in particular died on the vine in the 1990s, a victim of industry factors and perception. Today, commonly used tools like *cscope* and *etags* cannot distinguish between `std::find` and `std::map::find`. The *etags* file format was last updated in 1998 and in the introduction to its manual lists _support for C++_ as a desirable feature. Even if these broken tools worked on their own terms, they would still be inadequate. Static analysis can show, for example, everywhere a variable is modified, and where its address is taken so that it _could_ be modified, and the code paths by which that modification is effected. Static analysis can _prove_ that a variable is not modified or a function is not called from some arbitrary module. But no tool does those things. A moment's consideration reveals why: to _analyze_, say, C++, a tool must first _parse_ C++, a famously difficult proposition. For GCC, though, that is a solved problem. Let's externalize what the gcc parsers do, so tool developers can exploit them. false Video of the talk Video of the talk https://conf.gnu-tools-cauldron.org/opo25/talk/SPUUDV/ https://conf.gnu-tools-cauldron.org/opo25/talk/SPUUDV/feedback/ Auditorium B003 (170) Birds of a Feather (BoF) 2025-09-28T13:30:00+01:00 13:30 01:00 A chance to discus upcoming and future work in the GNU toolchain for Arm platforms opo25-75645-arm-aarch64-bof Tamar ChristinaAlex CoplanWilco Dijkstra en false Video of the talk Slides https://conf.gnu-tools-cauldron.org/opo25/talk/B97ARA/ https://conf.gnu-tools-cauldron.org/opo25/talk/B97ARA/feedback/ Auditorium B003 (170) Talk (Short) 2025-09-28T14:30:00+01:00 14:30 00:30 The Memory Tagging Extension (MTE) is a feature of the ARM v8.5 architecture that introduces several hardware capabilities: - Each aligned 16-byte region of application memory can be assigned a 4-bit memory tag. - Every pointer can include a 4-bit address tag in its most significant byte. - An exception is triggered if the address tag differs from the memory tag. - A set of special instructions is provided for efficient tag manipulation. MTE aims to tackle two major issues: buffer overflows and use-after-free errors. It is the responsibility of tools such as compilers, libraries, and assemblers to emit MTE instructions that instrument the code to prevent these errors. This talk outlines the current support (and work in progress) for MTE instructions in the latest GNU tools, including GCC, binutils, and glibc. opo25-80298-notes-about-mte-implementation Claudiu Zissulescu en false Video of the talk Presentation https://conf.gnu-tools-cauldron.org/opo25/talk/9NWN9S/ https://conf.gnu-tools-cauldron.org/opo25/talk/9NWN9S/feedback/