cauldron2019talks - GCC Wiki

Talks

A year of experience with broad based continuous testing with GCC

Speaker: Jeff Law (Red Hat)

In 2018 I brought up a continuous testing system for GCC focused on finding generic issues by performing testing across a broad spectrum of targets. We will discuss the basics of the testing currently done, experiences (good and bad) as well as future directions.

ABI and Implementation Issues for Coexistant TOC-Based and PC-Relative Addressing

Speaker: Michael Meissner, Bill Schmidt (IBM)

Existing 64-bit ABIs for the POWER processor use a table-of-contents (TOC) pointer for access to static and global data. In a future version of the POWER architecture, we plan to introduce new instructions to provide PC-relative addressing. In this talk, we will discuss how we are modifying the ABI to permit either TOC or PC-relative addressing to access static and global data, including programs that contain both types of references. We will also discuss the changes we are making to the GCC compiler to support PC-relative addressing.

Adding Linux restartable sequence (rseq) support in glibc

Speaker: Mathieu Desnoyers (EfficiOS)

Restartable Sequences, a system call speeding up user-space operations on per-CPU data, made its way into the 4.18 Linux kernel.

This talk describes the basics of the rseq algorithm, going through the integration proposed for glibc 2.31. It presents the use-cases covered by the rseq system call, including memory allocators, per-CPU ring buffers, or just speeding up getting the current CPU number. Integration needed within GDB and emulators will also be discussed.

A discussion follows on the limitations of the current rseq system call, presenting missing pieces of kernel infrastructure required to cover additional use-cases.

Annobin - A Tale of A GCC Plugin's Lows & Highs

Speaker: Nick Clifton (Red Hat)

The annobin plugin for gcc has proved to be an effective component in a suite of tools designed to help system builders monitor how packages are built and verify that the necessary security options are being used. But its development and deployment has not been easy.

This talk will cover some of the trials faced whilst developing the plugin, the fixes used to overcome the harder obstabcles and some thoughts on the future of gcc plugins in general.

You will laugh, you will cry, you will wonder why you came into the presentation at all.

Annotating std::string with AddressSanitizer

Speaker: Kashkarov Mikhail, Vyacheslav Barinov (Samsung R&D Russia)

One kind of bugs that AddressSanitizer can find with the help of code annotations is "container-overflow": Given std::basic_string v a container-overflow is a memory access inside the range `[v.end(), v.begin() + v.capacity())`, i.e. inside the allocated heap region but outside of the current container bounds. Std::vector is already annotated in both libstc++/libc++, std::string is not upstreamed yet.

We'll discuss standard library sanitization process for std::string and how we applied it to the whole operation system.

c++ coroutines, function and implementation in GCC

Speaker: Iain Sandoe

Coroutines are actually one of the older computer science tools, with the term originally coined in the middle of the last century (in the early days of modern computing). This programming device is a generalisation of the concept of a function; where the generalisation is that, rather than a single entry and exit, a coroutine can be entered, paused and resumed (non-preemptively, and with retention of current state).

A formalisation of the coroutine will be a part of C++20; it was accepted into the working draft for the next International Standard at the February 2019 Working Group 21 meeting.

With the sponsorship of Facebook I have been constructing an implementation of currently proposed facility for inclusion in the GCC C++ front end (and with the necessary middle end support).

The content for the talk is in three areas:

A basic discussion of the properties of coroutines and some (necessarily simple) examples.
The current design of the implementation for GCC, and the drivers to that.
The status of the implementation and plans for the next few months.

Compact C Type Format Support in the GNU Toolchain

Speaker: Indu Bhagat, Nick Alcock, Wei-min Pan (Oracle)

Compact C Type Format (CTF) is a reduced form of debugging information whose main purpose is to describe the type of C entities such as structures, unions, typedefs and function arguments etc.

CTF originated in the Solaris kernel and it has been ported to Linux as part of the DTrace for Linux project. It's been used (via the libdtrace-ctf utility before the support in the GNU toolchain was available) to reduce the size of the debugging information for the Linux kernel and for use in DTrace.

There are many advantages to using CTF, due to its compactness, for many kinds of programs such as stack tracers and unwinders. Usually these programs can't rely on DWARF. DWARF's design (and evolution) strives for generality and expressive power, at the cost of being a rather heavy format to decode and use. For example, evaluating DWARF expressions requires a little interpreter for a stack-based machine. This, which is not problematic for typical "off-line" debugging programs such as symbolic debuggers (GDB), may be inconvenient for "on-line" debugging programs such as unwinders and stack tracers, due to efficiency and security concerns. CTF is a promising format that helps maintain some level of debuggability, even when the size of the executable is an issue and the DWARF info is being stripped out.

For such reasons it's useful to integrate CTF in the GNU toolchain on Linux. This talk will explain how CTF is structured, how we added CTF generation capabilites to gcc, how GDB consumes the CTF information and the role of linker in CTF de-duplication. binutils object file manipulation utilities have been expanded to understand and process this new format.

We believe CTF provides the right foundations for expressing the information needed by programs that need to do "on-line debugging", in a most convenient way.

Note: since the speaker for this talk can't make it to the conference, this presentation will be done remotely.

eBPF support in the GNU Toolchain

Speaker: Jose E. Marchesi (GNU, Oracle)

This talk covers the ongoing effort about adding eBPF support to the GNU Toolchain. eBPF is a virtual machine running within the Linux kernel; initially intended for user-level packet capture and filtering, eBPF has since been generalized to also serve as a general-purpose infrastructure for non-networking purposes.

Binutils support is already upstream. This includes a CGEN cpu description, assembler, disassembler and linker. By the time of the conference a simulator will be available as well, along with GDB support. A GCC backend will be submitted for inclusion upstream before September.

The first part of the talk will be a brief general description of the project, its components, what motivated us to start working on it, and an update on the project's status at the time of the conference.

Then we will discuss the particular challenges of supporting a target like eBPF:

On one hand, the kernel virtual machine has some unique characteristics that have a definitive impact on the tooling, like the in-kernel validator and the specialized contexts in which eBPF programs run. We will show how the tools can help improving the eBPF programmer's experience.

On the other hand, the exact shape of compiled eBPF code is still subject to change, and is in fact rapidly changing and evolving. Initially quite simple in terms of toolchain needs (single compilation units, no linking) this is changing as more kernel systems are being changed/written to be based on eBPF, and as the in-kernel validator is becoming more and more sophisticated. Along with bigger and more complex programs comes the need for more abstraction, hence modularity and code reuse. Kernel hackers are already discussing about bpf-to-bpf calls, run-time linking, and so on. This increased level of ambition and sophistication imposes additional requirements on the tools.

Finally, interoperability with clang/llvm (the other available toolchain supporting eBPF) will be also discussed, in the more general context of ABI and conventions for compiled eBPF, which are still to be (well) defined and documented.

GDB on s390x: To-dos and challenges

Speaker: Andreas Arnez (IBM)

While GDB on s390x is used successfully by many developers, some open issues still remain, usually induced by specialties in the ISA and/or ABI. This talk picks a few that might be of broader interest and outlines the problem, possible solution, and challenges for each.

GDB: Tab-completion & command options - frameworks for usability improvements

Speaker: Pedro Alves (Red Hat)

In the past few releases, a number of frameworks emerged within GDB with the aim of improving GDB's CLI usability. I'll talk about two: TAB-completion, and command options ("print -OPT", etc.).

TAB-completion:
- GDB 8.1 (2018) introduced a new single-pass mechanism to write GDB command completers. I'll explain what requirements led to the new design, how all the pieces fit together (completion_tracker, handle_brkchars, readline, etc.), talk about the user-visible improvements that have meanwhile been built on top since 8.1, and talk about future direction.
Command options:
- Up until recently, each and every GDB command implemented support for command options on its own, leading to user-visible inconsistencies all over the place. Also, GDB did not support TAB-completion for command options at all. The upcoming GDB 8.3 release introduces a new command option framework (gdb::option) that allows adding options to commands like "print -OPTIONS", in a GDB-ish-way, with full support for TAB-completion. I'll go over the framework's design, how all the pieces fit together, and show how to convert an existing command to use the new framework. I'll also show the "print -OPT" options, which were the first usage of the framework, the new "with" command, and more.

glibc support for Unikernel/LibraryOS

Speaker: Isaku Yamahata (Intel)

Recently unikernel/LibraryOS is getting momentum and some technologies already have been deployed in the field. glibc enhancement to help unikenrel/LibraryOS will benefit much and glibc would gain more users. Especially how to hook syscall instruction in glibc shared library. In this session, requirements/possible solution/recommended proposal/future development is discussed for feedback.

Note: since the speaker for this talk can't make it to the conference, this presentation will be done remotely.

GNU poke, an extensible editor for structured binary data

Speaker: Jose E. Marchesi (GNU)

GNU poke is a new interactive editor for binary data. Not limited to editing basic entities such as bits and bytes, it provides a full-fledged procedural, interactive programming language designed to describe data structures and to operate on them. Once a user has defined a structure for binary data (usually matching some file format) she can search, inspect, create, shuffle and modify abstract entities such as ELF relocations, MP3 tags, DWARF expressions, partition table entries, and so on, with primitives resembling simple editing of bits and bytes. The program comes with a library of already written descriptions (or "pickles" in poke parlance) for many binary formats.

GNU poke is useful in many domains. It is very well suited to aid in the development of programs that operate on binary files, such as assemblers and linkers. This was in fact the primary inspiration that brought me to write it: easily injecting flaws into ELF files in order to reproduce toolchain bugs. Also, due to its flexibility, poke is also very useful for reverse engineering, where the real structure of the data being edited is discovered by experiment, interactively. It is also good for the fast development of prototypes for programs like linkers, compressors or filters, and it provides a convenient foundation to write other utilities such as diff and patch tools for binary files.

This talk (unlike Gaul) is divided into four parts. First I will introduce the program and show what it does: from simple bits/bytes editing to user-defined structures. Then I will show some of the internals, and how poke is implemented. The third block will cover the way of using Poke to describe user data, which is to say the art of writing "pickles". The presentation ends with a status of the project, a call for hackers, and a hint at future works.

Inline expansion of string and memory instructions to improve performance on PPC64LE

Speaker: Aaron Sawdey (IBM)

This talk will describe the work I have done to improve inline expansion of strcmp/strncmp/memcmp and other string/memory functions for ppc/ppc64/ppc64le. I'll also discuss performance of inline expansion relative to glibc, and how it exposes the function expanded to all the optimization done in the back half of gcc.

Parallelizing GCC: Status and Expectations

Speaker: Giuliano Belinassi (University of São Paulo)

During GSoC 2019, there was an effort to parallelize GCC internals in the hope of decreasing build times in many-core machines as well as tracking down global states in the compiler. In this presentation, I will show the results obtained so far and discuss what can be expected based on a projection of the current results on other parts of the compiler.

Power ISA transactional memory registers in GDB (Cancelled)

Speaker: Pedro Franco de Carvalho (IBM)

Note: this talk is cancelled due to the speaker not being able to attend the event.

GDB now has support for accessing hardware transactional memory registers on POWER processors. In this talk, I will give an introduction to how transactional memory works in POWER processors, and present how the access to these registers is implemented in GDB. I will also discuss some of the existing issues with debugging programs that use transactional memory in GDB.

Reproducible Toolchains For The Win!

Speaker: Vagrant Cascadian

The Reproducible Builds project promotes a set of software development practices that create an independently-verifiable path from source to binary code, by providing bit-for-bit identical results.

A key component in building software are the toolchains used. Solving reproducibility issues at the toolchain level can sometimes fix thousands of bugs in a single place, rather than patching each individual affected package.

As an interesting side-effect, Reproducible Builds can also assist in verifying license compliance.

This talk will mention some of the past and current issues in toolchains needed to realize Reproducible Builds in the real world. Let's work together to fix outstanding issues and further these efforts!

https://reproducible-builds.org

Status update on reworking OpenACC 'kernels' support in GCC: automatic parallelization of loop nests

Speaker: Thomas Schwinge (Mentor)

With the OpenACC 'parallel' construct (and similar to the OpenMP 'parallel' and other constructs), parallelizable loops nests are explicity marked up with 'loop' directives. In contrast, in the region attached to an OpenACC 'kernels' construct, the compiler is expected to categorize loop nests on its own, identifying and parameterizing those that are suitable for parallelization.

As discussed before, the current implementation of the OpenACC 'kernels' construct is based on GCC's 'parloops' pass (a.k.a. 'pass_parallelize_loops', or 'autopar'), originally created to "distribute iterations of loops into several threads", that is, transform suitable sequential code, annotating it with OpenMP 'parallel for' directives. This implementation, extended to synthesize the corresponding OpenACC directives, turned out to not satisfy the expectations. It is quite limited in the classes of loop nests it handles. While in the OpenMP context this is just a "nuisance" (because any 'parloops' parallelization only is a "bonus" anyway), for OpenACC 'kernels' construct usage this is a real problem: it is crucial for performance to be able to handle many classes of multi-level loop nests, and adequately map these to the levels of parallelism provided by OpenACC: 'gang', 'worker', and 'vector' dimensions.

We'll give an update on the changes implemented (in process of being integrated into GCC trunk) restructuring the compilation flow of OpenACC 'kernels' constructs, and then future work, with some questions to discuss interactively.

Supporting upcoming extensions to the IBM mainframe

Speaker: Andreas Krebbel (IBM)

A future revision of the IBM mainframe architecture will provide several extensions to the instruction set.

In this talk I'll give an overview of the potential hardware changes and explain how we plan to exploit those in GCC and Glibc together with the challenges we are still facing with that.

The elfutils debuginfo server

Speaker: Frank Ch. Eigler, Aaron Merey (Red Hat)

Debugging data is a necessary evil. It is necessary for running debuggers in situ, some tracing tools, or for coredump analysis. It is evil because it is big - potentially many times the size of the binaries. Therefore, software distributions have conflicting needs to generate & keep this data but not burden everyone with its storage.

We will review some degrees of freedom for debugging data distribution, across compiled languages and OS distributions, identifying some of the best practices. We will identify the remaining shortcomings that necessitate exploring yet another way of making debuginfo data available needed.

We will present the elfutils debuginfo-server prototype, where a web service offers a lightweight, build-id-indexed lookup of debuginfo-related data on demand. This service is designed to run on a nearby host, private or shared within teams, or even by OS distributions. Clients built into various debugging type tools will be demonstrated.

Truly inter-procedural IPA-SRA pass

Speaker: Martin Jambor (SUSE)

The "Early IPA-SRA pass" introduced to GCC in 2009 is inter-procedural in the sense that it modified also the callers of the function it operated on but it scheduled as an early intra-procedural pass and this cannot handle recursion and cannot take advantage of LTO. This talk will describe its proposed replacement with a truly IPA pass, scheduled in the IPA pipe-line and operating on the whole call graph. Apart from explaining how the pass makes decisions, it will also discuss changes necessary to the call graphs clone infrastructure to actually carry out IPA-SRA decisions at the gimple level.

Lightning Talks

A New Debug Server to support modern GDB on embedded platforms

Speaker: Simon Cook (Embecosm)

GDB is now very flexible in its ability to debug modern heterogenous multi-core systems. Inferiors do not need to all be the same architecture, complex memory maps can be managed and there is flexibility on when cores and threads run. This all works well on application class platforms, where GDB can be run native, or talk remotely to the Linux gdbserver application.

However GDB servers for embedded platforms have not kept pace. Whilst tools like OpenOCD can provide a basic GDB server interface, they lack the functionality for more complex systems.

In this talk I'll present a new free debug server, capable of unleashing the full power of GDB for embedded heterogenous multicore platforms, whether those platforms are real hardware or pre-silicon simulations. The server can even support "lockstep execution", where two targets, such as a simulation and a hardware implementation are run in parallel to check for any divergence.

AMD GCN GPU Port Update

Speaker: Andrew Stubbs, Thomas Schwinge, (Mentor/CodeSourcery)

The GCN backend was introduced in GCC 9, but that only provides means for running a single thread on the GPU. Since then we've been working on preparing the OpenMP and OpenACC support for upstream. Here we present an update on the current state of the project and future plans for upstreaming.

CGEN for RISC-V

Speaker: Mary Bennett (Embecosm)

(This talk could form part of the RISC-V BoF)

This will review the current state of CGEN for RISC-V. It now supports all the standard instruction set extensions for generation of both assembler/disassember and simulation. By the time of the Cauldron it should also support the draft bit manipulation extension and have initial support for the draft 0.7 vector extension.

(Mary is unable to attend in person. This talk will be presented on her behalf by Jeremy Bennett).

Common-base store/load with RISC-V GCC

Speaker: Nidal Faour (Western Digital)

We have a patch to GCC for RISC-V which should improve code size with -Os. By using an alternative base register, short instructions can be more widely used to load and store values.

We expected this approach to yield significant benefit, and we do see modest improvements in some of our in-house programs, on the other hand the results are not significant but we don’t have any regressions. In this short talk we will summarize the approach we have taken and seek the community support to apply the patch because the benefit in some benchmarks are small, and on other test cases it show big improvements, and it is a clearly a benefit to embedded controller systems.

Compact storage and analysis of DejaGNU test logs

Speaker: Serhei Makarov, Frank Ch Eigler (Red Hat)

Upstream projects must be tested regularly on a variety of system configurations. It is easy to set up an automated testing system. It is much harder to make sense of the enormous volume of test results. When the volume of test results exceeds the developers' capacity to examine them, analysis of test results must be automated.

We will show how to use a Git repo to compress, index, and analyze a large collection of log files from a DejaGNU testsuite. The result is a small and portable dataset (e.g. ~88GB of log files compress to a ~1.4GB Git repo, including an index in JSON format). The indexed log files can be filtered and analyzed with simple Python scripts to detect problems and regressions.

We will summarize some experiments on test results collected from the DejaGNU testsuites of the SystemTap and GDB projects.

Function address significance and nop+fallthrough aliases

Speaker: Alexander Monakov (ISP RAS)

Occasionally GCC needs to emit very short functions that almost immediately branch to another function. In particular, they arise from C++ thunks and also from trivial wrappers created by the ICF (identical code folding) pass when creating function aliases is not possible. GCC places such wrappers and thunks after the branched-to function, which is suboptimal. Ideally function deduplication could use "nop" instructions to separate initial labels of duplicate functions when their addresses are significant.

RISC-V bit manipulation extension

Speaker: Maxim Blinov (Embecosm)

(This talk could form part of the RISC-V BoF)

During this summer I have worked with Jim Wilson and Clifford Wolf to complete support for the draft bit manipulation instruction set extension in GCC. I'll present the result of that work, along with benchmark results using Embench.

Tweaking the compiler for fewer false negatives in -Wuninitialized

Speaker: Vladislav Ivanishin (ISP RAS)

The analysis of uninitialized variables in GCC is known to both produce spurious warnings and fail to report true uninitialized uses. We experimented with adjusting its implementation to reduce false negative rate.

Another objective was having the warning work regardless of the optimization level. To achieve both these goals we moved the pass very early in the pipeline. This indeed uncovered some warnings the mainline compiler misses on some real software (all of them due to the CCP pass folding an undefined value and a constant into that constant) -- but predictably at the cost of raising many more spurious warnings. The rest of the effort was spent suppressing those, mainly via adding essential transformation passes before the warning pass.

This work also uncovered some latent bugs in the predicate aware uninitialized variable analysis, improvements were submitted upstream.

Using combined elimination with GCC to minimize compiled code size: A case study

Speaker: Craig Blackmore (Embecosm)

Combined elimination is a type of iterative compilation. It is not as comprehensive as an exhaustive search (which is intractable), but can yield large improvements, while being quick enough to run with real projects.

I'll present the results of using Combined Elimination with GCC to minimize the size of code compiled for 32-bit RISC-V.

Using Embench to measure the performance of GCC for deeply embedded targets

Speaker: David Patterson (UC Berkeley), Jeremy Bennett (Embecosm, presenter), Cesare Garlati (Hex Five), Palmer Dabbelt (SiFive)

Embench is a GPL licensed benchmark suite developed by a team under the leadership of David Patterson at Berkeley. Embench is derived from BEEBS, which in turn derives from a number of other free benchmarks suites. In its initial form it is aimed at deeply embedded platforms, with up to 64kB of RAM and 64kB of ROM, such as are widely used in IoT devices.

I'll present the results of using Embench to compare GCC performance for several popular embedded architectures, and look at what conclusions can be drawn from the results.

Birds of a Feather (BoFs)

20+ years after EGCS, rethinking GCC development processes

Led by: Jeff Law (Red Hat)

20+ years ago the EGCS project was unveiled in an effort to jump start GCC development. The time has come to evaluate our development practices to help ensure a viable development community in the future. Maintainers vs consensus, patches vs pull requests, regression testing vs continuous testing, development schedules, release criteria, coding conventions, automated tools, etc it's all up for discussion. Ideally we will leave with 3-5 concrete ideas to experiment with to reduce friction for GCC developers.

C++ hardware_constructive/destructive_interference_size

Led by: Thomas Rodgers (Red Hat)

C++17 introduced two new constants:

std::hardware_destructive_interference_size
std::hardware_constructive_interference_size

Which are supposed to be the minimum size/alignment to avoid (encourage) false-sharing (see https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size).

While we could certainly default these values to '64' and that would work well for many of the targets that GCC supports, some intrinsics support from the compiler to get the appropriate size would be a better alternative.

This BoF proposal is to discuss how we might support this, particularly for architectures like ARM where the size may be either 32 or 64.

C++ Modules & Tooling

Led by: Nathan Sidwell (Facebook)

C++20 will have a module system. This places new constraints on the order of source file compilation. Preprocessing as a separate step becomes complex. Compiler bug reporting will not be a simple as providing preprocessed output. How can build systems, from Make onwards, adjust? What changes might be needed for compiler bug fixing?

GCC/LLVM Collaboration BoF

Led by: Jeremy Bennett (Embecosm)

The goal of this BOF is to discuss the current state of and ways to improve collaboration between the gcc and LLVM projects. Proposed topics to discuss include: Collaboration on issues related to language standards, changes to existing standards or implementing new ones. Maintaining ABI compatibility between the compilers. Interoperability between tools and libraries e.g. building with clang and libstdc++ or building with gcc and linking with lld. As well as communication channels for developers via bugzilla or mailing lists.

GDB tests, CI & Buildbot BoF

Led by: Sergio Durigan Junior (Red Hat)

Even though we require a testcase for every new non-trivial patch, and despite expecting that each contributor will run the testsuite and make sure no regressions happen, the reality is that we are usually chasing regressions more often than not, especially if you are responsible for a downstream GDB release. In my experience, much of the regressions introduced are already being caught and reported by our Buildbot, but gdb-testers is currently just serving as a justification for Sourceware admins to buy more disk, so it's hard to keep track of them.

In this BoF the GDB community will be able to get together and discuss the current state of our testsuite, ideas to improve our Buildbot infrastructure and how to be increase the quality of our Continuous Integration efforts.

glibc development workflows

Led by: Florian Weimer (Red Hat)

glibc upstream developers show each other how they develop new patches and tests.

GNU Toolchain Advocacy BoF

Led by: David Edelsohn (IBM)

Discussion about promoting and sustaining the GNU Toolchain projects

OpenACC/OpenMP/offloading (OMP, Offloading and Multi Processing) BoF

Led by: Thomas Schwinge (Mentor)

This is an interactive BoF to discuss all things OMP (Offloading and Multi Processing): from front ends (programming abstractions: OpenACC, OpenMP, CPLEX (C Parallel Language Extensions), modern C++, others?) to multicore or heterogeneous offload targets/GCC back ends (Nvidia PTX, AMD GCN, others? -- ..., and what's going on with Intel MIC, HSA/HSAIL?) -- and everything in between: middle end abstractions. Optimizations, such as automatic vectorization/parallelization (parloops/autopar, graphite, polly, others?). Compilation flow in GCC (LTO model vs. HSAIL model). Issues with non-trivial GCC offloading build configuration, problems for packagers, GNU/Linux distributions.

Optimising SPEC CPU 2017 with GCC

Led by: Kyrylo Tkachov, (Arm toolchain performance team)

Optimising the SPECCPU 2017 benchmarks with GCC is of interest to many GNU community members.

In this BoF we'll present some of the more high gain opportunities we (the Arm toolchain performance team) have identified and invite fellow community members interested in SPEC to present on their findings.

This is an opportunity to set up a collaborative roadmap of optimisations, discuss, and gather feedback on how to make them versatile enough to integrate into trunk.

Project Ranger: On demand, precise value ranges. Overview, status, & plans for gcc-10 and beyond.

Led by: Andrew Macleod, Aldy Hernandez, Jeff Law (Red Hat)

Ranger is an on-demand infrastructure for computing ranges of SSA_NAMEs at a given statement. The on-demand nature allows passes which only need ranges for a subset of SSA_NAMEs to get those ranges much more efficiently than using an embedded EVRP analyzer. Ranger performs comparably to EVRP when computing ranges for all SSA_NAMEs in the IL. Ranger generally provides ranges that are as good as or better than VRP/EVRP.

We'll be discussing the current state of the ranger work, integration plans, how it can be used to improve optimization, how it can be used to improve warning precision or avoid false positives, future plans, etc.

Register allocation

Led by: Peter Bergner (IBM)

This BoF is intended to allow the GCC community and interested parties to come together and discuss topics relevant to IRA and LRA. I will discuss work I have done recently as well as potential work items. This is your chance to interact with RA developers, so please bring your thoughts, pain points, wishes and ideas for all of us to discuss.

rs6000/PowerPC/Power

Led by: Segher Boessenkool (IBM)

The place to discuss anything Power.

Signaling floating point comparisons

Led by: Segher Boessenkool (IBM)

All floating point comparisons should exist in both a signaling and a quiet form. Languages say which of those to use when. Currently, neither in GIMPLE nor in RTL we represent this properly, making it hard or impossible to do various simple optimisations. It is also harder than needed for backends to support it.

Let's talk about how to make things better.

The Arm / AArch64 BoF

Led by: Ramana Radhakrishnan (Arm)

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.

The GDB BoF

Led by: Pedro Alves (Red Hat)

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

The GNU C Library BoF

Led by: Carlos O'Donell, Florian Weimer (Red Hat)

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.31 and what work needs to be done between August 2019 and January 2020.
Planning for glibc 2.32 and what work needs to be done between January 2020 and July 2020.

... and more.

The LTO/IPA BoF

Led by: Jan Hubicka (Suse)

Discussion about recent LTO and IPA developments in GCC.

The RISC-V BoF

Led by: Palmer Dabbelt (SiFive), Jeremy Bennett (Embecosm)

A session discussing all things RISC-V related.

Q&A Sessions

GCC Steering Committee Q&A

Led by: David Edelsohn

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

None: cauldron2019talks (last edited 2019-10-08 17:16:31 by SimonMarchi)