GNU Tools Cauldron 2024

Talks

Adding a new backend to GCC for beginners

Speaker(s): Jeremy Benett

This is an expanded version of the short talk I gave at FOSDEM (https://fosdem.org/2024/schedule/event/fosdem-2024-2713-how-to-bring-up-gcc-for-your-new-chip/). It aims to give potential new contributors a guide to how to add a new back end to GCC. During the tutorial, we will go through all the steps to add a new architecture, VAM, to GCC.

At the end of the talk, the audience should understand all the steps they need to follow to add a new back end to GCC. All the tutorial code is available via GitHub (https://github.com/embecosm/gcc-vam) to act as a template for new back ends.

Borrowing Polonius (Rust GCC)

Speaker(s): Jakub Dupak

Borrow checking is an essential feature of the Rust programming language. This talk presents the initial effort to bring this capability to the Rust GCC compiler. We start by introducing the borrow checking static analysis and its development in the rustc compiler. Then we move over to GCC and go over the current design and state of the implementation of borrow checking using the Polonius project.

CTFv4, the next generation

Speaker(s): Nick Alcock

CTFv3 has been in the GNU toolchain for some time now, other tools use it, and the code has had time to be tested and deployed. So it's time to start thinking about improvements.

One big improvement we are actively working on involves a new format version, v4, in which CTF will be modified and augmented to become a proper superset of the closely related BTF format used by the GNU/Linux kernel; this means that GNU ld will be able to link both BTF and CTF with the same codebase and even at the same time (you will be able to link BTF and CTF together and get either out). In this talk we'll review the main v4 improvements and enhancements and dive into the way we propose deduplication and linking might work.

Debugging Intel GPU Devices with GDB

Speaker(s): Baris Aktemur

Intel recently submitted patches to upstream GDB to enable debugging programs that execute computation workloads on Intel GPUs. The target-specific definitions are provided as a gdbserver target that uses the Level-Zero Debug API. In the proposed approach we utilize GDB's multi-target feature to debug the host application and the GPU workload together in the same debug session. There is one GDB thread for each hardware thread on the GPU device. We opted for this model to avoid a potential proliferation of threads. Hardware threads, however, may be idle from time to time, during which they cannot be interacted with. To handle this case, we introduced an UNAVAILABLE wait kind and also defined a corresponding thread execution state. In this work, we present the overall structure and discuss design decisions.

Elfutils Debuginfod: Project Update

Speaker(s): Aaron Merey

Slides: debuginfod-cauldron2024.pdf

Debuginfod is an HTTP client/server that provides on-demand access to debugging data for debugger-like tools. It is a part of Elfutils, a collection of utilities and libraries to read, create and modify ELF binary files.

Debuginfod was first introduced at Cauldron 2019. Since then, new capabilities and optimizations continue to be added to the Debuginfod server as well Debuginfod clients implemented in tools such as GDB and Valgrind.

In this talk I'll provide an overview of Debuginfod and explore some recent features and improvements to the Debuginfod server and clients. I'll also discuss features currently under development as well as some potential future work.

Enhancements in the CTF Backend of Libabigail for Improved Software Deployment

Speaker(s): Claudiu Zissulescu-Ianculescu

The Compact Type Format (CTF) file format efficiently describes C types and the association between function and data symbols and types, serving as a simpler alternative to the widely used DWARF format. The Application Binary Interface Generic Analysis and Instrumentation Library (ABIGAIL) framework, particularly its core library libabigail, assists developers and software distributors in identifying ABI-related issues, such as interface incompatibilities in ELF shared libraries, through static analysis of ELF binaries. Libabigail supports multiple debug information formats, including CTF, BTF, and DWARF.

This presentation focuses on the latest developments and enhancements in the CTF backend of libabigail. We will discuss the specific improvements made to the CTF backend, highlighting their impact on the efficiency and accuracy of ABI analysis. Additionally, we will demonstrate how these advancements are integrated into our software deployment process, ensuring robust and compatible software distribution.

By exploring the new features and optimizations, attendees will gain insights into the practical applications of libabigail in managing and mitigating ABI compatibility issues, ultimately leading to more reliable software deployment. This session will be of particular interest to developers, software engineers, and system integrators involved in the maintenance and distribution of ELF binaries.

Finding GCC wrong-code bugs with smtgcc

Speaker(s): Krister Walfridsson

Slides: finding-gcc-wrong-code-bugs-with-smtgcc.pdf

The smtgcc plugin performs translation validation on the GIMPLE IR and assembly to identify cases of miscompiled code. The tool uses a formal semantics definition to perform the analysis, but many parts of GIMPLE are underspecified, so a significant part of the development work has involved determining the detailed semantics.

In this talk, we will discuss:

• What kinds of problems smtgcc can find
• How to use it effectively
• Examples of problems encountered when formalizing the GIMPLE semantics

GCC - Rust front end update

Speaker(s): Pierre-Emmanuel Patry

GCC's rust front end aims to compile kernel modules written in rust as supported by the Rust For Linux project. This project does not depend on the standard library but rather on two dependencies of it, "core" and "alloc". Core define a base for the language and define fundamental language items, alloc on the other hand provides the different mechanisms to allocate some memory outside of the stack as well as some handy container types such as vector and hashmap. The latter depends on the former, hence why GCCRS is focusing on compiling core. During the last year we have gathered almost all features required to compile core. This mean we have been able to test almost all those features together in their final environment for the first time. Those tests lead to multiple discoveries and changes in the current design. This talk will address those discoveries as well as future goals for the

Hardware control-flow Integrity for RISC-V

Speaker(s): Kito Cheng

This presentation will explore the newly introduced hardwareControl-Flow Integrity (CFI) mechanisms in the RISC-Varchitecture—Zicfiss (shadow stack) and Zicfilp (landing pad). With modern processors' increasing security demands, CFI has become crucial for protecting systems from control-flow hijacking attacks. This session will particularly focus on the implementation and support of these mechanisms in the RISC-V GNU toolchain.

We will begin with an introduction to CFI, reviewing past software and hardware mechanisms to provide background knowledge. Then, we will present the RISC-V Zicfiss and Zicfilp mechanisms, highlighting their roles in enhancing security.

The discussion will include the labeling issue with landing pads in the Zicfilp mechanism and potential solutions. We will also cover the implementation and support of these mechanisms in the RISC-V toolchain, sharing current progress and future upstream plans.

Finally, we will address integrating these features into various Linux distributions, exploring challenges and solutions. This talk aims to provide RISC-V developers and security experts with insights into these new mechanisms, promoting more secure system design and practices.

Improving GDB support for variable-length registers, with focus on remote debugging

Speaker(s): Thiago Jung Bauermann

Some processors have registers whose size may change during runtime. For example, the size of vector registers defined in AArch64's Scalable Vector Extension (SVE) is given by the SVE vector length — a parameter that can be changed by the running application at its convenience. GDB already supports this when debugging a locally running application, but not when debugging a remote target. This talk examines how the remote target can be extended to support this use case, as well as the corresponding changes needed in GDB's internals and the XML target description. The result is arguably a cleaner way to support variable-length registers compared to the approach currently used for local debugging. Finally, two approaches that were previously proposed on the GDB mailing list will also be briefly described and compared.

Improving upon the modulo scheduler

Speaker(s): Benjamin Priour

Slides: Improving upon the modulo scheduler.pdf

Modulo scheduling is a software pipelining technique relevant for VLIW architectures but not only. Indeed [1] recently demonstrated that modulo scheduling extended with Modulo Variable Expansion can benefits even an out-of-order superscalar processor. Yet Swing Modulo Scheduler (SMS) integrated to GCC since 2004 has been neglected, and many of the TODO points mentioned then still remain today. Therefore here, we (1) review the current state of modulo scheduling in GCC and LLVM; (2) explain how MVE matters in the absence of special hardware support and in the presence of long-latency loads; (3) present how modulo scheduling before register allocation impacts the quality of the schedule, and what has been and can be done to further improve its performance. We conclude by presenting a before/after comparison on a selected set of programs.

[1]: M. Arai et al. Introducing software pipelining for the A64FX processor into LLVM. HPCAsia'24

Integrating librseq into the GNU C library

Speaker(s): Mathieu Desnoyers, Michael Jeanson

Slides: presentation-gnu-tools-cauldron-2024-librseq-glibc.pdf

The librseq project implements helpers for the RSEQ system call, which can speed up various GNU C library interfaces.

The work done to integrate support for the extensible RSEQ ABI opens the door to further integration of librseq into libc, namely the rseq critical section inline assembler implemented in librseq for various architectures, and the CPU-local memory allocator, both of which enable implementation of per-CPU data structures in user-space.

Mid-term larger projects for glibc (take two)

Speaker(s): Florian Weimer

Last year, we talked about larger projects for glibc we could tackle in the medium term. At least we tried to—we spent most of the time discussing development process and Git forge alternatives. This year, I want to come back and revisit actual code-changing projects. This still isn't glibc 3.0 as discussed at Cauldron 2017. Since then, we have merged libpthread into libc, and moved the debugging malloc into a separate shared object, all without switching to glibc 3.0. The purpose of this talk is to look at subsequent larger, mid-term projects for glibc, in areas like performance, reliability, and maintainability.

Next steps for SFrame stack trace format

Speaker(s): Indu Bhagat

Slides: SFrame-Cauldron-2024.pdf

SFrame stack trace format provides the minimal necessary information for generating stack traces on AMD64 and aarch64. After a quick update on the latest developments, in this session, we would like to discuss new feature requests and what lies ahead for SFrame. We will discuss support for further architectures/ABIs, planned for the next version of SFrame. We will also discuss how the format has been designed to support more architectures/ABIs without compromising its compactness and simplicity, showing particular examples.

OpenMP, OpenACC and Offloading in GCC

Speaker(s): Thomas Schwinge, Andrew Stubbs, and Tobias Burnus

Slides: OpenMP-OpenACC-and-Offloading-in-GCC.pdf

An update of the current status of OpenMP, OpenACC and offloading in GCC, including what has been achieved last year. Additionally, an outlook for next year is given of the tasks that are planned or that should be done in the near term.

Optimizing Code Size with the RISC-V Zcmt Extension

Speaker(s): Hau Hsu

The RISC-V instruction set architecture (ISA) continues to gain traction in the embedded systems community due to its open-source nature, extensibility, and simplicity. Among its suite of extensions, the zcmt extension provides oppertunitis in minimizing code size, making it an essential tool for resource-constrained environments. This talk will provide an in-depth exploration of the RISC-V zcmt extension, emphasizing its design, implementation, and the benefits it brings to code size optimization.We will start with an overview of the RISC-V architecture and the motivation behind developing extensions aimed at code size reduction. The main focus will be on the technical aspects of the zcmt extension, detailing its specific instructions, operational semantics, and the advantages it offers in terms of reducing the footprint of compiled code.Key topics to be covered include:

Motivation and Design: Understanding the need for the zcmt extension in the context of embedded systems and the design principles that guided its development. Instruction Set and Semantics: A thorough examination of the instructions introduced by zcmt, their functionalities, and how they contribute to code size reduction. Implementation: Insights into how the zcmt extension integrates with RISC-V cores, including necessary changes to the toolchain, compiler, and assembler to support these new instructions. Code Size Analysis: Practical examples and benchmarks demonstrating the impact of zcmt on code size, showcasing significant reductions and the scenarios where these savings are most beneficial. Future Directions: Discussion on the potential future enhancements and developments within the RISC-V ecosystem that can further leverage the zcmt extension.

This session is tailored for software engineers, embedded systems developers, and researchers interested in the latest advancements in the RISC-V ISA, particularly those focused on optimizing code size for embedded applications. Attendees will gain a comprehensive understanding of the zcmt extension and learn how to apply it to achieve more efficient and compact code.

Profiling framepointer-less code with elfutils stacktrace

Speaker(s): Serhei Makarov

Slides: profiling-stacktrace.pdf

The omit-frame-pointer optimization has been a widespread compiler default. Recent requests to disable it in Linux distributions are motivated by commonly-used profiling tools only being able to unwind stack traces for programs compiled with framepointers. This has led to a conflict of priorities between users who want profiling and users who have no plans to profile their systems and don't want a performance regression.

Is it possible to relieve this conflict? Call-frame information (CFI) is provided in .eh_frame format for most compiled code, and the elfutils toolkit has a CFI unwinding implementation that does not require framepointers. Only a few things are missing to make this implementation easy to access.

In this talk I will compare the relative merits of framepointer and call-frame information unwinding, and review some recent discussions around disabling framepointer optimizations. I will also present eu-stacktrace, a tool for the elfutils project that unwinds a stream of stack samples on behalf of another profiler. The eu-stacktrace prototype integrates with the sysprof sampling profiler, and the goal is for any profiling tool that relies on perf_events callchain data to be easily adapted to work with eu-stacktrace.

SLP-only vectorization - present and future

Speaker(s): Richard Biener

Slides: 2024-Cauldron-vectorizing-with-SLP-only.pdf

An update about the vectorizer refactoring to solely rely on SLP as data structure to perform vectorization.

Status update on GCC security features for the Linux kernel

Speaker(s): Qing Zhao

Multiple security features for the Linux kernel have been added into GCC releases since GCC11, including "zero call-used registers at return" (GCC11), "stack variables auto-initialization" (GCC12), "treating flexible array members in a stricter way" (GCC13), etc. These features have been actively used by the Linux kernel to improve its security for several years.

In this talk, we will focus on several most recent features in this area (in GCC14 and GCC15) First, I provide a status update on the task list including most-wanted security features for the Linux kernel from last year.

• The first group includes several items relating to flexible array members (FAM), such as, supporting "structures with FAM nested in other structures", supporting "FAMs in unions", and "a new attribute counted_by for FAMs". All these items are finished and committed into GCC14 and GCC15. - The second group includes items that reduce false positive warnings for -Warray-bounds. Most of the items are fixed, one item has been further discussed and agreed on. Instead of a GCC false positive, it's a real kernel bug. Kernel patch has been submitted to fix this bug. At the same time, GCC need general improvement in this area to provide more contexts information to the users when issuing warnings. The GCC work is ongoing.
• The third group includes several items about arithmetic overflow protection, including new unsigned overflow detection, improvement to signed integer overflow handling, etc. Some more discussion on this area, not too much real progress. CLANG has made bigger progress in this area, GCC might need catch up.
• The last group is kernel control flow integrity (KCFI), which is a big but important security feature, wanted badly by the Linux kernel. More discussion but no real progress yet.

Then, More details are given on multiple interesting items that have been done within this year or are ongoing right now.

• The implementation of counted-by attribute for FAM in GCC15.
• Extend counted-by attribute to pointers inside structures or pointer arguments of a call.
• Improvement to GCC diagnostic to provide more hints of compiler code duplication to end user in order to help users to locate the error accurately in their code.

The talk concludes with a sketch of future work and further improvement in this area.

Talk about unCSE

Speaker(s): Segher Boessenkool

I'll explain the transformation, what its benefit is, what other things (in combine) it makes superfluous, etc. Maybe future directions as well, if enough experience with it shows up soon enough

Update on GNU poke and the integration with GDB + hardware demo

Speaker(s): Mohammad-Reza Nabipoor

We begin with a status report on GNU poke. Next, we will look at the new garbage collector that the GNU poke uses in place of the Boehm GC. At the moment, Boehm GC interferes with the Guile integration, causes problems for the GDB integration. This migration takes care of the problem.

Then GDB integration will be presented in the context of poking a micro-controller over GDB. Using live examples, we will discuss the GNU poke strength for describing the hardware and strategies for using it for testing and verification.

Using the Valgrind error manager for file descriptor tracking

Speaker(s): Alexandra Petlanova Hajkova, Mark J. Wielaard

The valgrind error manager makes it easy for valgrind tools to report issues that can include execution backtraces for multiple events, integrate with gdb, generate xml reports and lets users suppress specific issues. The valgrind error manager contains a fast unwinder which can be used to detect "equivalent" issues.

For valgrind 3.23.0 we introduced "core errors" which are tool independent and can be used to report on core events for resources that are explicitly created and destroyed. We used this to add errors when using file descriptors that can be reported by any valgrind tool by using --track-fds=yes. This allows reporting on bad use of file descriptors, file descriptors that are double closed, used after closing, and file descriptors that "leak". Because these are "normal" valgrind errors all these events can be reported in the xml output, suppressed by the user, intercepted by gdb and integrated in CI runs with --error-exitcode.

Slides: valgrind-cauldron24.pdf

Waste-Free Per-CPU Userspace Memory Allocation for the GNU C Library

Speaker(s): Mathieu Desnoyers

Slides: presentation-gnu-tools-cauldron-2024-rseq-mempool.pdf

Introduce the librseq per-CPU user-space memory allocator. It implements concepts similar to the Linux kernel percpu allocator in userspace, and thus reduces waste of per-CPU data structures hot cache lines by eliminating padding usually required to eliminate false-sharing, and in addition tackles issues that arise from resident memory waste when restricting processes with scheduler affinity or cpusets.

It is a good fit when used with data structures indexed by either CPU ID or per-process concurrency ID, both available through the RSEQ ABI since version 2.35 of the GNU C Library.

Discuss how this memory allocator could benefit the GNU C library.

What is new in the BPF support in the GNU Toolchain

Speaker(s): Jose E. Marchesi, David Faust, Cupertino Miranda

Slides: cauldron2024-bpf.pdf

After four years of intense development we recently reached a very important milestone in the support of BPF in the GNU toolchain. The toolchain can now compile all the Linux kernel BPF selftests, and more than 80% of the resulting test cases run and pass in the kernel. This means that GCC is capable of generating verifiable compiled BPF code for the vast majority of the selftests. Considering that the goal of the kernel selftests are basically to serve as a model of real BPF programs, and that they focus on the trickiest and "hackiest" aspects of it, we can declare that the GNU support for BPF is ready for serious usage.

In this presentation we will first provide an update on the status of the support of the always evolving and tricky BPF technology. We'll describe the port, in all its components, discuss recent developments, our interactions with the kernel community and participation in the BPF standardization process. Then we will describe the current work in progress, and will bring forward for discussion a set of new BPF features which are experimental and still under discussion in the kernel community. Finally, we will discuss the best way to maintain the BPF port, since there are some unusual requirements due to the peculiarities of the target. We aim to avoid the current situation in llvm/clang, where users are often stuck with the need for one particular compiler version per kernel per compiled program.

What's new with diagnostics in GCC 15

Speaker(s): David Malcolm

I'll be talking about developments in GCC 15:

• those affecting GCC's diagnostic subsystem, and
• those affecting the static analyzer (-fanalyzer)

Slides: 2024-Cauldron-diagnostics-talk.pdf

Lightning Talks

ASMGraph: Coverage-based performance evaluation tool

Speaker(s): Jivan Hakobyan

In this talk, I will present the ASMGraph tool, which can evaluate and highlight weaknesses in assembly code generation. It graphically shows each function’s control flow and colorizes every BB according to its execution count (from coolest to hottest). The tool can provide a function-level comparison of two evaluation results for the same benchmark, run with different compiler versions (base and peak). In addition, it has a plugin mechanism that allows to add various checkers and instruction pattern matchers. For example, for optimization purposes, specific combinations of instructions are of interest.

GCC machine description for the CRAY architecture

Speaker(s): Toon Moene

Linaro CI status update (Lightening talk)

Speaker(s): Christophe Lyon

Slides: Linaro CI status update GNU Cauldron 2024.pdf

In this talk, I'll quickly show: - examples where multi-component CI detected bugs in component A after a new commit in component B - regression detection statistics / trends over the past year - dashboards showing the pass/fail evolution

Measuring GCC Performance

Speaker(s): Jeremy Benett

In this talk I will look at how we can measure the performance of GCC in the widest sense (code size, code speed, energy consumption...). I will look at the use of SPEC CPU benchmarks for GCC on application class processors and the use of Embench benchmarks for deeply embedded microcontrollers.

The talk will be illustrated by the results from benchmarking the RISC-V vector extension GCC. I will look at:

• the targets that can be used for benchmarking: both physical and simulated
• comparing GCC performance for different architectures
• comparing GCC against LLVM
• using performance measurement to improve optimization
• If slots are tight, I can compress this talk to a shorter version that would fit in a lightning talk.

OpenScanHub: A Brief Introduction

Speaker(s): Siteshwar Vashisht

OpenScanHub is a service for static and dynamic code analysis. It uses the static analyzers embedded in GCC and Clang, Cppcheck, ShellCheck, find-unicode-control, and the Gitleaks tool. This talk would be a brief introduction about how developers can use this service to find bugs in the code.

BoFs

Arm/AArch64 BoF

Speaker(s): Richard Earnshaw

a chance to discus upcoming and future work in the GNU toolchain for arm platforms

avoiding (or not) the gas "pre-processor"

Speaker(s): Jan Beulich

There is gas'es -f option and the #APP / #NO_APP "protocol", yet it looks to be largely unused. I wonder whether that's for reasons other than just being broken (to some degree) in gas and/or gcc right now, and hence whether there would be (assumed) incentive to making it work properly. Seeking input (i.e. perhaps also historical aspects) and other thoughts.

BoF on OpenMP, OpenACC, and Offloading

Speaker(s): Tobias Burnus, Thomas Schwinge, Andrew Stubbs, and Jakub Jelinek

Slides: BoF-on-OpenMP-OpenACC-and-Offloading.pdf

Discussion of topics related to concurrency and offloading work onto accelerators and, in particular, implementation of the remaining OpenMP 5.x features and the upcoming OpenMP 6.0 release, of newer OpenACC features, and improving the performance especially for offloading. But also topics like supporting offloading from ARM or RISC-V hosts, improving the documentation and diagnostic, the relation of OpenMP and base-language parallelization.

Additionally, related topics and trends can also be discussed, be it base language concurrency features, offloading without using OpenMP/OpenACC, or other accelerators.

SIMD lane support in GDB for GPUs

Speaker(s): Baris Aktemur, Lancelot Six

GPU threads operate in Single Instruction Multiple Data (SIMD) 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. Two downstream debuggers "Intel Distribution for GDB" and "AMD ROCm Debugger (ROCgdb)", implement SIMD lane support. In this session we compare and contrast the design decisions of the two approaches with the goal of progressing towards a unified SIMD lane support in upstream GDB.

Bof: Sourceware infrastructure tips & tricks

Speaker(s): Sourceware Project Leadership Committee, Elena Zannoni, Mark J. Wielaard, Ian Kelling

Sourceware has provided the infrastructure for the core toolchain and developer tools for more than 25 years. The last couple of years it has transformed from a purely volunteer into a professional organization with an eight person strong Project Leadership Committee, monthly open office hours, multiple hardware services partners, expanded services, the Software Freedom Conservancy as fiscal sponsor and a more diverse funding model that allows us to enter into contracts with paid contractors or staff when appropriate.

The Sourceware services are loosely coupled, but developers become most productive when they combine them. So lets exchange tips and tricks on how using bugzilla and cgit, b4 and public-inbox, git-pw and patchwork, the snapshot builders and manual generation, wikis, buildbot and try-bots, ci-bots, full-builds and the bunsen testresults database, make you most productive.

Lets also discuss the recent "Cybersecurity" regulations, how Sourceware prepared and what policies projects could adopt to improve their secure software development framework.

https://sourceware.org/mission.html#services https://sourceware.org/sourceware-25-roadmap.html https://sourceware.org/sourceware-security-vision.html

BoF-topics: bof.txt BoF-notes:'' bof-notes.txt

glibc BoF

Speaker(s): Carlos O'Donell

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.

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.41 and what work needs to be done between September 2024 and February 2025.
• Planning for glibc 2.42 and what work needs to be done between February 2025 and August 2025.
• Adopting month-to-month feature planning
• Security hardening strategies
• Status of pthread condvar signal stealing bug (again)
• Status of static linking support
• Status of Patchwork pre-commit CI/CD for glibc.

... and more.

GNU Binutils BOF

Speaker(s): Nick Clifton

LTO/IPA/Profile feedback BoF

Speaker(s): Jan Hubicka

Patch review and maintenance BoF

Speaker(s): Richard Earnshaw

are we making the best use of modern methodologies for reviewing and integrating patches? How do we improve community engagement by encouraging new developers on the path to maintainership?

PowerPC/Power/rs6000 BoF

Speaker(s): Peter Bergner, Segher Boessenkool, Kewen Lin

RISC-V BoF

Speaker(s): Kito Cheng Jeff Law, Jeremy Bennett and Palmer Dabbelt

Join us for an in-depth discussion on all aspects of the RISC-V toolchain. This BoF session will cover the latest features introduced in GCC 15 and delve into the support for new ISA specifications within the toolchain. Attendees can share their experiences and discuss future directions for RISC-V toolchain development!

The GDB BoF

Speaker(s): Pedro Alves

An opportunity for the GDB community to meet to discuss all things related to the GNU Debugger project.

Toolchain and Linux kernel BoF

Speaker(s): Steven Rostedt, Jose E. Marchesi

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 shortly after Cauldron.

Toolchain Licensing BoF

Speaker(s): Bradley M. Kuhn, Denver Gingerich

The GNU toolchain projects are not only the showcase for the most excellent toolchain software ever written. They are also the showcase of the inventive licensing structure known as copyleft. The toolchain community is often at the forefront of licensing questions and concerns.

This BoF session will be an open discussion about many of the questions/concerns that were raised in the hallway track of last year's Cauldron (and elsewhere in community discussions). Discussion will include any additional topic that toolchain maintainers and hackers may be interested in discussing.

Some examples of items raised at last year's Cauldron that will be discussed include:

• How do we improve handling of GFDL/GPL incompatiblity when we want to mix code and docs easily?
• Do contribution policies need to change (such as listing of copyright notices) when I make a DCO-based contribution that isn't FSF-assigned?
• How does a DCO actually work and why is it safe? (It is, but knowing why is important)
• What are some best practices for code-sharing between GNU projects that require assignment to the FSF and ones that don't?
• How can I explain that complicated GCC RTL Exception to mere mortals?
• How do we handle licensing compatibility with plugins, particularly for GDB?

The FSF was consulted in the preparation and submission of this BoF and endorses it and its moderators. The FSF encourages the toolchain community to have frank discussion about these and related issues and pass along feedback to the FSF on these topics.

Vectorizer BoF

Speaker(s): Tamar Christina, Richard Biener

A discussion of short and long term improvement plans for the vectorizer post SLP transition.