GNU Tools Cauldron 2025

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.

In this BoF we will be discussing topics related to the BPF target in the GNU Toolchain.

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