LLVM Compiler Infrastructure

Mentors: Student: kamini08

This project aims to upgrade the llvm-advisor diagnostic tool into a scalable, active analysis workbench for massive workloads. The implementation restructures the underlying data layer with a high-performance, dual-path ingestion pipeline, primary path being native C++ libRemarks bitstream decoding to process massive LTO builds without memory exhaustion, and the fallback path is YAML ingestion pipeline. It also implements a dependency-free Vanilla JS virtualization grid and injecting "Active Diagnostic" modules (like heuristic hinting and spatial heatmaps) directly into the existing Code Explorer DOM. This provides LLVM developers with bottleneck triage and actionable C++ refactoring advice while still maintaining the tool's lightweight, offline-first design.

Mentors: Student: NeilN

Clang-Doc is LLVM's modern C/C++ documentation generator built on the compiler AST rather than heuristic text parsing. A key blocker to its adoption is the absence of Markdown support inside documentation comments. Fenced code blocks, pipe tables, and lists currently pass through to output generators as raw text, making generated documentation unreadable for any project that uses Markdown in its comment workflow, which includes LLVM itself. This project implements a standalone Markdown parsing library that takes text and returns typed data structures, with no knowledge of comments or Clang internals. Clang-Doc is the immediate consumer, but the library is usable by any LLVM tool. It follows the same pattern as the Mustache library from GSoC 2024, with no third-party dependencies. Deliverables include the full library, Clang-Doc integration, updated HTML and Markdown generators, end-to-end lit/FileCheck tests, a libFuzzer harness, and an LLVM blog post. Stretch goal: Clang AST support for Doxygen group comments, flagged by mentors as particularly valuable.

Mentors: Student: Dominic Stöcker

This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between overloaded methods such as foo(int) and foo(double), so annotations are applied to all overloads with the same name rather than to a specific function. The project introduces overload-aware matching for C++ methods, allowing API Notes to target individual overloads based on their parameter types while preserving compatibility with existing notes. This enables more precise annotations and improves interoperability for real-world C++ APIs, such as Swift bindings. The core deliverable is a working and tested implementation for explicit-parameter overloads (Phase 1), including typed-vs-legacy handling and regression tests. The project then extends this to support const- and ref-qualified member functions (Phase 2), completing support for receiver-sensitive overloads.

Mentors: Student: Mohammed.Ashraf

-fbounds-safety is a C language extension designed to prevent out-of-bounds memory accesses. Currently, upstream Clang provides partial support for some annotations such as counted_by. The proposal aims to extend the scope of the currently supported annotations and upstream missing ones.

Mentors: Student: Sukumar Sawant

This proposal is based on the LLVM project for GSoC 2026 with the same title, from Tue Ly, Nicolas Celik and Krishna Pandey. Discourse: https://discourse.llvm.org/t/gsoc-2026-libc-enable-float80-and-float128-math-support-on-unsupported-targets-for-llvm-libc/89647. Float80 (x87 80-bit extended precision) and Float128 (IEEE 754 binary128 quad precision) are high-precision floating-point formats critical for correctly rounded math implementations. However, not all compilers or architectures support these types natively which prevents LLVM libc from building and testing its high-precision math routines on these platforms. The goal of this project is to implement software support for these types in LLVM libc in a compiler and architecture agnostic way. Deliverables: - Implement float80 and float128 in a compiler and architecture agnostic way. Implement generic basic arithmetic operations that work on all supported architectures. - Demonstrate compiling and passing tests on unsupported targets (float80 on Mac ARM64, float128 on MSVC).