
GNU compilers
Showing 5 of 33 projects. Click any project card for scope, mentors, and proposal studio.
Mentors: Student: Egas Ribeiro
GCC's static analyzer (-fanalyzer) lacks C++ class hierarchy awareness, causing it to miss bugs in exception catch blocks that use base types and limiting virtual function resolution. This project implements exception subclass matching (PR119697) and improves virtual function dispatch (PR97114) by adding type hierarchy infrastructure to the analyzer.
Mentors: Student: Nchang Roy
Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.
Mentors: Student: Sebastian Galindo
GCC currently supports most OpenACC directives for GPU offloading, but several features remain unimplemented or incomplete. This project targets four concrete gaps in the OpenACC implementation within GCC: - init, shutdown, and set directives (OpenACC 2.5+): Implementing the directive-form equivalents of the already-available runtime API routines, following the pattern of the existing #pragma acc wait infrastructure. - bind clause: Extending full support to C, C++, and Fortran by mapping the clause to OpenMP declare target and declare variant directives at the middle-end level or implementing OpenACC specific code. - device_type clause: Filtering clauses in the GIMPLE IR linked list based on the target device type at compile time using the ACCEL_COMPILER variable. - cache directive: Moving beyond the current no-op behavior by emitting prefetch instructions and/or placing data in low-latency memory using existing GCC prefetch infrastructure and OpenMP memory traits for certain use cases. Additionally, once core tasks are complete, the project will survey newer OpenACC specification features, producing a structured list of unimplemented functionality with prioritized implementations and documentation to ease future contributions. Deliverables include upstream patches for each directive/clause with test suite additions for C, C++, and Fortran, and documentation updates to the relevant documentation files.
Mentors: Student: Enes Çevik
This project implements the compiler infrastructure—including missing intrinsics and lang items—required to compile Rust’s alloc crate in GCC Rust (gccrs). The work focuses on bridging architectural gaps and ensuring alloc is ready for integration once core support is finalized. Deliverables include core heap-related functionality, regression tests, and documentation of the resolved compiler limitations.
Mentors: Student: Janet Chien
gccrs still lacks support for Rust’s Drop trait, which is a core part of Rust’s resource management model. Without it, values that require cleanup cannot be handled correctly at scope exit, which makes gccrs incomplete with respect to important Rust semantics. This project proposes an incremental implementation of Drop support in gccrs, starting from a narrow and testable subset rather than attempting full drop elaboration at once. The first stage focuses on scope-exit destructor insertion for simple non-generic local variables using existing backend cleanup machinery. From there, the implementation will be extended to support multiple locals, correct reverse drop order (LIFO), and, if feasible, initial nested-scope cleanup. More advanced cases such as moved values, temporaries, partially initialized values, and generic Drop will be treated as later-stage or stretch work. The main deliverables are: an initial implementation of scope-exit Drop support for a restricted subset of local variables, support for correct LIFO drop ordering, regression tests covering the supported behavior, and documentation describing the implementation approach, supported subset, and current limitations.