Proceedings of the GCC Developers Summit. June 17th 19th, 2008 Ottawa, Ontario Canada

Size: px

Start display at page:

Download "Proceedings of the GCC Developers Summit. June 17th 19th, 2008 Ottawa, Ontario Canada"

Marjory Mathews
5 years ago
Views:

1 Proceedings of the GCC Developers Summit June 17th 19th, 2008 Ottawa, Ontario Canada

3 Contents Enabling dynamic selection of optimal optimization passes in GCC 7 Grigori Fursin Using GCC Instead of Grep and Sed 9 Taras Glek Middle-End Array Expressions 11 Richard Guenther Adding Coding Rule Checking Capabilities to the GCC Toolchain 13 Guillem Marpons Improving the precision of GCCs debug information 15 Michael Matz Towards an implementation of Co-Array Fortran 17 Toon Moene Exploiting front end knowledge to effortlessly create Python modules 19 Gaius Mulley A Plan to Fix Local Variable Debug Information in GCC 21 Alexandre Oliva Improving GCC Infrastructure for Streamization 23 Sebastian Pop Feedback Directed Optimization using Synthetic Edge Profiles from Hardware Event Sampling 25 Vinodha Ramasamy A Superoptimizer Analysis of Multiway Branch Code Generation 27 Roger Anthony Sayle

4 Non-stop Multi-Threaded Debugging in GDB 29 Nathan Sidwell A New ELF Linker 31 Ian Lance Taylor Incremental Compilation for GCC 33 Tom Tromey

5 Conference Organizers Andrew J. Hutton, Steamballoon, Inc., Linux Symposium, Thin Lines Mountaineering C. Craig Ross, Linux Symposium Review Committee Andrew J. Hutton, Steamballoon, Inc., Linux Symposium, Thin Lines Mountaineering Ben Elliston, IBM Janis Johnson, IBM Mark Mitchell, CodeSourcery Toshi Morita Diego Novillo, Google Gerald Pfeifer, Novell Ian Lance Taylor, Google C. Craig Ross, Linux Symposium Proceedings Formatting Team John W. Lockhart, Red Hat, Inc.

6 Authors retain copyright to all submitted papers, but have granted unlimited redistribution rights to all as a condition of submission.

7 Enabling dynamic selection of optimal optimization passes in GCC Grigori Fursin Your affiliation Abstract 7

8 8 Enabling dynamic selection of optimal optimization passes in GCC

9 Using GCC Instead of Grep and Sed Taras Glek Your affiliation Abstract 9

10 10 Using GCC Instead of Grep and Sed

11 Middle-End Array Expressions Richard Guenther Your affiliation Abstract We are implementing support for array objects as firstclass citizens of the tree middle-end. This allows to retain expressions that operate on array objects, such as allowed by the Fortran 9x language, to survive until the high-level loop transformation passes. Those benefit from the lesser work on loop and dependence analysis. Lowering those expressions leveraging work done by the GRAPHITE project allows to do a better job of what is currently done by the frontend and allows faster code to be generated. As a design and implementation proposal we expect this to be a medium term project as for utilization it requires modifications of the Fortran frontend as well as merging GRAPHITE and/or fallback lowering code in the middle-end to handle all expressions on array objects as allowed by the Fortran standard. We also present a proposal for a GCC extension to allow utilizing the new facility from C and C++ using VLA types and builtin functions. 11

12 12 Middle-End Array Expressions

13 Adding Coding Rule Checking Capabilities to the GCC Toolchain Guillem Marpons Your affiliation Abstract 13

14 14 Adding Coding Rule Checking Capabilities to the GCC Toolchain

15 Improving the precision of GCCs debug information Michael Matz Your affiliation Abstract 15

16 16 Improving the precision of GCCs debug information

17 Towards an implementation of Co-Array Fortran Toon Moene Your affiliation Abstract Co-array Fortran is an extension of Fortran having been defined around a decade ago to allow for asynchronous parallel programming within the Fortran language, as opposed to methods outside the language (via the OpenMP standard and the MPI library). It will be part of the upcoming Fortran 2008 Standard. As the description by one of its authors mentions: "A Fortran program containing co-arrays is interpreted as if it were replicated a fixed number of times and all copies were executed asynchronously. Each copy has its own set of data objects and is called an image. The array syntax of Fortran is extended with additional trailing subscripts in square brackets to give a clear and straightforward representation of access to data on other images." The presentation will describe the changes in the parser, intermediate representation and run-time library of GNU Fortran necessary to implement co-array Fortran. In addition, it necessarily will discuss various paradigms in parallel computing. 17

18 18 Towards an implementation of Co-Array Fortran

19 Exploiting front end knowledge to effortlessly create Python modules Gaius Mulley Abstract This paper presents the techniques used in GNU Modula-2 to automatically generate swig header files from definition and implementation modules. The swig interface files allow any swig supported scripting language to interface to an implementation module compiled as a shared library. The advantage with this technique is that most of the information necessary to construct these swig interface files is already known by the front end compiler. The compiler works out whether parameters are in, out or inout by examining their usage in the initial basic-block of each procedure. It also translates globally exported simple typed variables, enumeration types and allows exceptions to be thrown and caught by the library and scripting language respectively. This technique has been coupled with the automatic creation of shared libraries, initialisation and finalisation sections and dependency linking. Thus it allows users to recompile legacy code as a series of shared libraries and present them as a set of Python, Perl or TCL modules by including some additional flags on the compiler command line. 19

20 20 Exploiting front end knowledge to effortlessly create Python modules

21 A Plan to Fix Local Variable Debug Information in GCC Alexandre Oliva Your affiliation Abstract 21

22 22 A Plan to Fix Local Variable Debug Information in GCC

23 Improving GCC Infrastructure for Streamization Sebastian Pop Your affiliation Abstract GCC needs a strategy to support future multicore architectures, which will certainly include heterogeneous accelerator-like designs with explicit management of scratchpad memories; some have further restrictions, for example SIMD, with limited synchronisation capabilities. Meanwhile, we also anticipate that some platforms will offer hardware support for streaming, transactions and speculation. The purpose of this paper is to give a survey and evaluation of some automatic and manual techniques for improving support for such targets in GCC. We focus on translation of sequential code for such platforms i.e. the translation to vector operations and to task graphs and their communication and memory access operations. We conclude with recommendations for strategic development of the compiler to meet these challenges. Authors: Harsha Jagasia, Paul H J Kelly, Razya Ladelsky, Antoniu Pop, Sebastian Pop, Jan Sjodin 23

24 24 Improving GCC Infrastructure for Streamization

25 Feedback Directed Optimization using Synthetic Edge Profiles from Hardware Event Sampling Vinodha Ramasamy Your affiliation Abstract 25

26 26 Feedback Directed Optimization using Synthetic Edge Profiles from Hardware Event Sampling

27 A Superoptimizer Analysis of Multiway Branch Code Generation Roger Anthony Sayle Your affiliation Abstract Code Generation The high-level of abstraction of the multiway branch, exemplified by C/C++ s switch statement, Pascal/Ada s case and FORTRAN s computed GOTO, allows a compiler a large degree of freedom in its implementation. Typically compilers generate code selected from a few common patterns, such as jump tables and/or trees of conditional branches. However, for most switch statements there exists a vast number of possible implementations. To assess the relative merits of these alternatives, and evaluate the selection strategies used by different compilers, a switch-statement "superoptimizer" has been developed. This exhaustively enumerates code sequences implementing a specified multiway branch. Each sequence is evaluated against a simple cost model for code-size, average and worst-case performance (optionally using profile information). Backend timings for several architectures are parameterized by microbenchmarking. The results and insights from applying this superoptimizer to a corpus of "real-world" examples will be discussed. 27

28 28 A Superoptimizer Analysis of Multiway Branch Code Generation

29 Non-stop Multi-Threaded Debugging in GDB Nathan Sidwell Your affiliation Abstract When debugging a multi-threaded program, should a debugger stop all threads when any thread stops, or should it stop only those threads that have something to report, like a breakpoint hit? When debugging a live system, the latter approach may be less intrusive, as threads other than those under inspection can continue to respond to external events. We have implemented this behavior, which we call non-stop debugging, in the GNU Debugger, GDB. We have adapted GDB s control commands, strengthened GDB s event loop, extended GDB s remote protocol, and implemented new techniques for inserting, removing, and stepping past breakpoints. This project lifts long-standing restrictions in GDB s thread support, using a number of interesting techniques. It opens a way to supporting multi-process and multi-core debugging. 29

30 30 Non-stop Multi-Threaded Debugging in GDB

31 A New ELF Linker Ian Lance Taylor Your affiliation Abstract 31

32 32 A New ELF Linker

33 Incremental Compilation for GCC Tom Tromey Your affiliation Abstract 33

34 34 Incremental Compilation for GCC

Proceedings of the GCC Developers Summit

Reprinted from the Proceedings of the GCC Developers Summit June 17th 19th, 2008 Ottawa, Ontario Canada Conference Organizers Andrew J. Hutton, Steamballoon, Inc., Linux Symposium, Thin Lines Mountaineering