Differences between revisions 39 and 40
Revision 39 as of 2018-07-17 13:36:23
Size: 28788
Comment: Split C++ modules talk into talk + BoF
Revision 40 as of 2018-07-17 14:52:37
Size: 29374
Comment: Clarify C++ Modules talk, tutorial & bof
Deletions are marked like this. Additions are marked like this.
Line 185: Line 185:
<<Anchor(cpp-modules_tooling)>> <<Anchor(cpp-modules)>>
Line 190: Line 190:
The C++ modules-ts [1] is now published, but undergoing design changes as implementations progress. I shall cover the progression of the design, and of the implementation in G++[2].

This talk will provide background to the C++ Modules & Tooling Tutorial.

 1 'Working Draft, Extensions to C++ for Modules', Gaby dos Reis, [[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4720.pdf|www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4720.pdf]]

 2 'C++ Modules wiki', [[https://gcc.gnu.org/wiki/cxx-modules|gcc.gnu.org/wiki/cxx-modules]]

==== C++ Modules & Tooling ====

''Speaker:'' Nathan Sidwell
Line 192: Line 204:
This talk leads into the "Progress with C++ Modules" BoF. This tutorial leads into the "C++ Modules" BoF.
Line 245: Line 257:
==== C++ Modules and Build Systems BoF ==== ==== C++ Modules BoF ====
Line 249: Line 261:
Adding modules to C++ changes the interactions between the compiler and the build system. How might they cooperate without forcing either to be aware of the other's internals?  Adding modules to C++ changes the interactions between the compiler and the build system. How might they cooperate without forcing either to be aware of the other's internals?

GNU Tools Cauldron 2018

<< GNU Tools Cauldron 2017

  • Date: September 7 to 9, 2018.

  • Location: Manchester, UK

    University of Manchester (talks)
    Manchester Art Gallery (cauldron dinner)
    Museum of Science and Industry (SSEM demonstration)

    map1, map2, map3

  • Registration Fee: No charge.

  • Submission deadline: 31 July 2018. We will also accept "last minute" BoF/talks at the conference, if there is still room available.


Organizing committee:

  • Jeremy Bennett
  • Sarah Cook
  • David Edelsohn
  • Evelyn Ng
  • Raymond Harney
  • Will Hawkins
  • Jan Hubička
  • Ian Taylor


We'll be approaching companies for sponsorship in the coming weeks. Please email the mailing list if you would like to sponsor. The list of sponsors will be published here in due course.

Slides, Videos and Notes

After the event, this section will link to the videos, slides and any notes for all recorded presentations. Not all BoFs will be videoed.

Mailing lists

  1. Abstract submissions, registration, administrivia questions: tools-cauldron-admin@googlegroups.com

  2. Announcements and discussions related to the conference: gcc@gcc.gnu.org .

Workshop description

We are pleased to announce another gathering of GNU tools developers. The format of this meeting will be similar to the previous meetings. The purpose of this workshop is to gather all GNU tools developers, discuss current/future work, coordinate efforts, exchange reports on ongoing efforts, discuss development plans for the next 12 months, developer tutorials and any other related discussions.

This time, the GNU Tools Cauldron returns to the North of England, taking place in the Sackville Street building of the University of Manchester, adjacent to the Alan Turing memorial. Manchester University was one of the earliest centers of computer innovation, with Alan Turing serving as Deputy Director of the Computing Machine Laboratory from 1949. The Cauldron dinner will take place at the Manchester Art Gallery. For those who can arrive early, we have arranged a demonstration on Thursday afternoon of the 1948 Small Scale Experimental Machine (SSEM) which is housed at the Museum of Science and Industry.

We are inviting every developer working in the GNU toolchain: GCC, GDB, binutils, runtimes, etc. In addition to discussion topics selected at the conference, we are looking for advance submissions.


If you intend to participate, but not necessarily present, please let us know. Send a message to tools-cauldron-admin@googlegroups.com stating your intent to participate. Please indicate:

  • your affiliation;
  • dietary requirements;
  • t-shirt size; and
  • whether you plan to attend the SSEM demonstration on the Thursday afternoon.

Please tell us as soon as possible if you need a letter of invitation in order to secure a visa.

Travel Grants for Students

The GNU Tools Fund sponsors student travel to attend the GNU Cauldron. Travel grants cover some or all of travel related expenses. This program is open to full time undergraduate and graduate students.

Students should email information about their interest, their experience, their participation in the GNU Toolchain, an estimated budget, and any sponsors in the GNU Toolchain community to tools-cauldron-admin@googlegroups.com.

The deadline to submit a request is 1 August 2018.

Submitting talks/!BoFs/Tutorials

If you have a topic that you would like to present, please submit an abstract describing what you plan to present. We are accepting three types of submissions:

  • Prepared presentations: demos, project reports, etc.
  • BoFs: coordination meetings with other developers.

  • Tutorials for developers. No user tutorials, please.

Note that we will not be doing in-depth reviews of the presentations. Mainly we are looking for applicability and to decide scheduling. There will be time at the conference to add other topics of discussion, similarly to previous meetings.

To register your abstract, send e-mail to tools-cauldron-admin@googlegroups.com .

Your submission should contain the following information:

  • Title:
  • Authors:
  • Abstract:

GDPR compliance

The personal information we hold on you is your name, affiliation, dietary preferences, T-shirt size and whether you wish to attend the SSEM demonstration. This information will only be used to contact you about the arrangements for the GNU Tools Cauldron 2018, including a follow-up questionnaire after the event. The data is held securely on outsourced secure servers where the data is encrypted. The data is only accessible by the organisers of the GNU Tool Cauldron 2018. All the data will be destroyed shortly after the GNU Tools Cauldron, once the follow-up questionnaire has been sent out.

Please contact the Data Officer if you would like to know the information we hold on you, wish to have that information deleted, or for any other queries related to GDPR.


The detailed schedule of talks will appear here. For now we have an outline schedule.

All events are in the Sackville Street Building, except where indicated.

  • Start


    Great Hall

    C53 Lecture Theatre

    Thursday 6th September



    SSEM Demonstration(at the Museum of Science and Industry)



    Welcome reception (Entrance Hall)

    Friday 7th September



    Registration tea and coffee



    Talks, BoFs and Developer Tutorials

    Saturday 8th September



    Registration tea and coffee



    Talks, BoFs and Developer Tutorials



    GNU Cauldron dinner at Manchester Art Gallery

    Sunday 9th September



    Registration tea and coffee



    GCC Steering Committee Q&A (STC)



    Talks, BoFs and Developer Tutorials

The Great Hall seats up to 150, the C53 Lecture Theatre seats up to 137. In addition we have the Council Chamber (seating 40) for informal meetings, breakout and hacking. We shall use the Entrance Hall for the welcome reception on Thursday evening.

Last Minute Changes

The schedules will be on posters around the venue, and will be updated as necessary by the organizers. In addition last minute changes will be posted on the GCC IRC channel (#gcc on irc.oftc.net) and tweeted with the hashtag #GNUCauldron.

Remote Access to Talks

In general we are not going to livestream the talks, although they will all be videoed and made available here shortly after the Cauldron concludes. If there is a talk where there are key remote participants, please let the organizers know as soon as possible and we'll do our best to set up a remote video connection.


Abstracts will be listed here in strict case insensitive alphabetical order of title.


Debuginfo news

Speakers: Mark Wielaard & Alexandre Oliva

GDC - D front-end for GCC

Speaker: Iain Buclaw

The D programming language, what is it and who is it being used by?

The D front-end for GCC was started in 2004, and has been actively maintained for the last ten years, will talk about how it was implemented, and what features of GCC it makes leverage of.

The D language was accepted for inclusion into GCC, what is being currently done for that?

What is the currently being worked on in GDC, and status of moving to a self-hosting front-end.

Long double format on GLIBC for powerpc64le

Speaker: Gabriel F T Gomes

Long double can take many formats. On POWER, it can take the same format as double, or the IBM Extended Precision format, which is currently default on all POWER latforms. More recently, the GLIBC community introduced library support for an additional floating-point type (_Float128), which lays the groundwork for the transition of the long double type to its new format, on powerpc64le.

The transition is currently being developed for GLIBC and is comprised of several goals and challenges:

  • support for the three formats must be preserved within the ABI;
  • automatic redirections to the correct implementation must be provided by the library headers;
  • new tests are needed to guarantee correctness and prevent future regressions;
  • etc.

This presentation will share the design options and rationale for choosing among them, as well as aiming to collect more feedback from the community.

Optimization records: showing the user what GCC's optimization passes are doing

Speaker: David Malcolm

How does an advanced end-user figure out what GCC's optimization passes are doing to their code, and how they might tweak things for speed?

How do we (as GNU toolchain developers) debug and improve the optimization passes?

I'll be talking about:

  • the existing approaches here and their limitations
  • experiments I've been doing to address these limitations by capturing "optimization records" in a machine-readable format
  • what this might enable, and
  • what this might mean for GCC middle-end maintainers.

PowerPC GCC memory handling changes

Speaker: Michael Meissner

In this talk I will discuss changes that I am working to rework the PowerPC GCC compiler memory support to handle memory addresses in a more general fashion. The idea is to not immediately split addresses into the instructions that will ultimately be used to address memory, but keep the addresses together longer in the RTL stage of the compiler. I will also discuss how this plays into supporting fusion that some of the PowerPC servers support.

Progress With C++ Modules

Speaker: Nathan Sidwell

The C++ modules-ts [1] is now published, but undergoing design changes as implementations progress. I shall cover the progression of the design, and of the implementation in G++[2].

This talk will provide background to the C++ Modules & Tooling Tutorial.

C++ Modules & Tooling

Speaker: Nathan Sidwell

C++ Modules require compilers & build system cooperation. How can that be achieved without one becoming the other? I'll present the evolution of schemes in the G++ modules project. I'll show why putting a client/server interface into the toolchain is not a crazy idea.

This tutorial leads into the "C++ Modules" BoF.

The SECURE project and GCC

Speaker: Graham Markall

The SECURE project is a 15 month program funded by Innovate UK, to take well known security techniques from academia and make them generally available in standard compilers, specfically GCC and LLVM. An explicit objective is for those techniques to be incorporated in the upstream versions of compilers. The Cauldron takes place in the final month of the project and this talk will present the technical details of some of the techniques implemented, and review those that are yet to be implemented. A particular focus of this talk will be on verifying that the implemetnation is correct, which can be a bigger challenge than the implementation.

Techniques to be covered in the project include the following:

  • Stack and register erasure. Ensuring that on return from a function, no data is left lying on the stack or in registers. Particular challenges are in dealing with inlining, shrink wrapping and caching.

  • Bit slicing. Of particular value to block ciphers, how do we facilitate transformation of algorithms to bit sliced formulations?

  • Critical variable sensitivity. Critical variables such as encryption keys, should not be used for control flow, or in indirect memory accesses, since such this may allow information to leak through timing and power side channels. The compiler can warn of such code, but there are limitations to tracking sensitivity across programs in all circumstances.

  • Atomicity. If a critical variable must be used in control flow, how do we balance the code to ensure whichever path is taken the external timing and power usage are the same?

  • Code duplication. An attack method sometimes used is to shine powerful lasers on the chip in the hope of corrupting code, so a critical variable is not written correctly. To defend against this, programmers will often assign values to critical variables twice, so even if one code point is corrupted, the value will still be assigned. The problem is that modern compilers will spot such duplication and automatically remove it, so such code is often compiled without optimization, seriously reducing performance. However the compiler can instead automate the duplication, for variables marked as being sensitive to this attack. This simplifies the whole process and allows code to be optimized. Being automated it ensures that no duplication is missed, and the duplication is spaced optimally.

  • Permutation. Where multiple translations exist for a code block, it is possible to generate several translations and randomly choose which one will be executed at run time. This increases the complexity of differential power and timing attacks.

Update on Modula-2

Speaker: Gaius Mulley

GNU Modula-2 has been grafted onto the trunc, 8.0.1, 6.4.0, 5.4.0, 4.7.4 and 4.1.2 releases of gcc. Several new options have been introduced, most notably, -fm2-g, -fwholevalue, -ffloatvalue and -fm2-plugin.

The option -fm2-g will guarantee an instruction for every statement compiled.

Integer arithmetic overflow detection for (subtract, addition, negation, multiply, assignment operators, for all ordinal operands and sub-range types. (-fsoft-check-all) and (-fwholevalue) is complete. Detection of a NaN after all floating point arithmetic operations is also available via -ffloatvalue.

The new plugin for Modula-2 exploits the optimisation and data flow analysis to provide enhanced semantic checking. Semantic compile time checking has been considerably enhanced by the new plugin which detects whether the initial basic block in any reachable procedure contains a runtime violation (a call to the runtime error library).

This works well as the runtime error library functions take source file, line, column as parameters. Thus this information will survive any optimisation and therefore data flow analysis coupled with code transformation optimisations can be usefully leveraged towards gaining better semantic errors.

Value-numbering on regions and beyond

Speaker: Richard Biener

Abstract to follow…

Birds of a Feather sessions (BoFs)

Arm / AArch64 BoF

Leaders: Ramana Radhakrishnan and Richard Earnshaw

C++ Modules BoF

Leader: Nathan Sidwell

Adding modules to C++ changes the interactions between the compiler and the build system. How might they cooperate without forcing either to be aware of the other's internals?

Gfortran Developers' BoF

Leader Thomas Koenig

A meeting of the gfortran developers.

Non-8-bit-byte architecture support BoF

Leader Simon Marchi

GDB currently has very patchy support for processor architectures with memories whose addressable size is other than 8-bits. One of the problems is that while such architectures exist as internal products at various companies, very few are publicly/freely available and none of them is supported by FSF GDB. It's therefore not possible for the community to test and maintain the GDB support for such architectures.

This BoF is intended to bring together those who deal with such architectures, discuss what can be done to consolidate the support for them and how to make it easy to test it. It would be interesting to find an architecture with non-8-bit-bytes memory for which support could be added upstream. Another interesting avenue to discuss would be the AAP project by Embecosm [1], which can be used to generate architectures with unorthodox memory configurations.

Power / PowerPC / rs6000 BoF

Leaders Bill Schmidt and Segher Boessenkool

BoF for all developers interested in the Power ports, discussing progress, concerns, and plans during the GCC 9 time frame. We will also provide a brief overview of the new POWER9 processors and their impact on our GNU toolchain development.

Progress With C++ Modules

Speaker: Nathan Sidwell

The C++ modules-ts [1] is now published, but undergoing design changes as implementations progress. I shall cover the progression of the design, and of the implementation in G++[2].


Leaders: Jeremy Bennett, Palmer Dabbelt, Jim Wilson

An opportunity to discuss all things related to the GNU tool chain for RISC-V

RISC-V Vector Extension Implementation BoF

Leaders Roger Espasa and Graham Markall

The RISC-V Vector Extension has several interesting properties. Two that are particularly interesting from a compiler perspective are:

  • A hardware vector length that is not only unknown at compile time, but also changes during execution. Changes to the vector length are controlled by software to process as many elements per loop iteration as the hardware can support.
  • Variable vector unit configuration. The vector register file in any implementation is a fixed size, but the available space can be configured for variable data width and vector length, as well as "type" (scalar, vector, or matrix data). Like the vector length, the configuration is changeable at runtime.

The vector length being determined by the hardware is similar to ARM's Scalable Vector Extensions (SVE), but in SVE the vector length is fixed during program execution. Whilst it is possible to leave the configuration fixed throughout execution in RISC-V, tailoring the vector length and register file configuration will result in higher-performing programs.

This BoF is for discussion about changes to GCC to support the RISC-V Vector Extension and the challenges that it presents, such as the impact on optimizations that the configurable vector length and register file will have.

The GNU C Library BoF

Leaders: Carlos O'Donell, Florian Weimer

The GNU C Library is used as the C library in the GNU systems and most systems with the Linux kernel. The library is primarily designed to be a portable and high performance C library.It follows all relevant standards including ISO C11 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.29 and what work needs to be done between August 2018 and January 2018.
  • Planning for glibc 2.30 and what work needs to be done between January 2019 and July 2019.
  • Interfaces for stack and TLS boundaries for use by language runtimes (Rust) and developer tooling (ASAN)?
  • Finally fixing TLS in signal handlers? A re-review of the two options (or others if you want to present them).

… and more.

The Multicore GDB BoF

Leaders: Pedro Alves, Stephen Roberts, Andrew Burgess

Discussion of all things related to multicore debug, particularly debugging multiple remote systems and bare metal multicore.

Unwinder BoF

Leader: Florian Weimer

Our current approach with unwinding has several problems:

  • It is not async-signal-safe.
  • Performance is poor (in part due to locking).
  • Expected behavior in case of corrupted stack frames is unclear.
  • pthread_cancel needs the unwinder, but it is not available in libc.so.
  • glibc contains an old copy of the libgcc unwinder for static linking.

There is a related discussion in in WG21 SG14 concerning alternatives to table-driven (“zero cost”) exception handling. See Herb Sutter, Zero-overhead deterministic exceptions: Throwing values.

The intent of the BoF is to discuss ways to address some of these issues, determine whether closer integration between the dynamic linker and the unwinder is needed, and get an early idea whether we want to switch away from table-driven handling for Sutter-style “throws” functions.


CGEN Tutorial

Leaders: Andrew Burgess, Jeremy Bennett

CGEN hugely simplifies writing of assemblers, disassemblers and simulators, particularly for GNU tool chains. All generated from a Scheme specification of the ISA syntax and semantics.

In this tutorial we will introduce all the key features of CGEN as used within GNU tool chains. We'll use RISC-V and AAP as examples.

Q&A Sessions

GCC Steering Committee Q&A

Led by: David Edelsohn

Time: Sunday, 10:00-10:45, Great Hall (TBC)

Do you have questions? We may have answers. Or maybe not.


University of Manchester Sackville Street Building (main venue)

Sackville Street Building

The Grade II listed Sackville Street Building opened in 1902 to support the expansion of Manchester Municipal Technical School. Today it forms part of the University of Manchester, the second largest University in the UK.

Manchester Art Gallery (image CC-BY-SA David Dixon)

Manchester Art Gallery is home to major collections of Fine Art, Craft & Design and Costume. A chance to admire the artistic heritage of the city.

We plan a buffet feast of regional foods, which will be accompanied by beverages from local brewers and vineyards.

The Museum of Science and Industry (SSEM Demonstration)

The Museum of Science and Industry (image CC-BY-SA Jonti Wilde)

The Museum of Science and Industry celebrates Manchester's key role in technology development over the centuries and houses a replica of the 1948 Small Scale Experimental Machine (SSEM), aka the "Manchester Baby". We have arranged a demonstration for the Thursday afternoon—more details will be provided here nearer the time.

About Manchester

Founded as a roman fort just under two thousand years ago, Manchester remained a small town until the start of the nineteenth century. With the start of the Industrial Revolution, Manchester expanded and urbanized rapidly and today is at the center of an urban area of more than two million people. Its key role in the Industrial Revolution generated great wealth, and the city is noted for its striking architecture from the period.



By Air

Manchester is served by Manchester International airport. Transfer time by train is approximately 15 minutes. For those arriving in London, there is a fast train service taking just over 2 hours from London Euston, giving a total transfer time from Heathrow or Gatwick Airports of around 3.5 hours.

Public Transport

The Sackville Street Building is 400m from Manchester Piccadilly station and is very well served by trains from the airport, London and many northern towns and cities. For timetables and travel planning see National Rail Enquiries.

The building is also a short walk from the Central Coach Station, offering coach transport to London and many other cities. For timetables and travel planning see National Express.

In addition to the long distance rail and coach network, Manchester has an extensive bus and tram network. Everything you could possibly want to know is available from Transport for Greater Manchester.


Numerous taxi companies as well as Uber serve Manchester. There is a public taxi rank at Piccadilly station where you can pick up a metered taxi.


Every major hotel chain is represented in Manchester, and there is a huge choice of smaller independent hotels, B&Bs and self catering accommodation. Manchester Visitor Information can provide detailed advice.


The UK is generally temperate, but well known for the variability of its weather. While September can often be pleasantly warm, it can also serve up autumn gales and rain.

None: cauldron2018 (last edited 2019-03-12 17:31:45 by SimonMarchi)