Google Summer Of Code

Thank you for your interest in the GNU Compiler Collection as your mentoring organization in Google's Summer of Code (GSoC). GCC has been accepted as a GSoC mentoring organization in 2024. The primary org-admin is Martin Jambor.

If you would like to be a GSoC contributor with GCC, first make sure you read the Before you apply and Application sections on this page and then pick a project, possibly from the list below. After you made your selection or have a project idea of your own, please discuss it as soon as possible (way before the application) via the gcc@gcc.gnu.org mailing list (put "GSoC" somewhere to the subject) and feel free to raise it on IRC. If you are interested in gcc-rust topics, you can also reach out to the gcc-rust community via Zulip.

Selected Project Ideas

When discussing GSoC project ideas in the community, we have found out we are especially interested in the following few. One of their main advantages, apart from their particular relevance and usefulness this year, is that we are confident we can find mentors for them. We will however also consider other projects and we will be happy to discuss your own ideas with you. Nevertheless, please do consider applying for the following:

The expected outcome of all projects listed above is a series of patch submissions which pass review and are included in the main GCC repository, the GCC-Rust project repository (for Rust-related projects) and/or binutils (e.g. the demangler code is shared between GCC and binutils).

Unless a project above was explicitly marked with a different difficulty, consider it to be hard. Generally speaking, GCC is a production compiler and working on one of those is always hard, especially if you are new. On the other hand, the community of GCC developers is very helpful and goes out of its way to assist newcomers with various difficulties they inevitably encounter.

If the list above was not exhaustive enough for you, you can have a look also at Other Project Ideas section below.


Before you apply

Applicants for a GCC Google Summer of Code project need to have experience coding in C/C++. Furthermore, if you want to work on the actual compiler you must have at least rudimentary theoretical background in the area of compilers and compiler optimizations - at the very least you need to understand the term intermediate representation (IR), sometimes also called intermediate language (IL). It also helps if you know what static single assignment (SSA) form is and why it is useful. This may not be strictly necessary if your project aims to improve a different tool or library that is part of GCC, such as the demangler but even in these cases you need to know about the required algorithms.

Before you apply and even before you even reach out to us make sure that you can check out the GCC source code from its Git repository, build GCC from it and run the testsuite (this is something that would need doing very many times in the course of any project working on GCC) and look around the project a bit.

The following links should help you:

      -O3 -S -fdump-tree-all -fdump-ipa-all -fdump-rtl-all

If you have done all of the above, or at least most of it, and still find it all a little bit intimidating, do not despair. If you are facing any specific technical problem or if you have difficulties figuring out where to start looking for particular things, that is something the mentors and the community at large are willing to help you with. First, the mailing list you keep reading about here has an archive, it is always a good idea to check if some other GSoC applicant has not asked your question recently. If not, send an email describing your situation to the mailing list yourself. We will appreciate if in your email you will make it clear that you have read this section and briefly list the steps above you have managed to carry out successfully.

Any non-trivial contributions to GCC are accepted only if their author either formally assign their copyright for them to the Free Software Foundation or if the author certifies the "Developer Certificate of Origin" (DCO) by adding the Signed-off-by: tag to their submission. Both processes are described in the official page on Contributing to GCC. Accepted GSoC contributors will be expected to choose one and follow it.

Application

First, you need to select a project. If you have been following GCC development, you might have an idea of your own, otherwise look at the suggested projects above and try to pick one there. In the course of selecting a project or when researching it in order to write your application, do not hesitate to ask questions or request more details from the community by email to the gcc@gcc.gnu.org mailing list with the string "GSoC" in the email subject or on our #gcc IRC channel at irc.oftc.net. Please note that the mailing list does not accept HTML messages, you must set your email client to plain text. If you are interested in gcc-rust topics, you can also reach out to the community via Zulip.

When you have a draft of your proposal ready, send it to the gcc@gcc.gnu.org mailing list as a request for comments. First, it should help you come up with a much better final proposal. Second, when evaluating applicants, we look closely at how they responded to feedback and how they incorporated it in their application document. We are unlikely to accept an application from someone who has not interacted with the community before at all. Please remember to put the string "GSoC" in the email subject of all messages about GSoC or a GSoC project proposal.

Formal application document

GCC does not have any application form or a mandatory application format to follow, but we strongly suggest you include the following in the formal application document that you submit to GSoC:

Further tips and guidelines


Other Project Ideas

Note that some of the ideas found below might be fully or partially obsolete. This is another reason why it is always a good idea to discuss the project of interest on the mailing list and/or via IRC before submitting a GSoC proposal.

Link-time optimization (LTO) is powerful infrastructure in GCC and there are many areas how to make it better, for example:

Language front-ends and run-time libraries

New optimization passes

Other projects and project ideas

There are several pages with general ideas for GCC, many of which we linked below for easy access. These ideas usually are not just one project but a group of distinct projects.

Or invent your own project. We're always open to good ideas. But note that we are probably not too interested in projects to add new extensions to the C or C++ languages. We've found over time that these tend to introduce more problems than they solve.

Thanks, and we look forward to your submissions!

Improving GCC Developer Documentation

The rules of the GSoC program do not allow projects to consist of documentation improvements only. Nevertheless, note that writing documentation may be an important part of your project or even an essential one if you introduce user-visible changes and plan your work accordingly.


Accepted GCC Projects

2023

Project

Student

Mentors

Improving user errors & Error Code Support for GCC Rust Frontend

Muhammad Mahad

Philip Herron and Arthur Cohen

Unicode Support for GCC Rust Frontend

Raiki Tamura

Philip Herron and Arthur Cohen

Extending gcc -fanalyzer C++ support for self-analysis

Benjamin Priour

David Malcolm

GCC static analyzer plugin for CPython extension modules

Eric Feng

David Malcolm

Bypass assembler when generating LTO object files

Rishi Raj

Martin Jambor and Jan Hubicka

C++: Implement compiler built-ins for the standard library traits

Ken Matsui

Patrick Palka

2022

Project

Student

Mentors

Support for Constant Folding in Rust Frontend

Faisal Abbas

Philip Herron

Extend GCCs static analyzer to support checking for POSIX file descriptor APIs

Immad Mir

David Malcolm

Improving Rust debugging experience by enhancing the HIR dump

Andrew Naguib

Arthur Cohen and Philip Herron

Bypass assembler when generating LTO object files

Nitin Kumar

Jan Hubička and Martin Jambor

New checkers for GCC’s static analyzer

Tim Lange

David Malcolm

Accelerating Fortran DOCONCURRENT

Wileam Phan

Tobias Burnus and Thomas Schwinge

2021

Project

Student

Mentors

Extending C++ support for static analysis pass

Ankur Saini

David Malcolm

Cargo tool for Rust-GCC

Arthur Cohen

Philip Herron

Static analysis for unreachable functions

Wenzhang Yang

Philip Herron

Make Cp-demangler non recursive

Vishnu Madhav

Nathan Sidwell and Martin Jambor

2020

Project

Student

Mentors

Automatic Detection of Parallel Compilation Viability

Giuliano Belinassi

Richard Biener

General Jobserver Client/Server Library

John Ravi

Martin Liška and Nathan Sidwell

Implementation of OMPD in GCC and libgomp

Tony Sim

Jakub Jelínek and Martin Jambor

2019

Project

Student

Mentors

On vector<bool> and optimized Standard Algorithms in libstdc++

ThePhD

Thomas Rodgers, Jonathan Wakely and Ville Voutilainen

New math.h and complex.h functions as built-ins

Tejas Joshi

Martin Jambor and Jan Hubička

Csmith fuzzer leveraging GCC C Extensions

Shubham Narlawar

Martin Liška and Andi Kleen

OpenMP Work Stealing Scheduling

Khurai Kim

Jakub Jelínek

Make C/C++ not automatically promote memory_order_consume to memory_order_acquire

akshatg

Paul E. McKenney and Ramana Radhakrishnan

Parallelize GCC with Threads (see also ParallelGcc)

Giuliano Belinassi

Richard Biener

2018

Project

Student

Mentor

LTO dump tool (project page)

Hrishikesh Kulkarni

Martin Liška and Jan Hubička

2016

Project

Student

Mentor

Replace libiberty with gnulib (project page)

Ayush Goel

Manuel Lopez-Ibanez

Development of GIMPLE Front End

Prasad Ghangal

Richard Biener

Further work on addressing mode selection

erikvarga

Oleg Endo

2015

Project

Student

Mentor

C++ Library Fundamentals: shared_ptr and polymorphic memory resources

Fan You

Tim Shen

Addressing mode selection in GCC

Erik Krisztian Varga

Oleg Endo

2014

Project

Student

Mentor

Coarray support in GNU GFortran

Alessandro Fanfarillo

Tobias Burnus

Concepts Separate Checking

Braden Obrzut

Andrew Sutton

Integration of ISL code generator into Graphite

Roman Gareev

Tobias Grosser

Generating folding patterns from meta description

Prathamesh Kulkarni

Richard Biener

GCC Go escape analysis

Ray Li

Ian Lance Taylor

2013

Project

Student

Mentor

Porting the GCC go language frontend on the GNU/HURD kernel

Fotis Koutoulakis

Thomas Schwinge

Optimizing large applications with LTO

Martin Liška

Jan Hubicka

Completing C++11 regex

Tim Shen

Stephen M. Webb

2012

Project

Student

Mentor

Continue work on GCC generic optimisation and cleanup

Dimitrios Apostolou

Andrey Belevantsev

Implement regular expressions to C++

Morgen Matvey

Benjamin De Kosnik

Gimple FE : Extending the text gimple recognizer to a real front end

Sandeep Soni

Diego Novillo

C++11 regex support in libstdc++

Sergey Lega

Benjamin De Kosnik

2011

Project

Student

Mentor

Extend GFortran's Coarray support with MPI-based paralellization (project page)

Daniel Carrera

Tobias Burnus

GCC Optimisation Final Report, Various Notes: (1) (2) (3)

Dimitrios Apostolou

Steven Bosscher

Integration of transactional memory support into a data-flow extension of OpenMP

Ismail KURU

Richard Henderson

Developement of Gimple Front End (project page)

Ketaki

Diego Novillo

Gccpy - GCC Python Front-end (project page)

Philip Herron

Ian Lance Taylor

Customizable warnings with a GCC plugin (project page)

Piervit

Basile Starynkevitch

Implement faster OpenMP Task for libgomp

Sho Nakatani (中谷 翔)

Jakub Jelínek

2010

The source code for finished projects can be found at Google's code hosting site and their respective SVN branches.

Project

Student

Mentor

EFI extension of Binutils

Yi-Hong Lu

H. J. Lu

Development of GIMPLE FE

Sandeep Soni

Diego Novillo

Improvement of general vector extension in GCC

Artjoms Sinkarovs

Richard Günther

Partial Implementation of Python as a GCC Front-end

Philip Herron

Ian Taylor

Improving the static control part detection mechanism in Graphite

Vladimir Kargov

Sebastian Pop

Traditional loop transformations in GRAPHITE

Ankur Deshwal

David Edelsohn

ScopLib support for Graphite - Linking Graphite to the huge industrial and research community

Riyadh Baghdadi

Sebastian Pop

Porting GRAPHITE to CLooG trunk

Andreas Simbuerger

Tobias Grosser

gfortran: Polymorphism and a complete OOP implementation

Janus Weil

Tobias Burnus

Extending Fortran 2003 and 2008 support for gfortran (esp. Co-Arrays)

Daniel Kraft

Tobias Burnus

2009

The source code for finished projects can be found at Google's code hosting site.

Project

Student

Mentor

Automatic parallelization in Graphite

Li Feng

Tobias Grosser

Enable generic function cloning and program instrumentation in GCC to be able to create static binaries adaptable to varying program and system behavior or different architectures at run-time

Liang Peng

Grigori Fursin

gfortran: Procedure Pointer Components & OOP

Janus Weil

Tobias Burnus

Traditional Loop Transformations

pranav garg

Sebastian Pop

Make the OpenCL Platform Layer API and Runtime API for the Cell Processor and CPUs

phil prattszeliga

Paolo Bonzini

Provide fine-grain optimization selection and tuning abilities in GCC to be able to tune default optimization heuristic of the compiler or fine optimizations for a given program on a given architecture entirely automatically using statistical and machine learning techniques from the MILEPOST project.

Yuanjie Huang

Grigori Fursin

2008

The source code for finished projects can be found at Google's code hosting site.

Project

Student

Mentor

GCC Improvements on Windows

Aaron W. LaFramboise

Steven Bosscher

Improving Dead Store Elimination

Jakub Staszak

Daniel Berlin

Extend Fortran 2003 support for gfortran

Daniel Kraft

François-Xavier Coudert

C++0x lambda functions for GCC

John Freeman

Douglas Gregor

Improved GIMPLE to GRAPHITE transformation

Tobias Grosser

Sebastian Pop

Finish work on propagation aliasing and array dependence information from Tree-SSA to RTL.

Alexander Monakov

Diego Novillo

Procedure Pointers for gfortran

Janus Weil

Tobias Burnus

2007

The source code for finished projects can be found at Google's code hosting site.

Project

Student

Mentor

Propagating array data dependence information from Tree-SSA to RTL

Alexander Monakov

Daniel Berlin

Better_Uninitialized_Warnings

Manuel López-Ibáñez

Diego Novillo

Speeding up GCC for fun and profit

James Webber

Eric Marshall Christopher

Fortran 2003 features for GCC

Janus Weil

Steven Bosscher

Open Mutliprogramming Interprocedural Analasis and Optimalizations

Jakub Staszak

Daniel Berlin

Integrating OpenJDK's javac bytecode compiler into gcj

Dalibor Topic

Mark J. Wielaard

New static scheduling heuristic for GCC

Dmitry Zhurikhin

Vladimir Makarov

GCC support for Windows-compatible Structured Exception Handling (SEH) on the i386 platform

Michele Cicciotti

Ian Lance Taylor

2006

Project

Student

Mentor

Code parallelization using polyhedral model

Plesco Alexandru

Daniel Berlin

Escape_analysis

Paul Biggar

Daniel Berlin

Garbage_collection_tuning

Laurynas Biveinis

Daniel Berlin

java.lang.management in Classpath

Andrew John Hughes

Mark Wielaard

Lock free C++ containers

Phillip Jordan

Benjamin Kosnik

Wcoercion option

Manuel López-Ibáñez

Ian Lance Taylor

None: SummerOfCode (last edited 2024-03-21 10:37:11 by MartinJambor)