Incremental build support for the modules driver
Contributor: Aadarsh Keshri
Until recently, explicit module builds were only supported for Clang modules. With the -fmodules-driver mode upstream patch being merged, the...
Programming languages
LLVM Compiler Infrastructure
LLVM Compiler Infrastructure
Technologies
C++clangllvmmlir
Topics
compilerdeveloper toolslibraries
- Total projects
- 133
- Years participating
- 11
- Most recent
- 2026
Participation history
Historical projects
Teach the Clang Static Analyzer to understand lifetime annotations
Contributor: Benedek Kaibas
The Clang Static Analyzer (CSA) can find a wide range of temporal memory errors such as use-after-free and dangling references. Some of its checkers,...
CIR Combine: Cross-Boundary Analysis for Heterogeneous CUDA/HIP Compilation
Contributor: David Rivera
Today, LLVM's offload compilation keeps host and device code strictly separate; they only reunite late in the pipeline when the device binary is...
Extending Clang API Notes for C++: Overload-Specific Annotations for Ordinary Methods
Contributor: Dominic Stöcker
This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between...
Adding native Fortran support in LLDB
Contributor: Iason Karaprodromidis
As the LLVM Flang frontend matures, a significant gap has emerged between compilation and diagnostic capabilities. Currently, LLDB does not provide...
Integrating a Remarks Analysis Engine into LLVM Advisor
Contributor: kamini08
This project aims to upgrade the llvm-advisor diagnostic tool into a scalable, active analysis workbench for massive workloads. The implementation...
Static Memory Planner for MLIR
Contributor: KrishGupta
MLIR already makes allocation and deallocation structure explicit after bufferization and the ownership-based deallocation pipeline, but it still...
Enable clangd support for HLSL
Contributor: Maria Fernanda Guimaraes
The goal of this project is to enable support for the High-Level Shading Language (HLSL) in clangd, allowing shader developers to benefit from modern...
Use LLVM libc math routines for compiler-rt floating point routines
Contributor: Mohamed Emad
compiler-rt builtins provide software floating-point routines (__addtf3, __multf3, __floatsitf, etc.) for targets that lack hardware FP support. The...
Upstreaming -fbounds-safety
Contributor: Mohammed.Ashraf
-fbounds-safety is a C language extension designed to prevent out-of-bounds memory accesses. Currently, upstream Clang provides partial support for...
Improving Clang-Doc
Contributor: 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...
Improving lit
Contributor: prasoon054
This project aims to modernize the LLVM Integrated Tester (lit) to improve its execution speed and long-term maintainability. Performance is...
Enable float80/float128 on Unsupported Targets for LLVM libc
Contributor: 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:...
Rich Disassembler for LLDB
Contributor: Abdullah_Amin
This project aims to enhance LLDB's disassembler by annotating machine instructions with source-level variable information, such as variable...
ClangIR upstreaming
Contributor: Amr Hesham Gaber
ClangIR is a new, MLIR-based intermediate representation of C and C++ code. It has been developed in an LLVM incubator project, but work is now...
Usability Improvements for trapping Undefined Behavior Sanitizer
Contributor: Anthony Tran
The primary vision is to enhance clang’s UBSan trap mode by tackling the three main goals, which include adding a warning to the...
Improving Core Clang-Doc Functionality
Contributor: Erick Velez
Clang-Doc leverages Clang’s robust tooling and rich symbol information in the AST to generate documentation. It is lacking in some essential...
Improve Rust-Enzyme Reliability and Compile Times
Contributor: Karan Janthe
Enzyme, Rust's automatic differentiation tool, faces challenges with reliability and performance due to limited type information in LLVM-IR. This...
Bfloat16 in LLVM libc
Contributor: Krishna Pandey
This proposal is based on the LLVM project for GSoC 2025 with the same title, from Tue Ly and Nicolas Celik. Discourse:...
Performance and Exhaustive Testing of C Standard Math Functions on GPUs
Contributor: Leandro Lacerda
This proposal aims to refine and expand the testing infrastructure in the LLVM C library to help users balance speed and accuracy of math functions...
LLVM Compiler Remarks Visualization Tool for Offloading
Contributor: Miguel Cárdenas
LLVM generates valuable information through remarks, profiling, and runtime annotations that becomes difficult to navigate as projects grow. This...
Introduce an ABI lowering library
Contributor: Narayan Sreekumar
The current implementations of the LLVM Project, have a drawback that every language frontend that wants to support Foreign Function Interface(FFI)...
Support simple C++ modules use from the Clang Driver without a Build System
Contributor: Naveen Seth Hanig
This proposal seeks to extend the build system in Clang's driver to natively support module-based builds by leveraging Clang's existing support for...
Byte type
Contributor: Pedro Lobo
LLVM currently lacks a type capable of representing raw memory, similar to unsigned char, char and std::byte in C/C++. The absence of such a type is...
Improve I/O performance in the libc implementation for GPU using io_uring
Contributor: Rodrigo Ceccato
Many HPC applications rely on GPUs for fast and efficient computation. At the same time, there is an effort to bring more programmability and...
Advanced symbol resolution and reoptimization for clang-repl
Contributor: Sahil Patidar
Clang-REPL is an incremental compiler that enables interactive programming in C and C++, combining the flexibility of a REPL with the performance of...
GPU Libc Benchmarking
Contributor: James Hu
The LLVM libc project was designed as an alternative to glibc that aims to be modular, configurable, and sanitizer-friendly. Currently, LLVM libc is...
Support clang plugins on Windows
Contributor: thomas fransham
This project aims to allow using dynamically loaded Clang plugins on windows by adding support for building LLVM and Clang as shared libraries on...
Improve Clang-Doc
Contributor: Peter Chou
Clang-Doc is a documentation generator developed on top of libtooling developed as an alternative to Doxygen. Development started in 2018, and...
OpenCL C Support for ClangIR
Contributor: 7mile
Optimizing code for heterogeneous hardware like GPUs requires specialized approaches. While LLVM/Clang supports various GPU programming interfaces,...
Out of process execution for Clang-Repl
Contributor: Sahil Patidar
Clang, part of LLVM, supports multiple languages and functions as a library, fostering a compiler-assisted ecosystem. Its accessible codebase and...
Reviving NewGVN
Contributor: Manuel Brito
Value numbering is a key compiler optimization. Currently, LLVM’s optimizer offers two implementations, GVN and NewGVN, neither of which is entirely...
Statistical Analysis of LLVM-IR Compilation
Contributor: Andrew K
This project aims to provide an analysis of the causes of unexpected compilation times. By conducting a statistical analysis on IR files available on...
LLVM.org Website Redesign
Contributor: Chaitanya Shahare
Problem Statement: Redesigning and migrating the llvm.org website to enhance user experience, accessibility, and community engagement. Solution...
Half precision in LLVM libc
Contributor: OverMighty
This proposal is based on the open LLVM project with the same title, from Tue Ly and Joseph Huber. See...
Addition of 3-way comparison intrinsic to LLVM
Contributor: Volodymyr Vasylkun
Three-way comparisons are present in many high-level programming languages, such as C++ with its spaceship ( ) comparison operator or Rust via the...
Build & Run SingleSource Benchmarks with ClangIR - Part 2
Contributor: Vinicius Espindola
ClangIR is the newest attempt to tackle the lack of a higher-level intermediate representation for C++. Said representation would greatly benefit the...
The 1001 thresholds in LLVM
Contributor: Sh0g0
LLVM has lots of thresholds and flags to avoid “costly cases”. However, it is unclear if these thresholds are useful, their value is reasonable, and...
ExtractAPI while building
Contributor: Ankur Saini
This project aims to give LLVM-clang the ability to generate ExtractAPI symbol graph files as a side-effect of a regular compilation job. This can...
WebAssembly Support for clang-repl
Contributor: Anubhab Ghosh
Clang includes libInterpreter, a framework for incrementally JIT compiling and executing C++ code. The goal of the project is to port this to...
Modules Build Daemon: Build System Agnostic Support for Explicitly Built Modules
Contributor: Connor Sughrue
This project aims to implement a daemon that serves as a build system manager for modules, providing support for explicitly built modules...
Interactive MLIR query tool to make exploring the IR easier
Contributor: Devajith Valaparambil Sreeramaswamy
This project aims to create an interactive query language for MLIR that will allow developers to dynamically query the MLIR IR. The tool will provide...
Improving Compile Times
Contributor: Dhruv Chawla
This project aims to reduce the amount of time that LLVM spend on compiling code by focusing on hotspots in the code identified by profiling...
Adding C++ Support to Clang's ExtractAPI
Contributor: Erick Velez
Clang’s ExtractAPI extracts information from C and Objective-C codebases to describe public API symbols and the relationships between them. It is...
Optimizing MLIR’s Presburger library
Contributor: gilsaia
MLIR’s Presburger Library, FPL, provides mathematical abstractions for polyhedral compilation and analysis. When many set operations are performed in...
Adapting IR Load Semantics to Freeze All or Freeze Only Uninitialized Data
Contributor: John McIver
This proposal outlines a continuation of the Google Summer of Code (GSoC) 2022 topic to move uninitialized memory to poison semantics. Starting with...
Addressing Rust optimization failures in LLVM
Contributor: Kohei Asano
Rust is a popular system programming language that relies on LLVM for its compilation. Rust has a variety of features and paradigms and states “Zero...
Tutorial development with clang-repl
Contributor: Krishna Narayanan
This project aims to develop tutorials demostrating the current capabilities of clang-repl. It also aims to investigate and research the requirements...
Fix Handling of Undefined Behavior in NewGVN
Contributor: Manuel Brito
NewGVN was introduced to LLVM to cope with the limitations of the old GVN. It hasn't, however, seen widespread adoption, due to its bugs and missing...
Map LLVM values to corresponding source-level expressions
Contributor: phyBrackets
This project aims to improve the accuracy of compiler-generated remarks and analysis reports by including corresponding source-level expressions in...
Machine Learning Guided Ordering of Compiler Optimization Passes
Contributor: Puneeth A R
Standard optimization pipelines are used by developers to compile programs in LLVM clang like (O1, O2, O3, etc…). These are based on heuristics that...
Patch based test coverage for quick test feedback
Contributor: ShivamGupta123
Most of the day to day tests in LLVM are regression tests executed by Lit, structured as source code or IR to be passed to some binary, rather than...
Re-optimization using JITLink
Contributor: Sunho Kim
In Just-In-Time compilers we often choose a low optimization level to minimize compile time and improve launch times and latencies, however some...
Improvements in Clang Diagnostics
Contributor: Takuya Shimizu
Clang diagnostic is an interface for programmers that assists them in writing bug-free, efficient source codes. The aim of this proposal is to...
Build & Run SingleSource Benchmarks with ClangIR
Contributor: Vinicius Espindola
ClangIR is the newest attempt to tackle the lack of a higher-level intermediate representation for C++. Said representation would greatly benefit the...
Better Performance Models for MLGO Training
Contributor: Viraj Shah
This project aims to improve the reward signal used in the RL-based training of MLGO models. I plan to integrate an existing GNN-based performance...
Enhancing llvm-cov to Generate Hierarchical Coverage Reports
Contributor: Yuhao Gu
Clang supports source-based coverage that shows which lines of code are covered by the executed tests. It uses llvm-cov to generate coverage reports....
Autocompletion in Clang-REPL
Contributor: Yuquan Fu
Clang-REPL enables developers to program in C++ in an exploratory manner via a read-eval-print-loop. Developers, however, have to type each letter or...
Make Enzyme plugin callable from The New Pass Manager in LLVM
Contributor: Shakil
Enzyme plugin project aims to automatically find derivatives of LLVM IR which is pretty helpful for ML related works.Enzyme code base still uses the...
Graph Based Features for Better ML Guided Live Range Eviction Heuristics
Contributor: Aiden Grossman
Within this project, I aim to create a new ML model based on the already existing MLGO work in register allocation to further enhance the performance...
Improving Clang Diagnostics
Contributor: Muhammad Usman
Improving the clang diagnostics focuses on the diagnostic section of clang. This proposal is meant to make clang diagnostic more user friendly and...
Moving Instruction Rules to Tablegen
Contributor: Manuel Drehwald
Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. The support for an increasing number of LLVM Versions (7-main),...
Non-Determinacy based optimizations in Parallel Programs
Contributor: Abhishekvu
Problem : Optimize Parallel Programs by employing Non-Determinacy based optimizations. Plan : 1. Perform static code analysis to identify program...
Write JITLink support for new format/architecture
Contributor: Sunho Kim
JITLink is LLVM’s new JIT linker designed to support a variety of new features, which includes full static initializer, thread local storage, and...
Learning loop transformation policy and it's effect on RISC-V
Contributor: eopXD
This project is based on the proposed project (Learning Loop Transformation Policies) by the mentors Johannes Doerfert, Mircea Trofin. This project...
Remove undef: Move Uninitialized Memory to Poison
Contributor: John McIver
Current memory semantics of the LLVM-IR use undef when dereferencing an uninitialized memory location. This prevents optimizations within scalar...
Implement support for C++17 structured bindings in the Clang Static Analyzer
Contributor: Domján Dániel
Even though a lot of new C++ features are supported by the static analyzer automatically by the virtue of clang AST doing all the work under the...
Shared Memory Based JITLink Memory Manager
Contributor: Anubhab Ghosh
When a separate executor process is used with LLVM JIT, the generated code needs to be transferred to the executor process which is done by the...
Learning Live Ranges Priority Policy
Contributor: Eric Wang
This project is a practical application under the umbrella of the MLGO framework. While the previous work focuses on inlining and eviction policy of...
Instrumentation of Clang/LLVM for Compile Time
Contributor: Junduo Dong
GSoC Project "Instrumentation of Clang/LLVM for Compile Time" aims to solve a simple but interesting question: Why is the compilation taking so long?...
Extend clang to preserve type sugar when performing member access on template specialization
Contributor: mizvekov
For an example like: template struct Foo { using type = T; }; using Bar = int; Foo ::type baz; In clang, baz’s type will not desugar to...
Fix Fundamental Issues in LLVM IR
Contributor: Krishna Kariya
LLVM Project is a collection of modular and reusable compiler and toolchain technologies. It supports various high-level languages and hardware...
Machine Learning Guided Ordering of Compiler Optimization Passes
Contributor: Tarindu Jayatilaka
Developers generally use standard optimization pipelines like -O2 and -O3 to optimize their code. Manually crafted heuristics are used to determine...
Making Smart Pointer Checkers default checkers in the Static Analyzer
Contributor: Deep Majumder
The Clang Static Analyzer currently has checkers for std::unique_ptr. These checkers are currently in the experimental (alpha) group of checkers. I...
Learning Loop Transformation Heuristics
Contributor: Ali Sedaghati
In this project we will look at loop transformation heuristics, such as the unroll factor.
Integrate custom derivatives of Numerical Computing routines like BLAS and Eigen into Enzyme
Contributor: Pratyush Das
Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. This enables users to use Enzyme to perform various algorithms...
Improving OpenMP code generation with prediction of runtime parameters
Contributor: Konstantin Sidorov
The performance of the code generated for the GPU heavily depends on runtime parameters such as the number of thread blocks and threads per thread...
Distributed lit testing
Contributor: Soham Dixit
The LLVM lit test suites consist of thousands of small independent tests. Due to the number of tests, it can take a long time to run the full suite,...
Fix miscompilation issues in LLVM IR using the ‘Freeze’ instruction
Contributor: Hyeongyu Kim
Optimizations have been the cause of multiple miscompilations as well. It is difficult to determine whether an optimization is correct because bugs...
Integrate Enzyme into Rust to Provide High-performance Differentiation in Rust
Contributor: Chuyang Chen
With a surge of machine learning, especially the neural network model which needs to compute a huge amount of gradients, more and more languages'...
Utilize LoopNest Pass
Contributor: Toshiki Maekawa
A newly added idea of LoopNest pass enables to handle a loop nest efficiently, unlike function pass or loop pass. The goals of this project are: ...
Improve inter-procedural analyses and optimizations
Contributor: Kuter Dinel
In this project we aim to improve the deduction capabilities of the Attributor framework.
Use official isl C++ bindings for polly
Contributor: Riccardo Mori
Polly uses custom C++ bindings for isl (Integer Set Library) which is a library written in C. I aim to replace at least partially the usage of these...
Fixing fundamental issues in LLVM IR: Introducing a byte type to solve load type punning
Contributor: George Mitenkov
It is common for compilers, and LLVM in particular, to transform calls to memcpy or memmove to a number of integer loads and stores of the...
Integrating Enzyme into Rust
Contributor: Manuel Drehwald
Integrate Enzyme into Rust to provide high-performance differentiation of generic Rust code.
Evolving the LLDB GUI
Contributor: Omar Emara
The project aims to improve the LLDB curses GUI to provide a complete and intuitive IDE-like debugging experience without having to resort to the...
Inlining: using locally optimal inlining decisions
Contributor: Liq Tao
Improve inlining: using subgraph analyze and locally optimal inlining decisions
Improve Parallelism-Aware Analyses and Optimizations
Contributor: Stefan Stipanovic
Parallelism is used to improve performance. In sequential languages, parallelism is introduced with parallel constructs. However, it doesn’t come...
Add DWARF Support for yaml2obj
Contributor: Xing GUO
LLVM offers 2 useful YAML tools, yaml2obj and obj2yaml. The former one reads YAML files and emits object files, e.g., ELF, COFF and MachO. The latter...
Advanced Heuristics for Ordering Compiler Optimization Passes
Contributor: Hideto Ueno
Selecting optimization passes for given application is very important but non-trivial problem because of the huge size of the compiler transformation...
Improve hot cold splitting to aggressively outline small blocks
Contributor: Ruijie Fang
This project aims at enhancing the ability to detect and split small cold blocks (for example, __assert_rtn, throws) to the existing hot/cold...
Unify ways to move code or check if code is safe to be moved
Contributor: Rithik Sharma
LLVM transformation passes use code motion in different types of transformations. All these passes have some embedded code motion safety checks and...
Support autosuggestions in LLDB's command line
Contributor: Shu Anzai
Tab completion in LLDB is a very useful function for users. However, it is needed that users press [tab] key to confirm completion. If they can...
Advanced Heuristics for Ordering Compiler Optimization Passes
Contributor: Tarindu Jayatilaka
Compilers come with hundreds of optimization passes, making it difficult to select which passes to run and deciding the order in which to execute...
Implement the missing tab completions for LLDB's command line
Contributor: Gongyu Deng
To implement the missing tab completions for LLDB's command line as the title goes, I dug out possible commands as targets and provided a list of...
SPIR-V to LLVM IR dialect conversion in MLIR
Contributor: George Mitenkov
MLIR is a novel compiler infrastructure that enables multi-level abstraction and therefore enhances reusability and extensibility. The core concept...
Find null smart pointer dereferences with the Static Analyzer
Contributor: Nithin V Rajendrakumar
The Clang Static Analyzer is used to find bugs in the program by analyzing source code without compiling and executing. It uses symbolic computations...
Improve inter-procedural analyses and optimizations
Contributor: Shinji Okumura
LLVM IR has some attributes which can be attached to function, argument, callsite, et cetera. These attributes guarantee a property corresponding to...
Latency Hiding for Host to Device Memory Transfers
Contributor: Hamilton Tobon Mosquera
Given the increasing number of use cases for massively parallel devices (GPUs), solving the problems they bring have become an important research...
Improve MergeFunctions to incorporate MergeSimilarFunctions patches and ThinLTO Support
Contributor: Vishal Chebrolu
The project aims at providing the MergeFunctions pass in LLVM to have feature parity with the MergeSimilarFunctions pass, which can merge functions...
Improve inter-procedural analyses and optimizations
Contributor: Kuter Dinel
In this project we aim to improve the deduction capabilities of the Attributor framework.
Deduce attributes for non-exact functions
Contributor: Luofan Chen
A function that is non-exactly defined is a function that could be replaced at link time. Usually most of the non-inlining IPOs are inhibited. For...
libObjectcopy
Contributor: Alex Brachet
Working on librarifying llvm-objcopy for use throughout binutils. Creating a good base for a library such that many object file formats can be added...
Improve (function) attribute inference
Contributor: Hideto Ueno
LLVM functions can be tagged with several attributes. These attributes are used in optimizations to decide whether a particular transformation is...
Improve (function) attribute inference
Contributor: Stefan Stipanovic
LLVM functions, as well as arguments and other entities, can be tagged with several attributes such as the function only reads memory, or the...
Speculative compilation in LLVM ORC - Just in time APIs
Contributor: PreeJackie
One of the selling points of new LLVM ORC Concurrent JIT APIs is we can speculatively compile functions before we need it, with the hope that when we...
Apply the Clang Static Analyzer to LLVM-based projects
Contributor: Charusso
The idea is to improve the Clang Static Analyzer so that it is useful for developers who work on Clang and LLVM themselves, as well as on other...
Generation of Annotated Sources
Contributor: William Moses
LLVM automatically derives facts that are only used while the respective translation unit, or LLVM module, is processed (i.e. constant function,...
Improve LLVM binary utilities
Contributor: Seiya Nuta
LLVM includes binary utilities equivalent to GNU binutils. Basic functionalities are done but there are incomplete ones such as Mach-O support. This...
Enhancing bug reports in the Clang Static Analyzer
Contributor: Kristóf Umann
The Clang Static Analyzer (analyzer) can discover errors in a code by a technique called symbolic execution. Its core essentially interprets C, C++,...
Implement a single updater class for Dominators
Contributor: Chijun Sima
Dominance relationship is used widely in many compiler analyses and optimizations. The current API provided by LLVM to update the dominator tree and...
Re-implement lldb-mi on top of the LLDB public API
Contributor: Alexander Polyakov
The project goal is to re-implement lldb-mi to avoid using of HandleCommand and regular expressions to parse commands results.
Using the Z3 SMT Solver to Validate Bugs Reported by the Clang Static Analyzer
Contributor: Mikhail Y R Gadelha
The goal of this project is to provide a new option in the clang static analyzer to validate (or refute) reported bugs, by using an SMT solver. The...
Move the apt.llvm.org CI to OBS
Contributor: Reshabh Sharma
LLVM uses a Jenkins instance and Jenkins-Debian-Glue to build LLVM, Clang, clang extra tools, compiler-rt, polly, LLDB and LLD packages for the...
A checker for dangling string pointers in C++
Contributor: Réka Nikolett Kovács
The C++ std::string class provides a c_str() method that returns a raw pointer to a string's inner character buffer. When a std::string is destroyed,...
Improve Debugging of Optimized Code
Contributor: gramanas
Measure DebugInfo loss statistics. Find the cause. Fix the culprit transformations starting from the most used areas of the compiler.
Devirtualization v2
Contributor: Piotr Padlewski
In this project I would like to implement proposal “RFC: C++ Devirtualization v2” that I was working on for a quite some time with help from other...
Command line replacements for GNU Binutils
Contributor: Paul Semel
A lot of GNU binutils have their equivalent in the LLVM project. As the majority of people are already accustomed to the GNU ones, it would be great...
ThinLTO Optimizations
Contributor: Charles Saternos
I would like to work on ThinLTO to improve and tune performance. This will require some analysis to determine what optimizations to add, as well as...
Clang-based C/C++ diff tool
Contributor: Johannes Altmanninger
I want to implement a structural diff tool atop of clang APIs that finds changes to the AST between two versions of a file. This would enable better...
Warn if virtual calls are made from constructors or destructors
Contributor: Xin Wang
In C++, virtual functions let instances of related classes have different behavior at run time. Pure function called from constructors and...
Enable Polyhedral Optimizations in XLA through LLVM/Polly
Contributor: Annanay Agarwal
TensorFlow is a popular machine learning and deep learning framework developed by Google. Despite its recent launch in late 2015, it has been widely...
ISL Memory Management Using Clang Static Analyzer
Contributor: malhar1995
Maintaining consistency while manual reference counting is very difficult. Languages like Java, C#, Go and other scripting languages employ garbage...
Building bash-completion for clang
Contributor: Yuka Takahashi
Shell completion is a function which developers use everyday. Typing "ls -" and pressing [tab] will return a list of probable options, and typing...
Improved Loop Execution Modeling in Clang Static Analyzer
Contributor: Péter Szécsi
The current implementation of modeling a loop is quite simple in the Clang Static Analyzer. This simple approach results a loss of coverage, which...
Enabling Julia to target GPGPUs using Polly
Contributor: Singapuram Sanjay S.V.
Polly can now automatically offload suitable kernels to GPUs in the form of Polly-ACC, saving a lot of developer time and effort. Julia, a modern...
Finding and analysing copy-pasted code with clang
Contributor: Teemperor
Copy-pasted code is dangerous because it introduced bugs and makes projects harder to maintain. This proposal is about creating tools for finding...
Interprocedural Register Allocation in LLVM
Contributor: Vivek Pandya
The objective of this project is to implement a simple interprocedural register allocation that attempts to minimize register spill code by...
SAFECode’s Memory Policy Hardening
Contributor: Zhengyang Liu
Monolithic kernels, like linux, did not provide a hardening mechanism on the kernel modules’ memory access. Modules in Linux could do almost...
Improvement of vectorization process in Polly
Contributor: groman
Polly can perform classical loop transformations, exploit OpenMP level parallelism, expose SIMDization opportunities. However, due to the lack of a...
Enabling llvm’s self-hosted modules builds using libstdc++
Contributor: CrisCristescu
A Module System for C++ is on its way to the C++ standard. The current state of the Module System, although fairly stable, it has a few bugs for C++...
Polly as an Analysis Pass in LLVM
Contributor: Utpal
The Polyhedral framework provides an exact dependence analysis, which is more powerful than conventional dependence testing algorithms. Currently,...
Better Alias Analysis By Default
Contributor: grievejia
The cfl-aa pass implemented by Gerorge Burgess IV back in GSoC 2014 is a fast, precise and interprocedural analyses that overcomes many deficiencies...