LLVM February Status Update

Hi Everyone,

Sorry for the long overdue status update, as you might guess, the holidays
have been busy for everyone. :slight_smile:

Here's your periodic dose of updates on the progress of LLVM, which takes
us from the LLVM 1.4 release until present CVS. I appologize if I forgot anything!

Big Things:

  1. Brian contributed a new SparcV8 backend, which (unlike the SparcV9
     backend) uses the target-independent code generator. This port
     mostly works with many programs, but still has some bugs. If you're
     interested in helping out, please let us know.
  2. Andrew Lenharth is working on a native Alpha backend for LLVM. It can
     run many programs correctly, but does not currently support C++,
     longjmp, varargs, or dynamic stack allocations yet.
         Alpha Nightly Tester: http://www.lenharth.org/llvm-alpha/
  3. Duraid Madina has started work on an IA-64 backend and will be
     checking it into CVS in the near future.
  4. As mentioned here:
     We've changed the llvm-gcc build instruction to build executables
     prefixed with "llvm-" to make it easier to use.

LLVM Core Changes:

  5. Improvements to the implementation of the LLVM representation have
     shrunk the memory/cache footprint of the IR by about 30% and sped up
     LLVM overall by about 15-20% for large programs.
  6. Reid refactored linker/archive resolution support into a new
     lib/Linker library.
  7. Reid is continuing work on libsystem and has factored a bunch of
     system specific routines out of libsupport.

Operating System Ports:

  8. Jeff Cohen has dramatically improved support for building LLVM with
     the Microsoft Visual C++ compiler. Most of the LLVM tools build now,
     and he wrote a document describing how to use it:
  9. Duraid Madina has ported LLVM to build on HP-UX with the HP aCC
     compiler. For more information, see:
10. Henrik Bach is continuing his work to get LLVM fully functional on
     Win32 with the MingW compiler. The port is basically functional, but
     some final patches still need to be integrated into CVS.

Optimization Changes:

11. LLVM now includes an interprocedural sparse constant propagation
     implementation, named "-ipsccp". This is enabled by default at
12. The -globalopt pass now shrinks two-state global variables (e.g.
     integers that can only ever contain 0 and 1) to booleans, improving
     later range analysis and reducing memory usage slightly.
13. Alkis enhanced the -globalopt pass to promote scalar global variables
     into SSA values if they are only used by the 'main' function. This
     is particularly useful for eliminating static final class fields that
     have dynamic initializers in Java.
14. The ADCE and GCSE passes are each about 20% faster. The GCSE and DSE
     passes are another 20% faster on programs with complex nested types.
15. We now have better optimization of pointer comparisons and
     subtractions, particularly in loops (which often occurs with C++
     iterators, for example).

Native Code Generator Changes:

16. The LLVM code generator now includes a new framework for building
     instruction selectors, which has long been the hardest part of
     building a new LLVM target. This framework handles a lot of the
     mundane (but easy to get wrong) details of writing the instruction
     selector, such as code generating (efficient) getelementptr
     instructions, promoting small integer types to larger types (e.g.
     for RISC targets with one size of integer registers), expanding
     integers (e.g. 64-bit integers into two 32-bit registers), etc.
     Currently, the Alpha, IA-64, and X86 backends use this framework.
     There is some high-level documentation available here:
17. Reid enhanced the X86 backend to emit Cygwin-compatible .s files.
18. The tblgen backend that autogenerates target-specific asm writers
     generates much more compact and efficient asmwriters. This works
     around the "g++ hits swap compiling asmwriters in optimized builds"
     problem. See LLVM PR448 for more information.
19. The LLVM makefiles have been improved to avoid regenerating all of the
     targets whenever tblgen is rebuilt.
20. The code generator now can take advantage of commutative instructions
     when coallescing live ranges for 2-address instructions.
21. Andrew added support to the tblgen asmwriter for escaping the '$'
     character in instruction strings.

Other Miscellaneous changes:

22. The LLVM pool allocator is now available in the public CVS tree as the
     llvm-poolalloc module.
23. Dinakar Dhurjati added MediaBench to the llvm-test suite.
24. Bugpoint now supports -abs-tolerance and -rel-tolerance flags to debug
     programs that emit floating point values which are allowed to be
     slightly off (e.g. to treat 0.445 and 0.444 as the same).

Notable bugs fixed:

  PR490: [cbackend] Logical constant expressions (and/or/xor) not implemented.
  PR491: [dse] Dead Store Elimination deletes stores that are partially
         overwritten by smaller stores.
  PR487: llvm-gcc incorrectly rejects some constant initializers involving
         the addresses of array elements.
  PR501: llvm-g++ doesn't support C++ anonymous unions.
  PR502: [llvm-g++] Link failure linking POD 'const' global with a dynamic
  PR509: [llvm-g++] llvm-g++ used dynamic global variable initializers in
         some cases where static initializers would work.
  PR511: [cbackend] C backend does not respect 'volatile'.

Finally, here's a link to the previous status update, the 1.4 release:

If you have any questions or comments about LLVM or any of the features in
this status update, please feel free to contact us on the llvmdev mailing list (llvmdev at cs.uiuc.edu)!