Andrew MacLeod GCC re-architecture II BOF

A follow-on to the Cauldron 2013 BOF discussing a move towards better source base
modularization. At that time a rough prototype was shown which replaced tree macros with c++
wrapper classes allowing the interface used in the gimple back-end to be abstracted away from
the implementation details of trees.

The design has been flushed out and the various merits of the new interface classes will be
discussed. Also discussed will be a forward looking plan of future work leading to separation of
the front ends from the gimple middle/back end. A complete document will be available on the
mailing list.
Author Presentation Title Presentation Abstract
Carlos O'Donell GNU C Library BOF
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.21 and what work needs to be done
between the August -> January 2015 timeframe.

* Infrastructure
- The sysdeps sorting issues.
- The abilist issue (raised recently when IBM wanted
to add ppc64le support).

* Testing
- Testing in chroots.

* Performance?
- Status of microbenchmarks?

* libm
- Status of alternate libm implementations.
- Planning work against gcc requirements.

* Tuning the C library?
- Status of review of existing usage of env vars.
- Status of work to bring together tunnables internally.

* POSIX conformance
- Cancellation discussions.

* IPv4 and IPv6
- Next steps to solve more getaddrinfo problems.
David Edelsohn Steering Committee Q&A
David Edelsohn PowerPC BoF
Author Presentation Title Presentation Abstract
David Malcolm Just-In-Time compilation using GCC (libgccjit.so)
This will be a report on http://gcc.gnu.org/wiki/JIT - the
current status of this branch of gcc, along with a discussion of how we
could go about merging it into the trunk. I'll also talk about things
we could do to both GCC and to the rest of the GNU toolchain (e.g. gas)
to better support the JIT use-case from GCC.
David Malcolm A proposal for typesafe RTL
The backend code's ENABLE_RTL_CHECKING ensures that only valid
combinations of RTL are constructed, but this option is painfully slow
to use, so AFAIK very few people with it, and only when close to release
time.

I'll talk about an approach I've been experimenting with in which the
RTL codes are expressed in a simple way in the C++ type-system, so that
this checking can be done when the compiler is built, rather than at
run-time, allowing the checking to be on for all developers, throughout
the development cycle. As a further benefit, I believe it makes the
backend code significantly more readable.
Dodji Seketell
Libabigail: Toward ABI compatibility checking

Checking and reporting about the meaningful differences in the
application binary interfaces of two versions of a given library has
been a challenge for some time. To help tame that beast, the ABI
Generic Analysis and Instrumentation Library intends to provide
capabilities to analyze binaries and empower tools willing to build upon
that capabilities.

This talk will present the work done on Libabigail and its associated
tools since we introduced the project at the previous GNU Cauldron in
Mountain View in 2013 and will talk about the future of the project.
Ilya Enkovich
Overview of Pointer Checker implementation in
the GCC compiler
Invalid memory access problem is commonly found in many C/C++ programs and leads to time
consuming debugging, program instability and vulnerability. Many attacks exploit software bugs
related to inappropriate memory accesses caused by buffer overflow (or buffer overruns).
Existing set of techniques/tools to find such memory bugs in the programs and defend them
from the attacks are software only solutions which result in poor performance of the protected
code so it looks like processor manufacturers start addressing these issues like Intel in its Intel
Memory Protection Extensions (MPX) technology.

Here we present what we called Pointer Bounds Checker - set of passes and new features in
the GCC compiler which implement code instrumentation for buffer overflow checking. Pointer
Bounds Checker was developed to support Intel MPX but was implemented in a generic way
allowing a pure software solution. In presentation we talk about approach in general, how it may
be used for other targets that support buffer overflow checking in hardware and also cover some
implementation details.
Author Presentation Title Presentation Abstract
Jan Hubicka / Ondrej
Bilka
Devirtualization in GCC
In this talk I review the new implementation of devirtualization in GCC. I
explain details of the type inheritance graph construction, basic type based
devirtualization and devirtualization via low level propagation. I compare
effectivity of both methods. I also describe speculative devirtualization both
by type inheritance graph analysis and by profile feedback and show their
effectivity on bigger software projects (firefox, libreoffice). Finally I also
discuss adding new warning about missing final and anonymous namespace
specifiers with LTO.
Jan-Benedict Glaw Build robot BoF Build robot BoF (http://toolchain.lug-owl.de/buildbot/timeline.php)
Jeremy Bennett
Machine Guided Energy Efficient Compilation
system
Two years ago we showed that choice of compiler optimizations has a
significant impact on the energy used by the compiled program. Last year
we presented the initial design for the Machine Guided Energy Efficient
Compiler (MAGEEC). MAGEEC is a plugin for GCC (and other compilers)
which integrates with a machine learning system, to allow the compiler
to learn which optimizations will generate the most energy efficient
code for any particular program and architecture.

The first version of MAGEEC is almost complete. In this talk we will
give the first ever public demonstration of MAGEEC in operation. The
talk will also explain in detail the implementation, describe
outstanding issues that are still being worked on, compare with the
implementation for LLVM, and look at issues around the scalability of
this approach.

Embecosm and Bristol University would like to thank the UK Technology
Strategy Board, whose support has made this development possible.
Kirill Yukhin
Introduction to new Intel SIMD ISA and its impact
on GCC
Kostya Serebryany /
Evgeniy Stepanov
News from Sanitizers
First, you will learn about MemorySanitizer, a detector of uninitialized memory use based on
compiler instrumentation. Then, well tell you about various additions to AddressSanitizer, such
as code coverage instrumentation, container-overflow annotations for libc++/libstdc++, and
LeakSanitizer (a leak detector). Finally, you will hear our complaints about Glibc and GCC.
Luis Machado Extending GDB's XML descriptions
With every new GDB port, there are mechanical changes that one should go through to make it
work. Those are usually hardcoded and need a new GDB build with every change.

By extending GDB's XML descriptions, we may have a more flexible and configurable debugger
that can cope with slight variations of processors. Small changes would then be added without
the need to rebuild GDB.
Author Presentation Title Presentation Abstract
Martin Jambor
Recent and future development in GCC
interprocedural propagation
In the recent years, the amount of data tracked by GCC interprocedural
(IPA) propagation has increased significantly and it is also being
used in new ways. The talk will especially describe propagation of
data passed in non-scalar types and by reference, IPA data tracking
and escape analysis. I would like to include a short discussion about
how IPA propagation might leave information useful in later stages of
compilation, for example for the value range propagation but also for
diagnostics (e.g. warning specific to clones).
Michael Haupt
Writing VMs in Java and Debugging them with
GDB
Part of the Alphabet Soup project at Oracle Labs deals with developing a lightweight virtual
machine: the Substrate VM is able to host programming language implementations built with the
Truffle framework for AST interpreters and the Graal dynamic compiler. All of these, including
Substrate VM, are implemented in Java and bootstrapped to stand-alone binaries. As
debugging such VMs with standard Java tools is not possible, we devised a strategy for
generating appropriate DWARF information to support debugging with standard tools such as
GDB. The talk describes the Substrate VM, exemplifies programming language implementations
atop it, and reports on experiences with DWARF and GDB.
Author Presentation Title Presentation Abstract
Michael Meissner
rs6000 backend improvements for Power ISA
2.07
In this talk, I will talk about upgrading the GCC compiler rs6000 backend to
add support for the new features in Power ISA 2.07 that will appear in future
IBM power servers. This talk will focus on the new features in the hardware
and the GCC changes in the 4.9 code base, and changes being planned for the
4.10 code base.

The features that will be discussed include:

* Adding support for little endian support in the Power server series.

* Adding support for hardware transactional memory, including dealing with
places where the power hardware has a different model of the world compared
to the x86 systems.

* Adding support for the new direct move instructions that can copy data
between the general purpose registers and vector registers.

* Adding support for 128-bit memory operations to/from the general purpose
registers, including atomic operations.

* Adding support for allowing scalar floating point variables to occupy the
Altivec registers beyond the traditional floating point support.

* Adding support in the future for software emulation of IEEE 128-bit floating
point, so that in the future we can plan to switch the long double type to
IEEE 128-bit.

* Adding support for addition instructions through miscellaneous builtin
functions, and challenges that adding these builtins created. The types of
builtins that were added include cryptological, population count, count
leading zeros, new vector logical instructions, various instructions to
permute data, support of 128-bit integer add/subtract, and support of
128-bit integer decimal support.

* Finally, we will talk about some of the other changes that we are
contemplating making to the power backend in the GCC 4.10 time frame.
Author Presentation Title Presentation Abstract
Paul Zimmermann Numerics BoF
Numerics BoF

* how MPFR and MPC can be more useful for gcc/glibc ?

* how can we help improving the IEEE-754 2008 conformance of GNU libc
mathematical functions, in particular using the MPCHECK tool we are
developing, see http://webloria.loria.fr/~zimmerma/glibc/

* how can we extend MPCHECK to complex numbers
Author Presentation Title Presentation Abstract
Phil Muldoon GCC-GDB compile and inject code proposal
Here at Red Hat a small team has been working on a project to compile
and inject code into a "live" GDB session.

A simple demo would be:

(some inferior is stopped in GDB)
(gdb) compile code int f = 42; printf ("Total is %d\n", f + foo);
Total is 50

Where "f" is a variable you just declared in the code block, and "foo"
is an already existing inferior variable with the value of 8. You can
create local variables and types in the code, and also reference and
assign inferior variables, inferior types, etc. All of this comes
with a number of caveats. You can do much more than the above
example, but that is just a direct short example for this email.

The project consists of two separate modules.

The GCC plugin side:

https://github.com/tromey/gcc/tree/gdbjit

and the GDB component:

https://github.com/tromey/gdb

You can build both projects in the usual way. You must add the .so
from the GCC side to LD_LIBRARY_PATH, and also the installed GCC to
PATH. There are a number of symlinks you must create currently. I
won't list them here, but they are easy to find (GCC won't build
without them). This is just for convenience right now.

Both branches are called "gdbjit". That's a legacy name -- we have
tried to keep away from the "jit" naming.

The project is still in its early phases. You can compile and inject
"C" code at the moment. There are, as usual, with any project in
incubation, many caveats and likely bugs.
Author Presentation Title Presentation Abstract
Pierre Langlois GDB and multiple address space architectures.
GDB has limited support for multiple address space architectures, the most
common example being Harvard architectures. This talk will present the current
state of GDB in this regard, my recent work on improvements to support the Atmel
AVR, and some suggestions for how GDB can be further improved to support such
architectures.

This issue was already addressed in the past with support for the SPU processor
and its use of a dedicated address space to talk to its host processor. In the
embedded world, multiple address spaces are very common and can go beyond just
separating code and data. For instance, the AVR architecture has a different
address space for accessing EEPROM memory, as well as being a pure Harvard
architecture.

This talk will cover:

* Supporting address spaces in GDB's type system.
* The relationship between addresses as seen by GDB and their architectural
counterpart.
* How to use and detect space qualifiers, using debugging information to
set the address space.
* Extending the remote serial protocol.

We are actively working on GDB for multiple address space architectures, and so
the talk will also include any other issues arising from our work between now
and the GNU Cauldron.
Ramana
Radhakrishnan
ARM/AArch64 BoF
Renato Golin
GCC and LLVM collaboration / The Open Source
Compiler Initiative
With LLVM mature enough to feature as the default toolchain in some
Unix distributions, and with the inherent (and profitable) share of
solutions, ideas and code between the two, we need to start talking at
a more profound level. There will always be problems that can't be
included in any standard (language, extension, or machine-specific)
and are intrinsic to the compilation infrastructure. For those, and
other common problems, we need common solutions to at least both LLVM
and GCC, but ideally any open source (and even closed source)
toolchain. In this BoF session, we shall discuss to what extent this
collaboration can take us, how we should start and what are the next
steps to make this happen.
Richard Biener
Unifying GENERIC and GIMPLE folding with a
pattern description
We present the ongoing work on providing infrastructure to unify
the GENERIC folding in fold-const.c and the GIMPLE folding in
gimple-fold.c and tree-ssa-forwprop.c into a single source
from which code operating on GENERIC and GIMPLE is autogenerated.
Author Presentation Title Presentation Abstract
Simon Marchi RPC debugging with GDB
Title: RPC debugging with GDB
Authors: Simon Marchi and Michel Dagenais
Abstract:
Remote procedure call (RPC) libraries help building
distributed applications by giving the illusion that a program can
call a function in another process, possibly on another system.
Standard source-level debuggers, which are invaluable tools when
it comes to pinpointing the root of a software problem, become
less effective when one uses RPC. We propose an extension
framework to the GDB debugger that detects remote procedure
calls and allows the developer to step from the client code
to the server code whenever such a call is made. We show
that it is possible with little effort to adapt the framework to
existing, generic RPC libraries. This benefits directly developers
of existing applications using those libraries. We also show
that the framework may be used with minimal effort to debug
applications that implement their own RPC scheme.
Author Presentation Title Presentation Abstract
Thomas Schwinge Accelerator BoF
In this BoF, we will discuss how we can support accelerators (e.g.,
GPGPUs) in GCC. This is a rather wide problem and raises questions
ranging from which programming abstractions to support (e.g., OpenMP
4.0 accelerator extensions, OpenACC, and others) to which accelerator
(virtual) ISAs to support -- and everything in between. The goal of
this session is to continue the discussion started in last year's
Accelerator BoF, quickly review what has happened since, and
coordinate which next steps to take. Possible sub-topics for
discussion include:

* Front-end issues: Which programming abstractions for
parallelization on accelerators at the programming-language level
do we target? OpenMP 4.0 will include accelerator abstractions;
OpenACC has similar features. Are there features that are shared
across several programming abstractions (e.g., ways to put
constraints on regions of code so that it can indeed be executed
on a particular accelerator)?

* Which infrastructure do we need in the middle-end to support
different language-level abstractions without a lot of duplicated
code? Which GCC-internal abstractions do we need? Can we have a
single shared internal representation of accelerator code? How
do we deal with issues such as heterogeneous accelerator hardware
or separate address spaces on accelerators? How do we represent
communication between hosts and accelerators? Is the current
SIMD support sufficient for accelerator code too?

* Back-end questions: Which (virtual) architectures do we want to
target first? Should we target low-level programming
abstractions such as OpenCL, too? Which additional runtimes do
we want to -- or need to -- bind to? Can/should we target
existing runtimes, or do we need to build our own (glue) layers?

* Testing: Do we need anything special to test all of this?

* Other GNU tools: What do we need to do in other tools such as
GDB?
Author Presentation Title Presentation Abstract
Ulrich Weigand The new little-endian PowerPPC64 ABI
PowerPC processors have long supported both big-endian and
little-endian modes of operation. However, the 64-bit
server operating system space used to be big-endian only.
This has recently begun to change, due both to improved
little-endian support in recent POWER hardware, and emerging
new use cases that require little-endian support. As a result,
several 64-bit little-endian Linux distributions are currently
being worked on.

Given that this constitutes a new architecture with no
pre-existing code base, we had the rare opportunity
to define a new ABI for the little-endian 64-bit platform.
While this is still based in large parts on the existing
big-endian PowerPC64 ABI used on both Linux and AIX, we
had the chance to address a number of issues that had been
coming up over the 25-year history of the old ABI.

In this talk we'll give an overview of the approach we
took in designing the new ABI. The basic design goals
were to make the platform more similar to others to simplify
porting, to create better opportunities to exploit recent
hardware capabilities, and to improve performance of
modern code patterns. We'll address some of the trade-offs
we had to make, and outline the core features of the new
ABI that resulted from this process.

The new little-endian PowerPC64 ABI has now been implemented
throughout the GNU toolchain, and work is continuing to port
additional packages (LLVM, valgrind, Mozilla, ...) as well.
In the presentation we'll also address the current status of
the porting effort and describe the toolchain changes that
were necessary to implement the new ABI.
Author Presentation Title Presentation Abstract
Yao Qi Performance Testing for GDB
GDB development process has no standard mechanism to show the
performance of GDB snapshot or release is improved or worsened.
Performance regressions do show up periodically.

We recently add a new performance testing framework in GDB. In
this session, we introduce this performance testing framework and
show how do we use it to track GDB performance during development.
Then, we show writing performance test cases on top of this framework
and performance problems exposed by these cases.

Finally, we discuss about adding more test cases and fixing other
performance problems in the future.
Ondrej Bilka Glibc performance tuning
Techniques employed to improve glibc performance, there are several
considerations:
What is performance anyway?
How use knowledge of input data?
How to actualy improve performance.
Author Presentation Title Presentation Abstract
Uday P. Khedker
Sheweta Tharani
Aniket Deole
Design, Implementation, and Evaluation of
specRTL: A New Specification Mechamism for
GCC Machine Descriptions
Although GCC machine descriptions have been quite successful, they are
difficult to read, construct, maintain, and enhance because of the
verbosity, repetitiveness, and the amount of details.

We present the design, implementation, and evaluation of specRTL which
provides a compositional specification mechanism for defining patterns
that describe RTL templates in machine descriptions. These patterns can
be refined by extending them and by associating concrete details with
them in a need based manner.

In essence, specRTL takes to the logical conclusion, Davidson-Fraser's
key insight that RTL statements are target dependent but their forms
are not. Although, GCC's code generation is based on Davidson-Fraser's
model of compilation, somehow GCC missed taking the idea to its logical
conclusion as far as the specification mechanism is concerned.

The specRTL compiler reads machine descriptions in the new form and
generate the conventional machine descriptions. This enables external,
incremental and non-disruptive migration of the existing machine
descriptions to specRTL and construction of new machine descriptions.

We have rewritten the i386 and MIPS machine descriptions using specRTL
and have computed their reusability factors which measure the extent
to which patterns are composed of other patterns. The higher the
reusability factor of a machine description, the easier it is to
read, write, and maintain. Our empirical measurements corroborate our
intuitions that specRTL machine descriptions are easier to read, write,
and maintain.

(This work is a logical conclusion of the preliminary work presented in
the GROW 2011 workshop.)
Author Presentation Title Presentation Abstract