Open LLVM Projects

If you are thinking about tackling one of these projects, please send a mail to the LLVM Developer's mailing list, so that we know the project is being worked on. Additionally this is a good way to get more information about a specific project or to suggest other projects to add to this page.

1. Olden timings - Time the compilation and execution times for the Olden benchmark suite, keeping track of these values over time.
2. Graphs - It would be great to have gnuplot graphs to keep track of how the tree is changing over time. We already gather a several statistics, it just neccesary to add the script-fu to gnuplotize it.
3. Regression tests - We should run the regression tests in addition to the program tests...

When testing a code, try running it with a variety of optimizations, and with all the back-ends: CBE, llc, and lli.

1. Transform setjmp and longjmp calls to use the LLVM invoke mechanism.
2. Add support for a volatile attribute on loads and stores
3. Support for variable argument functions
4. Add a new conditional move instruction: X = select bool Cond, Y, Z
5. Add support for platform independent prefetch support. The GCC prefetch project page has a good survey of the prefetching capabilities of a variety of modern processors.

1. Someone needs to look into getting the ranlib tool to index LLVM bytecode files, so that linking in .a files is not hideously slow. They would also then have to implement the reader for this index in gccld.
   
2. Improve the efficiency of the bytecode loader/writer, allow streaming lazy loading of functions from the bytecode (for use by the JIT, for example)
   
3. Rework the PassManager to be more flexible
4. Some transformations and analyses only work on reducible flow graphs. It would be nice to have a transformation which could be "required" by these passes which makes irreducible graphs reducible. This can easily be accomplished through code duplication. See Making Graphs Reducible with Controlled Node Splitting and perhaps Nesting of Reducible and Irreducible Loops.

1. Implement a flow-sensitive context-sensitive alias analysis algorithm
   - Pick one of the somewhat efficient algorithms, but strive for maximum precision
2. Implement a flow-sensitive context-insensitive alias anlaysis algorithm
   - Just an efficient local algorithm perhaps?
3. Implement an interface to update analyses in response to common code motion transformations
4. Implement alias analysis based optimizations:
   • Dead store elimination
   • Store+Reload or "store forwarding" elimination:

     Change:

             store int X, int* P
             Y = load int* P

     into:

             store int X, int *P
             Y = X

Ideas for profile guided transformations:

1. Superblock formation (with many optimizations)
2. Loop unrolling/peeling
3. Profile directed inlining
4. Code layout
5. ...

1. Implement a Dependence Analysis Infrastructure
   - Design some way to represent and query dep analysis
2. Implement a faster Dominator Set Construction Algorithm
   - A linear time or nearly so algorithm
3. Implement a strength reduction pass
4. Value range propagation pass
5. Implement a tail recursion elimination pass
6. Implement an unswitching pass

1. Implement a global register allocator
2. Implement a better instruction selector
3. Implement a static compiler in addition to the JIT (easy project)
4. Implement support for the "switch" instruction without requiring the lower-switches pass.

1. Write a new frontend for some language (Java? OCaml? Forth?)
2. Write a new backend for a target (IA64? MIPS? MMIX?)