Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
<p>LLVM IR has some attributes which can be attached to function, argument, callsite, et cetera. These attributes guarantee a property corresponding to each attribute and its position, and such information is used to decide to apply a particular transformation in other optimization passes. These attributes are given by the frontend or inferred by LLVM passes.</p> <p>A framework for unified attribute inference named “Attributor” was introduced and implemented. In a GSoC project last year, various attributes can be inferred with Attributor. However, there is room for improvement of inference.</p> <p>The Attributor can not only deduce attributes but also connect attribute deduction and other analyses to each other. We can take advantage of this potential of Attributor. One of such optimizations is “value simplification”. It has been implemented, but it also can be improved.</p> <p>The purpose of this project is two-fold.</p> <ol> <li>To make some inference stronger and make it possible for more optimizations to be applied.</li> <li>To improve value simplification from various perspectives.</li> </ol>
<p>The Polyhedral framework provides an exact dependence analysis, which is more powerful than conventional dependence testing algorithms. Currently, LLVM mainline lacks a powerful dependence analysis framework, and at the same time, Polly’s (a high level data locality optimizer based on polyhedral framework) dependence analysis is suitable for many transformation passes in LLVM like Loop Vectorization, Loop Versioning, Modulo Scheduling, Loop Nest Optimizations, etc. I want to provide an API to Polly such that its precise dependence analysis can be used as an Analysis pass within LLVM's transformation passes.</p>
<p>In this project we aim to improve the deduction capabilities of the Attributor framework.</p>
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. llvm-cov currently generates a single top-level index HTML/TEXT file. This causes rendering scalability issues in large projects. This project adds a new option `-show-directory-coverage` to llvm-cov which enables the generation of a hierarchical report mirroring the directory structure and solve scalability issues.
-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.
<p>The current implementation of modeling a loop is quite simple in the Clang Static Analyzer. This simple approach results a loss of coverage, which indicates false negatives. There is already an implemented loop widening method in the Clang Static Analyzer.[1] However, it comes at the price that (almost) all of the MemRegions values will be invalidated. Hence, the false positive rate is relatively high in these paths. That is the reason it is not turned on by default but hidden behind a flag. My project would aim to improve the simulation of the loops in general. Moreover, it would provide an extensible and incremental way of loop widening in which only the relevant regions are invalidated, and thus can be turned on by default.</p> <p>[1] <a href="https://reviews.llvm.org/D12358" target="_blank">https://reviews.llvm.org/D12358</a></p>
<p>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 later. I think we can create a much better and more ergonomic object file library than GNU's bfd considering we can use it as an example. Also, I find C++ is much better suited for creating ergonomic and easy to use libraries than C, obviously. If the library exists internally for LLVM and by use of its binutils, then we can create a much better library. If done correctly, many of the binutils will just have to interface with the command line and with the library and do little work with the underlying object file on their own.</p>
<p>LLVM includes binary utilities equivalent to GNU binutils. Basic functionalities are done but there are incomplete ones such as Mach-O support. This project aims to support those missing functionalities and improve usability for those who crave for an alternative to GNU binutils.</p> <p>The goal of proposal is twofold:</p> <ul> <li>llvm-objcopy: Improve Mach-O support</li> <li>llvm-objdump: More human-friendly disassembly</li> </ul>
<p>A Module System for C++ is on its way to the C++ standard.</p> <p>The current state of the Module System, although fairly stable, it has a few bugs for C++ support. The most common reason for the bugs is the semantic merging of C++ entities. Currently, the method for ensuring no regressions is a buildbot for libc++, which builds llvm in modules self-hosted mode. Its main purpose is to find bugs in clang’s implementation and ensure no regression for the ongoing development.</p> <p>Since the Module Systems is meant to be generic, the project aims to improve the stability and coverage of the Module System by finding as many issues as possible. One approach is to add a buildbot for libstdc++, because this would change the merging model for the modules, and in this way, it will point out different issues which would not be observed by using libc++. The choice for libstdc++ is motivated by its wider use in Unix and, more importantly, the benefits it will bring to supporting modules for third party projects that rely on libstdc++.</p>
<p>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 command line interface.</p>
Problem : Optimize Parallel Programs by employing Non-Determinacy based optimizations. Plan : 1. Perform static code analysis to identify program points for potential code optimizations. 2. Implement the optimizations as passes which will transform the source of the previously chosen program points. Following are the list of optimizations that are planned. a. Non-deterministic Loop Invariant Code Motion b. Loop interchange/reordering c. Non-deterministic Vectorization d. Non-deterministic Memory to Register 3. Evaluate the generated code for the optimizations against the benchmarks. 4. Documentation and Report a. Document the details with respect to the assumptions in the optimizations. b. Document the relevance of the optimization across the chosen benchmarks. Deliverables : a. Analysis to decide on the program segments to perform optimization b. Optimization passes on the previously chosen code segments. c. Optimization bench marking d. Documentation towards theory and implementation of optimizations
<p>Shell completion is a function which developers use everyday. Typing "<em>ls -</em>" and pressing <em>[tab]</em> will return a list of probable options, and typing "<em>sudo apt ins</em>" and pressing <em>[tab]</em> will complete the last argument (in this case "install"). Since each command takes different arguments, shells need to be taught how to complete arguments for each command.</p> <p>The aim of this proposal is twofold:</p> <ul> <li>There’s no bash autocompletion support for clang at the moment. Therefore I will build bash-completion which <strong> works not only for the current version but for all future versions of clang.</strong></li> <li>Not merely implement completion for bash, but also <strong> make this project highly portable to any other shells (zsh, fish..etc) by implementing completion behavior in clang internals.</strong></li> </ul>
<p>In C++, virtual functions let instances of related classes have different behavior at run time. Pure function called from constructors and destructors will make the C++ program crash and virtual function called from constructors and destructors may not do what you expect. This proposal is about implementing a path-sensitive checker to find virtual calls made from constructors and destructors.</p>
<p>Parallelism is used to improve performance. In sequential languages, parallelism is introduced with parallel constructs. However, it doesn’t come without a downside. Early outlining by the frontend is preventing existing optimization passes. The intent is to enhance and improve the existing “OpenMPOpt” optimization pass, thus improving performance of parallel programs.</p>
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 a REPL or command-line interface for users to query various properties of MLIR code. The goal is to create a tool similar to clang-query, with autocomplete and other features. The project's objective is to make it easier understand the MLIR IR representation, implement a REPL for executing queries over MLIR IR, and deliver a standalone tool for interactively exploring IR with common matchers. A stretch goal is to enable extracting parts of the IR matched by queries into self-contained IR snippets.
<p>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 visualizations of changes as well as semantic-aware merge tools.</p>
<p>LLVM transformation passes use code motion in different types of transformations. All these passes have some embedded code motion safety checks and mechanisms to move code. This project aims to identify different mechanisms for checking code motion safety and for moving code and then tries to unify them into one place. This will eventually provide a standardized way for different transformation passes to use code motion checks and to move code. The initial groundwork has already started in CodeMoverUtils. This project will focus on the code motion safety checks and the ways to move code in different loop passes, keeping CodeMoverUtils independent of any loop information. This will help to increase the maintainability of code motion safety checks and will reduce the redundancy and inconsistency of code motion safety checks and ways to move code.</p>
This project aims to enhance LLDB's disassembler by annotating machine instructions with source-level variable information, such as variable locations and lifetimes, based on debug data like DWARF. Currently, LLDB’s disassembler outputs only low-level instructions, requiring users to manually infer where source variables are located. By enriching disassembly output with variable annotations (e.g., which register or constant a variable is stored in), this project will make debugging optimized and low-level code significantly easier. The solution involves extending LLDB’s disassembly printing pipeline to query live variables at each instruction address, limited to variables that reside in CPU registers or are represented as constants, ensuring efficiency and clarity. Deliverables include: Annotated disassembly output in the LLDB command-line interface. Full test coverage against optimized and unoptimized binaries. Documentation and usage examples for developers and users. This work will be designed to be debug information format-agnostic wherever possible, making it extensible across formats like DWARF and PDB.
<p>With a surge of machine learning, especially the neural network model which needs to compute a huge amount of gradients, more and more languages' users begin to call for the ability to do high-performance and convenient <em>automatic differentiation</em> (hereafter AD) on functions, whereupon many AD tools are developed, among which is Enzyme. Enzyme is made as a plugin of LLVM and synthesizes differentiated functions directly on optimized LLVM IR code, which provides it with advantages in efficiency and universality. From another aspect, Rust is an emerging high-performance and safe language. Many of its users are trying to bring machine learning to it, thus an high-performance and user-friendly AD tool needed. Enzyme is a good option for this demand. However, without a deep integration into Rust, Enzyme's user experience with Rust is not so good, and more importantly, it may suffer from performance reduction due to wasted Rust meta-information. These problems hamper Enzyme from being widely used in Rust. This project will tackle the aforementioned problems through integrating Enzyme into Rust and then provide high-performance differentiation in Rust.</p>
<p>Improve inlining: using subgraph analyze and locally optimal inlining decisions</p>
<p>Copy-pasted code is dangerous because it introduced bugs and makes projects harder to maintain. This proposal is about creating tools for finding copy-pasted code and report bugs that are caused by this practice. These tools include a checker for clang’s static analyzer that analyses a single translation unit and a standalone tool that performs a project-wide analysis.</p>
<p>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, even on a high-spec computer. Builds are already distributable across multiple computers available on the same network, using software such as distcc or icecream, so running tests on a single machine becomes a potential bottleneck. One way to speed up running of the tests could be to distribute test execution across many computers too. Lit provides a test sharding mechanism, which allows multiple computers to run parts of the same testsuite in tandem, but this currently assumes access to a single common filesystem, which may not be possible in all cases and a knowledge of which machines the suite can currently be run on.</p>
JITLink is LLVM’s new JIT linker designed to support a variety of new features, which includes full static initializer, thread local storage, and small code model, that were not possible in RuntimeDyld, the old JIT linker API. JITLink’s generic linker algorithm needs to be specialized to support the target object format (COFF, ELF, MachO), and architecture (arm, arm64, i386, x86-64). This project aims to implement the JITLink specialization for ELF/aarch64 and COFF/x86-64.
<p>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 one does the reverse, reads object files and emits YAML files. We use these tools to write unit tests for binary tools, e.g., llvm-objdump, llvm-nm, llvm-readelf, as YAML is easier to read and edit than raw assembly codes and pre-built binaries. More importantly, YAML keeps our tests code base maintainable. However, yaml2obj currently doesn’t support generating DWARF sections very well (we have to hardcode the Content field of DWARF sections and it is not intuitive). This project aims to add DWARF support for yaml2obj (ELF part), which will ease our pain crafting DWARF tests.</p>