GNU Tools Cauldron 2023

THIS PAGE IS AUTO-GENERATED, DO NOT MODIFY BY HAND

THIS PAGE IS AUTO-GENERATED, DO NOT MODIFY BY HAND

Talks

Updates to diagnostics in GCC 14

Author: David Malcolm

Slides:: 2023-Cauldron-diagnostics-talk.pdf

• ideas for revamping how we present C++ template errors to the user
• GCC's new ASCII art capabilities

• what's new in -fanalyzer for GCC 14

Undefined behaviour and its treatment within GCC

Author: Richard Biener

ISO C23 support in the GNU Toolchain

Author: Joseph Myers

Slides: ISO C23 support in the GNU Toolchain.pdf

The next revision of the ISO C standard, C23, is expected to be released in early 2024. This talk will discuss some of the main new features of this standard and the state of support for them in the GNU Toolchain, mainly GCC and glibc.

Defining security policies for GNU Toolchain projects

Author: Siddhesh Poyarekar

GCC, binutils, glibc, GDB and others are ubiquitous in the Linux ecosystem and as a result, are common targets for security research. This is a great thing because more security research means a better, hardened GNU toolchain. However, given the nature of these tools, it is far too easy to misconstrue bugs as security issues.

In this talk, I try to set the context for this problem and the steps that we have taken in the community to define a security policy for projects so that there is a better understanding of what constitutes secure usage of these tools.

Improving Scalability by Leveraging the Linux RSEQ System Call

Author: Mathieu Desnoyers

The main purpose of this talk is to present common RSEQ critical sections and membarrier fence patterns allowing implementation of fast per-cpu data structures in assembler.

The RSEQ system call allows the Linux kernel to share thread information with user-space through per-thread area, e.g. scheduling state (running vs preempted), which can be used to improve adaptative mutexes. Discuss the impact on the user-space pthread mutex implementation and brainstorm other possible use-cases.

RSEQ exposes a new "concurrency ID" field since kernel v6.3. This field exposes a current ID number for which allocation scales with the number of threads running concurrently. Discuss the impact of this feature on scaling per-cpu data structures.

Finally, discuss the extensible RSEQ ABI and its eventual support in GNU libc.

gprofng: One year later

Authors: Ruud van der Pas, Vladimir Mezentsev, Kurt Goebel

Slides: gprofng One year later.pdf

At Cauldron 2022 we presented gprofng, the new GNU profiling tool that is part of binutils, for the first time.

Since then, and outside of bug fixing, there have been quite some new developments in various areas.

In this talk we start with a short refresher about gprofng. This is followed by an overview of the main improvements and some of the choices we have made.

One of the major new features has been the release of the GUI. It is available on savannah.gnu.org and we plan to include a demo as part of the talk.

Next, we present an overview and discussion of the test suite that we have created. There are several challenges to design robust tests for a tool like gprofng. Not only do we need to test the various tools that are part of gprofng, but some of these tools have a set of commands that need to be tested.

Another issue to deal with is that the results are platform dependent and by nature of the sampling that gprofng does, the timings and other sampled values are not 100% reproducible. As a result, a straightforward diff is not very meaningful as a way to verify correctness.

We conclude with an overview of our plans for new developments.

AArch64 Performance improvements for GCC 14 and GCC 15

Author: Tamar Christina

Slides: AArch64 Performance goals GCC 14.pdf

For SVE and AArch64 we have several performance and codegen improvements planned. Some of which will take more than one GCC version to implement. This includes improvements to both scalar and vectorized codegen. Most of it will be generic improvements.

This talk will go over the big ticket items and present our plans so that others working in the area are aware and discuss any issues the community has seen in these areas.

GCC Rust Update

Authors: Philip Herron, Arthur Cohen, Pierre-Emmanuel Patry

Slides: GCC Rust Update.pdf

This talk will provide an overview of the status of the compiler and the challenges and milestones we are aiming for.

Integration CI of GNU Toolchain

Authors: Maxim Kuvyrkov

We are going to present an approach and talk about implementation of GNU Toolchain CI at Linaro. This CI tests tip-of-trunk Binutils, GCC, Glibc, GDB, and automatically bisects testsuite regressions down to a single a single commit.

Benchmarking CI and automated result analysis

Authors: Maxim Kuvyrkov

We are going to present Benchmarking CI with automated result analysis and discuss challenges in its implementation, approaches to dealing with hardware noise, and processing of results.

GDB and Valgrind integration

Authors: Alexandra Petlanova Hajkova, Mark J. Wielaard

Slides:: gdb-valgrind-cauldron.pdf

Using the GDB remote protocol to create a local interactive debugger experience for programs running under Valgrind.

Valgrind has had an embedded GDB server (which is a fork of the GDB gdbserver) since version 3.7.0 (released in 2011). It needs a helper process, vgdb, to talk to GDB.

The GDB remote protocol was designed for remote debugging. This makes it a bit cumbersome to use for local debugging under valgrind. You had to run valgrind and gdb in separate terminals for example. And needed to start valgrind in a special mode first before connecting to it, through vgdb, with gdb.

In this talk we want to discuss some tricks we implemented in valgrind and gdb to make the whole experience feel more like local debugging. And show some issues we encountered for which we don't yet have a satisfactory solution.

For vgdb we implemented --multi mode, so vgdb and gdb can talk the extended remote protocol. Which lets GDB start a new (valgrind) process through vgdb from inside the GDB session. This works to make the session feel more local. But the way error handling works in the remote protocol makes it sometimes difficult to give good feedback to the user when something goes wrong. Also, although we are using the remote protocol we like to use the local file system ('set sysroot /'). And depending on the setup used by the user, passing around the environment and current working directory, might be a challenge. Some extensions to the remote protocol might be helpful in these cases.

Another challenge is handling stdin/stdout for communication between gdb and vgdb. When starting a (local) remote process in stdio mode, through target extended-remote | vgdb --multi, the inferior process cannot simply use stdin/stdout itself without interfering with the remote protocol packets. stdout can be redirected to stderr like gdb gdbserver currently does. But stdin handling is trickier. We are experimenting with various ways to split the file descriptors to be used for the remote protocol and those used for the process stdin/stdout. But we will also have to deal with terminal session handling if we want to allow the (remote) local process to use stdin.

OpenACC, OpenMP, Offloading and GCC

Authors: Thomas Schwinge, Andrew Stubbs, Tobias Burnus

Slides:: OACC-OMP-Cauldron23.pdf

A short update on 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.

A deeper look is then taken into implementing C++ and libstdc++ support for offloading regions - and into the challenges and achievements of improving the AMD GCN offloading support with focus on performance and on vectorization.

Most-wanted Security Features in GCC for Linux Kernel

Author: Qing Zhao

Slides: Most-wanted Security Features in GCC for Linux Kernel.pdf

Multiple features have been added to the latest GCC releases to support security improvement in the Linux kernel. These include "zero call-used registers at return", "stack variables auto-initialization", __builtin_dynamic_object_size support, "treating flexible array members in a stricter way", etc. These features are already being used by the Linux kernel to improve its security.

This talk will focus on several recent and most-wanted security features for the Linux kernel.

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".

The second group includes items that reduce false positive warnings for -Warray-bounds, which are important for the Linux kernel to turn on -Warray-bounds by default.

The third group is kernel control flow integrity (KCFI), which is a big but important security feature, wanted badly by the Linux kernel.

Other items include new unsigned overflow detection, and improvement to signed integer overflow handling, etc.

In the talk we will provide a high-level overview of these most-wanted security features by the Linux kernel. This includes a description of the motivation, major challenges during design and implementation, current status of the features, and existing known issues. We also seek suggestions for the solutions of some of the items, for example, the second group. The talk concludes with a sketch of future work and further improvements of these security features under consideration.

Exposing Complex Numbers to Target Backends

Authors: Sylvain Noiry, Paul Iannetta

Slides: Exposing Complex Numbers to Target Back-ends (slides).pdf

Paper: Exposing Complex Numbers to Target Back-ends (paper).pdf

Complex numbers are used to describe many physical phenomenons and are of prime importance in data signal processing. Nevertheless, despite being part of the C and C++ standards since C99, they are still not completely first class citizens in mainstream compilers. This can be explained by the fact that most general purpose instruction sets did not have hardware support for complex operations for a long time. Here, we

1. review the current state of complex numbers in GCC and LLVM;
2. explain why supporting complex numbers in a generic and extensible way that can be finely tuned for each architecture is important;
3. present a framework which extends complex numbers support in GCC, and allows each target to specify how complex numbers should be lowered, how they can be vectorized, and how operations on complex number should be mapped to assembly instructions.

We conclude by presenting a before/after comparison on a selected set of programs and suggest some ideas to improve the framework that we would like to consider next.

Catching defects in core components with massive rebuilds

Authors: Frédéric Bérat, DJ Delorie, Carlos O'Donell

The core components in a distribution, like gcc, glibc, autoconf, automake, etc are at the root of the dependency graph and therefore have a large impact when rebased to newer versions. This talk covers the strategy of using existing services to automate mass rebuilds during integration to evaluate the risk of breakage. We review the evaluation of Autconf 2.71 and the unreleased 2.72, along with Make 4.4, libffi 3.4, and various version of glibc. We discuss the differences between the current startegy and a pre-production build pipeline, and why we think this strategy has benefits over the latter. Lastly we cover current development in the mass prebuilder and future directions.

The challenge of compiling for verified targets

Author: Jose E. Marchesi

Slides: The challenge of compiling for verified targets.pdf

The Linux kernel BPF is not a sandbox technology: BPF programs do not rely on a sandboxed environment for security, and in fact they are executed in the most privileged kernel mode. Instead, BPF programs are known to be safe before they are executed. It is the job of the kernel verifier to determine whether a given BPF program is safe to be executed, and to reject it if that cannot be determined. Conceptually speaking, an entire BPF program should be as predictable as a single machine instruction. Obviously, this cannot be achieved for any arbitrary BPF program given that the BPF ISA is turing-complete, and so the verifier imposes quite draconian restrictions on the programs to make sure they always terminate, among other things.

BPF programs are sometimes written by hand, but as more kernel subsystems are being expanded to use BPF, the programs are getting bigger and more complicated, and hackers prefer to write BPF programs in high level languages like C or Rust and compile them to BPF object code using an optimizing compiler. Both the GNU Toolchain and clang/llvm provide BPF support.

In ordinary targets the main challenge of the compiler is to generate the optimal[1] machine instructions that implement the same semantics than the program being compiled. In verified targets (like BPF) there is an additional and very important challenge: the generated machine instructions shall be verifiable. While this cannot be guaranteed for every input program, ideally the optimizing compiler shall inform the user if the input program contains source language constructions that inexorably would lead to not-verifiable code, and shall also adjust the optimization passes in order to avoid transformation that lead to non-verifiable code. The better the compiler does this, the more practical compiled BPF will become.

It is not clear how to achieve this. In this talk, we will first state the problem and then examine different alternatives and potential techniques and strategies, some of them already tried by the clang/llvm BPF port with variable success: IR legalization, usage of the static analyzer, verification in assembler, usage of counter-passes vs. pass tailoring (-Overifiable), usage of annotations in source code, tailoring of the front-ends (BPF C), etc. Also we will analyze and discuss the impact that each strategy would have to the rest of the compiler.

Note that this problem is not specific to the GNU Toolchain. Whatever techniques get developed will also serve to the clang/llvm compiler. We will be touching base with them during the LPC conference in November this very year.

[1] Given some criteria like execution speed, or compactness.

Synthesizing Call Frame Information for hand-written asm

Authors: Jose E. Marchesi, Indu Bhagat

Slides: scfi_cauldron2023_final.pdf

Call Frame Information (or CFI) is the metadata that accompany executable object code. It is used to perform virtual stack unwinding / stack walking at any point of the execution of that code. When available, the CFI information can be found in dedicated sections in the object files. There are several formats available which encode this data: SFrame stack trace format, EH Frame, etc.

The compiler can generate the CFI annotations, completely and accurately. However, there are scenarios where assembly language sources are written (and maintained) by hand. In some cases, these hand-written sources can be large. In hand-written assembly programs, CFI annotations are either added by hand or, what is more usual, completely absent. Annotating assembly language programs with CFI is not an easy task, and maintaining them as the code evolves is time consuming and error prone.

Some applications, like the Linux kernel, use their own, in-house tools to post-process compiled object codes, and reverse-engineer the CFI. The reverse-engineering process uses knowledge about the architecture and the ABI to infer the frame structure from the instructions. This approach works, but it is neither scalable nor easy to maintain.

We are working to add support to the GNU assembler for synthesizing CFI information from the programs being assembled. We believe this will add value to the GNU Toolchain. The proposal is to make the assembler to "understand" some of the instructions it assembles, with the collaboration of the target code. This infrastructure can also be used as a foundation for developing other features in the future, such as certain optimizations and program verification.

In this talk we will discuss the design together with the infrastructure we are adding to the assembler, how existing GAS targets can be modified to make use of it, and a little discussion on future functionality that can use this work as a foundation.

Improving loop optimization with histogram profiling in GCC

Authors: Ondřej Kubánek, Jan Hubička

Slides: Improving loop optimization with histogram profiling in GCC.pdf

This presentation showcases the progress made in GCC, achieved by improving Profile-guided optimization (PGO). Our research introduces a novel profile counter, tailored to enhance loop optimizations. As a result, we achieve notable enhancements in loop peeling and loop versioning techniques, directly translating to improved performance at a reasonable cost. This further enables auto-vectorization improvements.

Update on BPF target support in the GNU toolchain

Authors: Cupertino Miranda, David Faust

Slides: bpf-update-GNUCauldron2023.pdf

BPF is a virtual machine that resides in the Linux kernel. Originally intended to allow user-written packet filtering rules to run in kernel context (the name is an acronym for Berkeley Packet Filter), BPF has grown significantly into a general-purpose infrastructure used also for various non-networking purposes, such as tracing. With this growth came a desire by BPF programmers to write programs in C rather than hand-written bytecode, so we added support for this virtual architecture to the GNU toolchain.

In this talk we will show and discuss recent developments related to the BPF target. This includes a significant rewrite of the binutils port to better suit the continually evolving architecture, support for the new ISA v4 instructions, support for the pseudo-C assembly syntax used in LLVM and the kernel in both GCC and binutils, major improvements to BPF CO-RE support, and several improvements and additions to the BTF debugging format used for BPF programs. Usability has also improved, with the BPF toolchain being packaged in various distros, and also added to the Compiler Explorer.

We will conclude with an overview of the current status of the port, and a discussion of future work and plans for further improving support for the BPF architecture in the GNU toolchain. Plans for future work include fully supporting all kernel selftests, ensuring that compiler-emitted code can actually be loaded and run under the kernel's strict requirements, and improving the simulator (included in the port) to simulate all kernel BPF helper functions and associated state.

20 years CFG profile in GCC

Author: Jan Hubička

Slides: 20 years of CFG in GCC.pdf

The original infrastructure for representing profile in control flow graph was implemented 20 years ago as a student project of Zdeněk Dvořák, Pavel Nejedlý, Josef Zlomek and myself. I plan to cover a bit of history, the lessons learned from the first implementation and changes made 6 years ago with the introduction of new profile count and profile probability classes as well as ongoing work.

Sensitive part of profile infrastructure is code keeping the profile up to date across the whole optimization pipeline. All passes doing modification to CFG are also responsible to update profile. This stage 1 I am trying to get updates to better shape with approx 50 bugs fixed so far. I would like to give short tutorial on how you can implement profile update in your awesome new optimization pass. How you can figure out if something goes wrong for a bad reason and when profile needs to be left inconsistent. I also show some benchmarks showing why keeping profile up-to-date matters.

Mid-term larger projects for glibc

Author: Florian Weimer

A lot of time has passed since we talked about glibc 3.0 at the 2017 Cauldron. Since then, we have merged libpthread into libc, and moved the debugging malloc into a separate shared object. It was possible to do this without glibc 3.0 after all. The purpose of this talk is to look at subsequent larger, mid-term projects for glibc, in areas like performance, reliability, and maintainability.

Incremental LTO in GCC

Author: Michal Jireš

This talk introduces new implementation of incremental LTO and shows achieved compile times improvements. The incremental LTO is implemented by caching the parallel LTRANS stage of LTO.

The focus of the talk is the exploration of cache misses caused by needless divergence and how they are/can be mitigated. Included are divergence of: new partitioning strategy, debug information, global counters, order of symbols, order of inlining, and few more.

Analyzing GIMPLE IR and Assembly Using SMT Solvers

Author: Krister Walfridsson

Slides: Analyzing GIMPLE IR and Assembly Using SMT Solvers.pdf

In this talk, I'll present an overview of "smtgcc", which is the next generation of my "pysmtgcc" tool for translation validation.

The tool transforms GIMPLE IR or assembly to the SMTLIB format that can be used to analyze the code.

The way I have used it so far is to do translation validation in order to automatically find miscompilations, but there are other use cases, such as writing better test cases, finding missed optimizations, etc.

The talk will describe

• How the tool work
• What kind of issues it can find, and to use it
• Experiences with using it to find bugs
• Limitations and possible improvements.

Lightning Talks

Session Chair: Jose E. Marchesi

Modula-2 the road ahead!

Author: Gaius Mulley

Slides: Modula-2 the road ahead.pdf

Lightening talk on the status of the Modula-2 front end. The talk will briefly mention the linking re-implementation, timeout fixes and new static analysis checking. The static analysis understands NEW/DISPOSE semantics and will check for NIL pointer violation. It also checks for uninitialised record field accesses. Future enhancements to static analysis will be discussed.

The talk will give an update about the progress on re-implementating long sets and will conclude with future list of language features to be implemented. ISO (part 2) Modula-2 generics, ISO (part 3) Modula-2 generics and Modula-2 R10.

GCC - CRC optimization

Author: Mariam Arutunian

Slides: GCC CRC optimization.pdf

My talk is about optimization of Cyclic Redundancy Check (CRC) computations to accelerate execution, which has already been implemented in GCC. The main idea is to identify CRC code snippets in user programs and replace them with more effective alternatives. The identification process involves a two-stage algorithm, where potential CRC code parts are first detected, and then verified using symbolic execution. As an effective alternative to the discovered CRC code, we use two algorithms. One algorithm is specifically designed for scenarios with hardware support for Carry-Less Multiplication (CLMUL). The second algorithm is a table-based CRC implementation, used when CLMUL support is unavailable.

GNU Binutils Support for the SPARROW SIMD AI Accelerator

Authors: Marc Sol´e Bonet, Leonidas Kosmidis

Slides: GNU Binutils Support for the SPARROW SIMD AI Accelerator.pdf

Recently there is an increased interest in space missions to use artificial intelligence algorithms. However, they are too computationally intensive for the simple, but qualified processors used in space. On the other hand, using accelerators like GPUs is not an option due to the lack of radiation-hardened AI accelerators. For this reason, we have designed a SIMD-unit with very low resource consumption, which can accelerate such tasks in qualified space processors, such as Cobham Gaisler’s RISC-V based NOEL-V, and SPARC based LEON3. In this talk, we provide the details of adding support for this SIMD-unit to GNU Binutils, used both by Gaisler’s GCC-based qualified compilers for these processors (NCC and BCC respectively), as well as in the space-qualified RTEMS real-time operating system.

SPARROW, our SIMD micro-architecture, follows a novel vector design by reusing the integer register file of the processor. This allows us to operate on 8-bits components within each register, which has been shown in the literature that is sufficient for inference applications [6]. The module pipeline is divided in two stages, for parallel computation and reduction operations respectively. Each of these stages can be used independently or combined to perform more than 200 different instructions, including signed and unsigned arithmetic and saturation. More details on the hardware implementation of the module were presented in [4] and [5]. The work, which corresponds to the speaker’s Master’s Thesis, is open source [3] and won the Xilinx Open Hardware 2021 competition in the Student Category [7]. Furthermore, SPARROW has been selected as an accelerator for the open source, RISC-V based METASAT platform, which is being developed in the METASAT project, funded by the European Commission [2] [1].

In this presentation we will focus on the GNU software support for this unit and how using binutils can allow new developers to achieve similar support in an easy way. We will present a brief overview of the module and the modifications we performed in the SPARC and RISC-V ISAs to include assembly support for the new SIMD instructions in the SPARC and RISC-V GCC backends. We will explain how we addressed the fact that each instruction can execute two independent operations over the two pipeline stages and the encoding of 5-bit immediate operands with the most common values for machine learning applications, such as powers-of-two or powers-of-two minus one. Moreover we will mention how to be able to use the compiler support also in a real-time operating system like RTEMS. Finally, we will cover our approach to offer a SIMD intrinsics-like programming interface to ease programming and present some performance results

Cpychecker as a GCC static analyzer plugin

Author: Eric Feng

Lightning talk on a new experimental GCC static analyzer plugin for CPython extension module code, aiming to reintroduce the features of the erstwhile Cpychecker. I will briefly discuss its current features, such as reference count checking and memory leak detection for PyObject* objects, and conclude with insights into future development.

BoFs

GNU Toolchain Q&A

Hosts: David Edelsohn and members of the various toolchain steering groups

Slides: GNU Toolchain QnA 2023.pdf

Your chance to ask general questions about the GNU Toolchain projects.

OpenMP/OpenACC/offloading BoF

Hosts: Tobias Burnus, Thomas Schwinge, Andrew Stubbs, and Jakub Jelinek

Slides:: BoF_on_OpenMP_OpenACC_Offloading_Cauldron_2023.pdf

Discussion of topics related to concurrency and offloading work onto accelerators and, in particular, implementation of the remaining OpenMP 5.x features, of newer OpenACC features, and improving the performance especially for offloading, but also 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.

GNU Binutils BoF

Host: Nick Clifton

Slides: GNU Binutils BoF.pdf

A chance to talk about the future of the GNU Binutils

Deploying SPDX License Identifiers in the GNU Toolchain

Host: David Edelsohn

Slides: Deploying SPDX License Identifiers in the GNU Toolchain.pdf

Explore adding SPDX license identifiers to GCC, Binutils, GLIBC and GDB source code files.

Arm/AArch64 BoF

Hosts: Tamar Christina, Andre Simoes Dias Vieira

Slides: Arm AArch64 BoF.pdf

The Arm and AArch64 BoF is an open session for discussing your issues and concerns on anything Arm related in the GNU toolchain. There is no fixed agenda! We'll probably start with a brief overview of the work done in the past year and planned for GCC 14 and then focus on whatever seems to be the most interesting item within the group. If you have specific issues or questions that you wish to raise, it might help if you can notify us in advance so that we can try to ensure that there is time to cover it.

Vectorizer BoF

Hosts: Andrew Stubbs, Richard Biener

A discussion of the current state and future direction of the GCC autovectorizer as we work to support architectures with non-traditional features. How can we improve vectorized code? How can we vectorize more cases? All-SLP representation?

Roadmap for pre-commit CI

Host: Maxim Kuvyrkov

We are going to discuss next steps for improving pre-commit CI in the GNU Toolchain community.

Modula-2 the road ahead!

Host: Gaius Mulley

GDB BoF

Host: Pedro Alves

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

IPA and LTO

Host: Jan Hubička

Slides: IPA and LTO BoF.pdf

RISC-V BoF

Host: Jeremy Bennett

More C (type safety) warnings as errors by default for GCC

Host: Florian Weimer

For backwards compatibility, GCC accepts a lot of constructs which are not valid C anymore, or do not work on most 64-bit architectures. These problems are often missed by accident in large build logs, and the compiled code may look like a compiler ABI bug. Changing the compiler defaults to reject these constructs may be desirable. This session intends to review what remains to be done in this area before GCC 14 Stage 1 close.

glibc BoF

Host: 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.39 and what work needs to be done between September 2023 and February 2024.
• Planning for glibc 2.40 and what work needs to be done between February 2024 and August 2024.
• Status of pthread condvar signal stealing bug.
• Status of dlopen and TLS variable access slowdown.
• Status of pidfd APIs.
• Status of Patchwork pre-commit CI/CD for glibc.
• .. and more.

Tutorials

Getting Started as a GCC Contributor

Presenter: David Malcolm

Slides:: 2023-Cauldron-Getting-Started-session.pdf

This will be a hands-on session aimed at newcomers to GCC development. The aim is to get you comfortable building the compiler from source and implementing a simple compiler warning.

Prerequisites:

• some knowledge of C/C++
• bring a laptop that you can code on (with at least 10GB of disk space available); ideally running some Linux distribution
• [and probably other things I haven't thought of; presumably there's decent wifi at the venue]

I'm thinking that this would be a face-to-face session, rather than a virtual session, with a small enough number of participants that I can help people individually as needed. If there's interest in a virtual session I could run that separately from Cauldron.

GCC Preparatory Tutorial

Presenter: Jeremy Bennett

Slides: GCC Prepartory Tutorial.pdf

This tutorial has been revised to work better as a preparation for the hands-on tutorial by David Malcolm.

Embecosm has a 3 month training course for new graduates joining us as future compiler engineers. The wide ranging course consists of daily lectures and tutorials combined with a lot of practical work.

This tutorial blends material from parts of that course. We will look briefly at the theoretical underpining of compilers, and map that to the implementation of the GCC compiler. We'll illustrate the talk with examples from the RISC-V GCC target, so that by the end you should be able to add a simple builtin function. My thanks to Maxim Blinov, who prepared much of the material on which this tutorial is based.

While I hope this will be useful to any students who wish to contribute to GCC, my main goal is to gain feedback from the wider GNU community about the suitability of this material and the didactic approach.