add UB BoF slides
Add T-shirt logo
|Deletions are marked like this.||Additions are marked like this.|
|Line 42:||Line 42:|
|It is still not too late to sponsor. Please email firstname.lastname@example.org if you are able to help.||We shall soon be looking for sponsors for Cauldron 2019. Please email email@example.com if you are able to help.
== T-shirt Logo ==
For all those who have asked about the logo, here it is:
Licensing and usage terms are the same as for the standard [[https://www.gnu.org/graphics/agnuhead.en.html|GNU head]].
GNU Tools Cauldron 2018
GNU Tools Cauldron 2018
- T-shirt Logo
- Slides, Videos and Notes
- Mailing lists
- Workshop description
- Where to eat
Date: September 7 to 9, 2018.
Location: Manchester, UK
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.
- Jeremy Bennett
- Sarah Cook
- David Edelsohn
- Evelyn Ng
- Raymond Harney
- Will Hawkins
- Jan Hubička
- Ian Taylor
We are grateful to our sponsors for their generous support. Some have supported us for many years, others we are pleased to welcome for the first time this year. All contributing to maintaining a vibrant GNU tools community.
- Mentor Graphics
- Red Hat
We shall soon be looking for sponsors for Cauldron 2019. Please email firstname.lastname@example.org if you are able to help.
For all those who have asked about the logo, here it is:
Licensing and usage terms are the same as for the standard GNU head.
Slides, Videos and Notes
Abstract submissions, registration, administrivia questions: email@example.com
Announcements and discussions related to the conference: firstname.lastname@example.org .
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 email@example.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 firstname.lastname@example.org.
The deadline to submit a request is 1 August 2018.
The program is now full for full presentations, BoFs and tutorials. We have room for a small number of additional lightning talks.
If you have a topic that you would like to present, please submit an abstract describing what you plan to present. We are accepting four types of submissions:
- Prepared presentations: demos, project reports, etc.
- Lightning talks (max 10 minutes).
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 email@example.com .
Your submission should contain the following information:
Code of Conduct
All participants are expected to by the conference Code of Conduct. As in 2016, we shall use the British Computer Society Open Source Special-ist Group Code of Conduct.
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.
- The Data Controller is Embecosm Limited
The Data Officer is Sarah Cook <firstname.lastname@example.org>
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.
This is the schedule. Any problems, please email the organizers.
All events are in the Sackville Street Building, except where indicated.
C53 Lecture Theatre
Thursday, September 6
SSEM Demonstration (at the Museum of Science and Industry)
Welcome reception (Entrance Hall)
Friday, September 7
Registration, tea & coffee (Entrance Hall)
Cesar Philippidis: Future Direction of OpenACC
Michael Meissner: PowerPC GCC memory handling changes
Jakub Jelinek & Cesar Philippidis: OpenACC/OpenMP/offloading BoF
Segher Boessenkool & Bill Schmidt: Power/PowerPC/rs6000 BoF
Lunch (Entrance Hall)
Andrew Stubbs: AMD GCN Port
Jeremy Bennett, Palmer Dabbelt & Jim Wilson: RISC-V BoF
Gabriel F T Gomes: Long double format on GLIBC for powerpc64le
Roger Espasa & Graham Markall: RISC-V Vector Extension Implementation BoF
Afternoon tea & coffee (Entrance Hall)
Nathan Sidwell: Progress With C++ Modules
Florian Weimer: Unwinder BoF
Nathan Sidwell: C++ Modules & Tooling
Carlos O'Donell & Florian Weimer The GNU C Library BoF
Saturday, September 8
Registration, tea & coffee (Entrance Hall)
David Edelsohn et al: GCC Steering Committee Q&A
Gaius Mulley: Update on Modula-2
Lunch (Entrance Hall)
Mark Wielaard & Alexandre Oliva: A collection of debug info improvements for the GNU Compiler Collection
Michael Matz: Dependence Analysis BoF
Alexander Monakov: Future directions for treatment of undefined behavior in C
Pedro Alves, Stephen Roberts & Andrew Burgess: The Multicore GDB BoF
Jan Hubicka: The LTO/IPA BoF
Afternoon tea & coffee (Entrance Hall)
Ramana Radhakrishnan & Richard Earnshaw: Arm/AArch64 BoF
Pedro Alves The GDB BoF & quick status update
Szabolcs Nagy: Optimizing math routines
Richard Biener: Value-numbering on regions and beyond
Jonathan Wakely: Consistent use of atomics in libstdc++ across ARM targets
GNU Cauldron dinner (Manchester Art Gallery)
Sunday, September 9
Registration, tea & coffee (Entrance Hall)
Jeremy Bennett, Andrew Burgess & Ed Jones: CGEN Tutorial
Vladislav Ivanishin: (Ab)using LTO plugin API for system-wide shrinking of dynamic libraries
David Edelsohn: Advocacy for GNU tools BoF
Iain Buclaw: GDC - D front-end for GCC
Thomas Koenig: Gfortran Developers' BoF
Lunch (Entrance Hall)
Martin Sebor: Implementing static analysis checkers in the middle-end
Simon Marchi: Non-8-bit-byte architecture support BoF
Stefan Koch: Demo of libgccjit as CTFE backend
Graham Markall: The SECURE project and GCC
Ulrich Weigand: Comparing the IBM Z back ends in GCC and LLVM
Afternoon tea & coffee (Entrance Hall)
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 (apart from some slots on Saturday afternoon when it is scheduled for BoFs). 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.
(Ab)using LTO plugin API for system-wide shrinking of dynamic libraries
Speaker: Vladislav Ivanishin
In this talk I will recount our adventures in pruning globally unused symbols from dynamic libraries in a "closed-world" system.
We relied on GCC's and GNU linkers' plugin facilities to collect section/symbol dependencies, and downgrade unused symbols' visibility to hidden to enable the --gc-sections linker switch to eliminate them.
This talk will feature some pitfalls of the linker plugin API and linker bugs we stumbled across. We'd like to highlight that if third parties are welcome to use the linker plugin API it might need some fundamental changes to be really useful.
Our work was tested on a Tizen distribution, bringing a 16% reduction in total size of the binaries, which translated to a 10% reduction of the system image size.
This is a joint work with Evgeny Kudryashov, Alexander Monakov, Dmitry Melnik (ISP RAS), Jehyung Lee, and Chan Lee (Samsung Research).
AMD GCN Port
Speaker: Andrew Stubbs
An overview of the GCN GPU architecture, how it creates challenges for a GCC backend, and how we've chosen to solve them.
What's done, and what's still to do.
OpenMP and OpenACC for GCN.
Comparing the IBM Z back ends in GCC and LLVM
Speaker: Ulrich Weigand
GCC and LLVM perform similar tasks, but the internal implementation is very different. As a maintainer of the IBM Z back end in both GCC and LLVM I've had the opportunity to become familiar with both worlds.
In this talk, I'll give an overview of the current status of support for IBM Z processors in both GCC and LLVM, touching on differences in available feature sets and performance results.
In addition, I'll be talking about my experience working in the context of both compiler frameworks. Where did I find GCC easier to work with, and where does LLVM have its advantages? The talk will look at these questions from a back-end perspective.
A collection of debug info improvements for the GNU Compiler Collection
Speakers: Mark Wielaard & Alexandre Oliva
DWARF is designed to have limited dependency on tools. A linker just has to concatenate the data sections, resolve symbol and inter-section relocations. But that does cause lots of repeated data structures (types) and the linker has to process a lot of references/relocations. To counter that .debug_types and DebugFission were introduced. First as GNU extensions then added to DWARF4 and DWARF5. Lots of details changed. These techniques can be used with separate .dwo files, or since DWARF5 in each .o file. This does introduce some extra complexity. We have to add various levels of indirection for types, strings, addresses and inter-section references. And with split-dwarf between the .o object files, executable and .dwo files. Some of the de-duplication of data is pushed to the DWARF consumer, or might need a slightly smarter post-processor to merge the duplication of types and data (there can be thousands of split-dwarf .dwo files).
We will go over the techniques that are now implemented in GCC. Which versions of GCC implement what. Why the indirection tables are actually cheaper than traditional relocations. Where they aren't used yet, but probably should. The current state of DWARF consumers (gdb, elfutils, etc.) and auxiliary post-processing tools (dwp and dwz).
In another part, the topic will be the latest and next steps in our efforts to improve debug information of optimized programs, so as to make debugging and monitoring possible without disabling optimization and recompiling. We have gone through each of the optimization passes in GCC enabled by -O* flags and assessed their impact on debugging (study of -O* vs -g, thus gOlogy :-), and how successful such techniques as source loci in stmts and insns, var-tracking, VTA, SFN, and LVU have been at masking the unwanted effects of optimizations. Presenting the complete results of the report would take far too long (it is way over a hundred different passes!), but we will present highlights that point at future projects, from low hanging fruit to large undertakings.
Future Direction of OpenACC
Speaker: Cesar Philippidis
This talk will present a high-level overview on the current state of OpenACC support to be included in GCC 9. Next it will cover the new functionality for GCC 10 and beyond. New functionality includes, but not limited to, enhancing automatic parallelism in OpenACC kernels and deep copy.
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.
Implementing static analysis checkers in the middle-end
Speaker: Martin Sebor
An overview of benefits and challenges of implementing warnings in the GCC middle-end. Using specific examples I will go over some of the disadvantages of front-end warnings and show how they can be overcome by relying on control- and data-flow analyses in the middle-end. I will go over some of the biggest technical as well as social challenges in achieving acceptable ratio between false negatives, false positives, and true positives.
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;
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.
Optimizing math routines
Speaker: Szabolcs Nagy
This talk presents the work behind several new single and double precision math function implementations for glibc.
The new implementations are generic and the performance improvements should be portable across different targets. The main challenges were dealing with target variations, rounding errors, doing careful error analysis, following the requirements of various standards, testing and benchmarking different configurations, integrating the code into glibc and fighting with various tools. I plan to discuss these challenges and some of the design decisions behind the new code. The performance improvements are significant in most cases so it is also worth discussing the key ideas that made it possible.
Some of the patches were upstreamed last year, some are still under review, the list of optimized functions with ubenchmark performance improvement on common inputs: sinf (1.7x), cosf (1.7x), sincosf (1.7x), expf (3.5x), exp2f (3.1x), logf (2.3x), log2f (2.4x), powf (4.8x), sin (1.4x), cos (1.4x), sincos (1.7x), exp (1.9x), exp2 (2.0x), log (3.8x), log2 (2.0x) and pow (3.1x).
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  is now published, but undergoing design changes as implementations progress. I shall cover the progression of the design, and of the implementation in G++.
This talk will provide background to the C++ Modules & Tooling Tutorial.
1 'Working Draft, Extensions to C++ for Modules', Gaby dos Reis, www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4720.pdf
2 'C++ Modules wiki', gcc.gnu.org/wiki/cxx-modules
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.
Towards Clear Memory Object Semantics for ISO and De Facto C
Speaker: Peter Sewell
The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as simple abstract or concrete entities: the language exposes their representations, but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO standard leaves much of this unclear, and in some aspects differs with de facto standard usage - which itself is difficult to investigate.
This talk will describe the issues involved in defining a clear source-language semantics for pointers and memory objects, focussing especially on pointer provenance. We aim ultimately to reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code.
It will also describe how a proposed semantics has been made executable as a test oracle (to calculate all the semantics-allowed executions of small tests), by integrating it with the Cerberus semantics for much of the rest of C, and preliminary experimental work to assess what code out there depends on.
The talk will be a revised version of a keynote given at EuroLLVM 2018, informed by discussion with the recently created ISO WG14 C Memory Object Model Study Group. We would be very interested to get feedback from the broader GCC community about these issues.
This is joint work with Kayvan Memarian, Victor B. F. Gomes, Stephen Kell, Brooks Davis, Robert Watson, Alex Richardson, and members of the ISO WG14 C Memory Object Model Study Group.
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
The SSA SCC based value-numbering algorithm used by FRE and PRE isn't well suited to be applied to regions of code and cannot be made fully optimistic. Its implementation also has correctness issues with regarding to expression simplification.
A new RPO based algorithm tries to address all these issues. The implementation is designed to be of complexity of the region it is applied to, making it suitable as localized cleanup phase after transforms like loop unrolling. Given its RPO structure it can be switched between a non-iterating non-optimistic mode and a iterating optimistic one. Care is taken to do expression simplification using available SSA names rather than values to avoid the wrong-code issues the SCC implementation is plagued with.
Maximum 10 minutes including Q&A.
Automatic Tuning of Compiler Options using irace
Speaker: Manuel López-Ibáñez
Co-authors: L. Pérez Cáceres, F. Pagnozzi, A. Franzin & T. Stützle
While modern compilers usually offer different levels of optimization as possible defaults, they have a larger number of command-line options and numerical parameters that impact properties of the generated machine-code. The irace package (https://cran.r-project.org/package=irace) is a method for automatic algorithm configuration that can handle numerical and discrete options and optimizes their settings according to a given metric (such as runtime) over a large number of noisy (stochastic) benchmarks. When adapted to the tuning of compiler options in GCC, irace becomes an alternative to Acovea, OpenTuner and TACT with some desirable features. Experimental results show that, depending on the specific code to be optimized, speed-ups of up to 1.4 when compared to the -O2 and -O3 optimization flags are possible.
I'm presenting on behalf of the other authors who will not attend. They did all the experiments using our tool (irace) and advice from me. I hope the irace package will be interesting to GCC developers and users (it is GPL).
Leader: Michael Matz
This is an introduction to the subject matter of the Dependence Analysis BoF.
GDB DWARF index cache
Speaker: Simon Marchi
DWARF index sections help significantly reduce the load time of large binaries in GDB. However, they require manual steps in order to be produced: either use a particular linker and set the right linker flags or run gdb-add-index.sh on the final binary. As a result, I didn't use them very often and didn't encounter them very often in the wild.
A recent feature allows GDB to automatically produce and save an index file to a cache directory when loading a symbol file that does not already have one. This lets the user take advantage of the speedup of the index for any binary (the next time they load the same binary), without having to even think about it.
We will see how to use this feature (spoiler: set index-cache on) and peek quickly in how it is implemented.
Using libgccjit as CTFE backend
Speaker: Stefan Koch
I am currently reimplementing the CTFE (Compile-time function evaluation) functionality of the D programming language's main compiler, DMD. I will explain why libgccjit makes this much easier, and why it shines compared to LLVM.
Using the GCC regression test suite for LLVM
Speaker: Simon Cook
LLVM has two main test suites:
- the regression test suite tests the compilation from source to IR; and
- the nightly test suite is a body of often large applications which are compiled and executed.
However there is no large body of tests of detailed functionality which is compiled right down to the target object code and executed. We describe the changes we have made to allow the GCC test suite to be used for nightly public regression testing of LLVM for RISC-V.
Birds of a Feather sessions (BoFs)
Advocacy for GNU tools BoF
Facilitator: David Edelsohn
This is an opportunity for all interested to discuss how we can improve advocacy for GNU tools projects.
Leaders: Ramana Radhakrishnan and Richard Earnshaw
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 then focus on whatever seems to be the most interesting items 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.
Topics that might be of interest this year:
- Vector ABI
- New architectural Extensions
- Security issues - stack clash et al.
Consistent use of atomics in libstdc++ across ARM targets
Leader: Jonathan Wakely
A few places in libstdc++ assume that the same -march value is used when building libstdc++ and when compiling user code that includes libstdc++.so headers. If this isn't true you can get undefined behaviour and crashes (or worse). I'd like to clean this up so that it just Does The Right Thing, even for ARMv5 where there are no native atomics. I'd like to present the current problem and start a discussion about how to fix it, maybe via kernel helpers, or something in glibc.
Dependence Analysis BoF
Leader: Michael Matz
We're going to discuss some of our loop transformation infrastructure, namely dependence analysis, it's representation, possible reuse of the GRAPHITE implementation of it (separating it from its code generation aspect) for all our dependence analysis needs and related topics.
Future directions for treatment of undefined behavior in C
Leader: Alexander Monakov
I'd like to invite discussion on prospects of adjusting how GCC treats undefined behavior. There's ever-increasing interest in discovering UB in production code, with tools such as tis-interpreter and UBSan helping to detect UB at runtime, as well as various tools for static analysis. At the same time, GCC does not always produce diagnostics for users wishing to learn where the compiler assumes absence of undefined behavior, and optimizations don't always insert traps when unconditional UB is reached.
Possible topics for discussions include: new warnings for code that may or will exhibit UB at runtime; adjusting optimization to avoid amplification of UB effects as much as practical.
Gfortran Developers' BoF
Leader Thomas Koenig
A meeting of the gfortran developers.
Leaders: Jakub Jelinek and Cesar Philippidis
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 , which can be used to generate architectures with unorthodox memory configurations.
Power / PowerPC / rs6000 BoF
Leaders Segher Boessenkool & Bill Schmidt
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.
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 GDB BoF & quick status update
Leader: Pedro Alves
An opportunity for the GDB community to meet to discuss all things related to the GNU Debugger project.
I'll start by showing some slides going over GDB's progress in the last year.
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 LTO/IPA BoF
Leader: Jan Hubicka
Discussion about recent LTO and IPA developments in GCC.
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.
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.
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.
Leaders: Jeremy Bennett, Andrew Burgess & Ed Jones
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.
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)
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 (Cauldron dinner venue)
(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 breweries and cider mills.
The Museum of Science and Industry (SSEM Demonstration)
(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. To make it feasible we have divided the time available into 4 slots. There should be a maximum of 22 people in each group.
- 15:00-15:30 Surnames beginning A-I
- 15:30-16:00 Surnames beginning J-O
- 16:00-16:30 Surnames beginning P-Z
- 16:30-17:00 Anyone whose flight arrives late!
Go through the main entrance of MOSI (it's free). There will be helpers from the Cauldron to point you towards the SSEM. Feel free to look around other exhibits while you are there.
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.
Where to eat
By popular request, here is a selection of restaurants local to the venue. There are far more available through your favourite mapping application.
Village Fish & Chip Shop
Address: 37 Bloom St, Manchester M1 3LY
Phone: 0161 237 3629
Northern Soul Grilled Cheese
Lively, fast food-style joint known for its inventive, elevated grilled cheese sandwiches.
Address: 10 Church St, Manchester M4 1PN
Counter-serve bagel chain outlet that prepares sandwiches plus sweet and savoury snacks on-site.
Address: 13 Piccadilly Station
Address: Picadilly Station, Gateway House, Station Approach
Colourful, modern takeaway serving menu of falafel wraps, hummus, juices and smoothies.
Address: 3 Newton St
=== Arnero Restaurant ====
Mughlai and North Indian cooking are the speciality at this welcoming restaurant.
Address: 25 Sackville St, Manchester M1 3LZ
Phone: 0161 236 1364
East African stews and delicacies at an Ethiopian restaurant with colourful decor and artefacts.
Address: 29-31 Sackville St, Manchester M1 3LZ
Phone: 0161 228 7396
Gay Village spot for tea, cocktails, Spanish/South American tapas and more, with a small verandah.
Address: 26 Richmond St, Manchester M1 3NB
Hours: Closes 2am
Phone: 0161 237 9329
Phetpailin Thai Restaurant
Anglo-Thai cuisine in a Chinatown venue, including a wide vegetarian choice and no BYOB corkage.
Address: 46 George St, Manchester M1 4HF
Hours: Opens 6PM
Phone: 0161 228 6500
Happy Seasons Restaurant
Address: 59 Faulkner St, Manchester M1 4FF
Hours: Closes 11PM
Phone: 0161 236 7189
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.
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.