LLVM 1.6 Release!

Hi Everyone,

LLVM 1.6 is out! Get it here:
Download LLVM releases or read about it here:
LLVM 1.6 Release Notes

This release is the culmination of a ton of great work by many people in the LLVM community. This release cycle has been much longer than any previous release cycle, and reflects that in its content. However, because we think that 3-4 months between releases is ideal, we are aiming for more frequent releases in the future.

The main focus of this release has been improving the code generator: we now generate better code, it is now easier to write an LLVM target, and several of the individual targets are more sophisticated. Another major feature of this release is increased maturity of the PowerPC backend and darwin port. Finally, an exciting aspect of the project is that more and more people are using LLVM for a variety of purposes. One of the most visible uses is for academic research projects: groups from across the globe are using LLVM to host their work: The LLVM Compiler Infrastructure Project .

With 1.6 behind us, work is now starting on LLVM 1.7: we already have several great new features in the works. Stay tuned!

Here is more detail on the highlights of the LLVM 1.6 release:

Major New Features:

  1. Reid added guards to the JIT, enabling it to JIT multithreaded code
     (on systems with pthreads). Threads support can be disabled by
     configuring LLVM with the --disable-threads switch.
  2. LLVM includes a new optimization to statically evaluate C++ static
     variable constructors when they are simple enough. For example, it
     can now statically initialize "struct X { int a; X() : a(4) {} } g;".
  3. The Loop Strength Reduction pass is completely rewritten, far more
     aggressive and enabled by default on most RISC targets. On PPC, we
     find that it often speeds up programs from 10-40% depending on the
  4. LLVM now includes support for auto-generating large portions of the
     instruction selectors from target descriptions. This allows us to
     write patterns in the target .td file, instead of writing lots of
     nasty C++ code. Most of the PowerPC instruction selector is now
     generated from the PowerPC target description files and other targets
     are adding support that will be live for LLVM 1.7.
  5. Andrew has dramatically improved the LLVM Alpha backend to the point
     where it is now considered fully functional and off the 'beta' list.

Major Code Generator Changes:

  6. Nate wrote a new component for the backend, a DAG Combiner. This
     allows the backend to take advantage of identities and do low-level
     peephole-style optimizations on the DAG.
  7. Nate added support for a new TargetSubtarget interface, which
     determines which parts of the target to enable based on the
     target-triple (e.g., whether to use GAS or Intel asm printers on X86).
  8. Jim Laskey extended sub-target support to include -mcpu and -mattr,
     allowing the target to think about what to do when particular features
     are enabled, but allowing the end-user to think about what CPU they
  9. Jim also contributed a new light-weight instruction scheduler,
     available to targets that use DAG-to-DAG instruction selectors. In
     this release, the scheduler is fully operational but needs tuning, so
     it is not enabled by default.
10. The instruction selector framework now supports DAG-to-DAG instruction
     selection, where the instruction selector does pattern matching but
     no code emission (necessary for scheduling & .td file autogeneration).

Other Code Generator Changes:

11. Duraid contributed many small improvements to the Itanium backend, and
     is actively moving it to the new isel framework.
12. Andrew Lenharth contributed a major change to the varargs support,
     allowing LLVM to work with targets whose va_list type is a struct.
13. The instruction selection framework that debuted in LLVM 1.5 is far
     more mature/robust and knows about many more strange target features.
14. Andrew added initial JIT support to the Alpha backend, which can run
     some simple programs. It is not fully complete yet, though.
15. Jim Laskey contributed patches to improve the instruction selection in
     the PowerPC backend, matching more RLWIMI cases, for example.
16. Nate implemented most of the PowerPC DAG-to-DAG instruction selector.
17. The tblgen tool & code generator now have more assertions and
     checking, which catch errors early, making it easier to work on the
18. The default register allocator is now far faster on some testcases,
     particularly on targets with a large number of registers (e.g. IA64
     and PPC).
19. Jim extended tblgen to allow description of subtarget features in the
     .td files for the target.
20. There have been several minor improvements to the register allocator
     to coalesce more aggressively and coalesce spill code with copies more

Miscellaneous Improvements:

21. Andrew added support to the JIT to built a Global Offset Table if
     needed by a target.
22. Alexander Friedman improved the .ll file parser to be able to read
     from a text buffer in addition to a file.
23. Bryan Turner tried LLVM with Quest, a random testcase generator, and
     exposed several bugs (which are now fixed).
24. The llvm-test suite can now use the NAG Fortran to C compiler to
     compile SPEC FP programs, if available (allowing us to test all of
     SPEC'95 & 2K).
25. The JIT-debugger mode of bugpoint is now much faster than before.
26. When bugpoint is grinding away and the user hits ctrl-C, it now
     gracefully stops and gives what it has reduced so far (instead of
     giving up completely).
27. LLVM now includes Xcode project files.
28. Jim Laskey added bitvector support to the command line option parsing
     library. See CommandLine 2.0 Library Manual — LLVM 16.0.0git documentation
29. We no longer build two versions of most LLVM libraries, which reduces
     the time required to build LLVM.
30. Documentation for the code generator is improving, though it is
     still incomplete: The LLVM Target-Independent Code Generator — LLVM 16.0.0git documentation
31. The code produced when exception handling is enabled is far more
     efficient in some cases, particularly on Mac OS/X.
32. LLVM should build faster than before: it only links each library in
     one configuration (instead of two), and some old code has been

Portability Improvements:

33. Nate added support for Mac OS/X on Intel.
34. X86 tail calls now work with the JIT and Jeff Cohen added code
     to support them under Visual C++.
35. Nate contributed a patch to allow LLVM to build with GCC 4.x, and Reid
     contributed several cleanup patches to silence GCC 4 warnings.
36. The llvm-test suite is now fully compatible with Mac OS/X
     (non-portabilities in the programs have been fixed).
37. Jeff Cohen contributed portability fixes to build on AMD64.
38. Jeff and Reid improved the Visual C++ build to not require any GNU
     utilities like flex, bison, or sed.

In addition to the new features and infrastructure we have built, we have also fixed many minor bugs in the C/C++ front-end, optimizers, and code generator including 63 bugzilla bugs (search for target milestone = 1.6). LLVM 1.6 is by far the best release we've had yet!

Also, special thanks to John, Bill and Tanya for organizing the 1.6 release process and testing the prerelease tarballs!

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

Finally, here is the previous status report, the LLVM 1.5 announcement: