LLVM 1.7 Release!

LLVM 1.7 is available now! Download it here: Download LLVM releases
Release notes here: LLVM 1.7 Release Notes

This release is huge! It contains about twice the number of new features as any previous release, and includes some big-ticket items that people have been requesting for a long time.

In particular, this release contains a completely rewritten llvm-gcc (based on GCC 4.0.1), a brand new SPARC backend, supports GCC-style generic vectors, supports SSE and Altivec intrinsics, support for Objective C/C++, the X86 backend generates much better code and can produce Scalar SSE code, this release has initial DWARF debugging support, includes a new llvm-config utility, has initial support for GCC-style inline assembly, and includes many target-independent code generator and optimizer improvements.

The high quality of this release is a direct reflection of a growing number of contibutors in the LLVM community. Traffic on the LLVM developer list has been steadily growing as more people discover the cool things LLVM can do!

Here are some of the major new features of LLVM 1.7:

Core LLVM IR Improvements:

  1. The LLVM IR now has full support for representing target-specific
     inline assembly code, as general as GCC's inline assembly.
  2. Rob Bocchino added new LLVM insertelement and extractelement
     instructions, for accessing/updating scalar elements of a vector.
  3. LLVM now has a new shufflevector instruction, for permuting the
     elements of a vector. LLVM Language Reference Manual — LLVM 16.0.0git documentation
  4. LLVM now supports first class global ctor/dtor initialization lists,
     no longer forcing targets to use "__main".
  5. LLVM supports assigning globals and functions to a particular section
     in the result executable.

LLVM Intrinsic Improvements:

  6. Adding target-specific intrinsics to LLVM is now really easy: entries
     are added to TableGen (.td) files and necessary support code is
     generated from it.
  7. Reid contributed flexible support for "autoupgrading" intrinsics. This
     is useful when we decide to change an intrinsic in a new releases of
     LLVM: .ll and .bc files from old releases get upgraded to the new
  8. Andrew added support for a new LLVM "readcyclecounter" intrinsic, for
     accessing low-level target timing interfaces.
  9. LLVM now supports llvm.stacksave/llvm.stackrestore intrinsics, for
     proper C99 Variable Length Array support.
10. Reid changed many intrinsics to have fixed types instead of being
     overloaded based on type.

Mid-Level Analysis and Transformation Improvements:

11. The -loop-unswitch pass has had several bugs fixed, has several new
     features, and is enabled by default now.
12. Evan improved the loop strength reduction pass to use a parameterized
     target interface and to take advantage of strided loads on targets
     that support them (e.g. X86).
13. The -instcombine pass now uses information about whether individual
     bits are actually used to simplify code.
14. Nate reimplemented post-dominator analysis using the Lengauer and
     Tarjan algorithm, replacing the old iterative implementation. On one
     extreme example (PR681) his implementation is 40x faster than the old
     one and uses 19x less memory.
15. Daniel Berlin contributed an ET-Forest implementation, which
     replaces the old LLVM DominatorSet with a far more efficient data
     structure (in both space and time).
16. Andrew wrote a new "reg2mem" which transforms an LLVM function so that
     there are no SSA values live across basic blocks (useful when
     prototyping transformations that don't handle SSA 'phi' nodes).
17. The -scalarrepl pass can now promote simple unions to registers.
18. The inliner can now inline functions that have dynamic 'alloca'
     instructions in them (without increasing stack usage).
19. The -reassociate pass knows how to factor expressions in several ways,
     e.g. turning (A*A+A*B) into (A*(A+B)) and (X+X+Y+Y) into ((X+Y) << 1)
20. Saem Ghani contributed support to allow different implementations of
     the abstract callgraph interface, e.g., based on pointer analysis.

Debugging Support Improvements:

21. Jim implemented almost complete debugging support in the llvm-gcc 4.0
     front-end and the X86/PowerPC Darwin backends. This includes line
     number information, variable information, function information, frame
     information etc. This is a huge leap in debug support over previous
     releases, the only major missing piece is support for debugging
     optimized code.
22. Jim added support to the C backend for turning line number information
     into #line directives in the output C file.
23. Jim expanded Source Level Debugging with LLVM — LLVM 16.0.0git documentation and filled
     in many details.

Target-Independent Code Generator Improvements:

24. Nate contributed the foundation of vector support including
     instruction selection and tblgen pieces.
25. Evan contributed a new target-independent bottom-up list scheduler.
26. The new list scheduler was enhanced to support top-down scheduling and
     to support target-specific priority functions and resource conflict
27. The code generator now supports many simple inline assembly
     expressions, though there are still cases that are not handled. If
     you get errors or assertions using inline assembly, please file a
     bugzilla bug. Inline assembly is not currently supported in the JIT
     or the C backend.
28. Evan contributed extensive additions to 'tblgen', the code
     generator generator, providing more expressive .td files.
29. Nate integrated switch statement lowering directly into the
     SelectionDAG machinery, eliminating dependence on the lower-switch
     pass to reduce them to branches. In the process, he improved the
     algorithm to avoid emiting some dead comparisons.
30. Evan significantly improved SelectionDAG support for chain and flag
     handling, and added support for describing these nodes in .td files.
31. Nate contributed a framework and implementation for simplifying code
     based on whether computed bits are demanded or not, which works well on
     bitfield manipulations and other bit-twiddling code, particularly for
     removing unneeded sign extensions.
32. Evan added support for adding per-instruction predicates that
     enable/disable specific instructions. This is used to disable
     instructions that are not supported by specific subtargets, etc.
33. LLC has a new -fast option, instructing it to generate code quickly
     instead of optimizing the generated code.
34. There are many compile-time speedups in the code generator.
35. The target-independent AsmPrinter module has many new features, such
     as support for emitting ".asciz" instead of ".ascii" when possible,
     support for .zerofill, support for targets that accept quoted labels,
     etc, and it reduces the amount of target-specific code that needs to
     be written.
36. Nate added support for byte-swap and bit rotate nodes.
37. The legalizer pass is now non-iterative (==faster), simpler, and
     several nasty libcall insertion bugs are now fixed.
38. The register spiller is better at optimizing generated spill code.
39. Evan modified the instruction selector generator to produce code that
     doesn't run out of stack space when compiled with GCC 4.x.
40. Evan added support for lowering memset/memcpy with small fixed sizes
     into discrete load and store instructions.
41. LLVM can now inline the copysign C99/FORTRAN functions.

X86-Specific Code Generator Improvements:

42. Evan added a new DAG-DAG instruction selector for X86,
     replacing the 'pattern' selector.
43. Evan added Scalar SSE support, which provides significantly
     better performance than the LLVM FP stack code.
44. Evan added a register-pressure reducing scheduler priority function,
     which is now used by default on X86.
45. Evan added support for -fpic and -static codegen on Darwin.
46. Evan added initial support for subtargets in the X86 backend,
     including a broad range of -mcpu=* values.
47. Evan improved the loop strength reduction pass on X86, and it is now
     enabled by default on X86.
48. Evan added support for generation of SSE3 instructions (e.g. fisttp)
     on subtargets that support it.

PowerPC-Specific Code Generator Improvements:

49. The PowerPC backend now includes full support for the Altivec
     instruction set, accessible with the GCC generic vector extension and
     the altivec.h intrinsics (llvmgcc4 only), including support for
     -faltivec and -maltivec.
50. Nate greatly simplified the PowerPC branch selector, making it more
     aggressive and removing support code from the target-independent code
     in the process.
51. The PowerPC backend now supports -static and -fpic codegen on Darwin.
52. Many improvements in the generated code.

IA64-Specific Code Generator Improvements:

53. Duraid transitioned the code generator to the new DAG-to-DAG isel
     framework, which is more reliable and produces better code.
54. The Itanium backend now has a bundling pass, which improves
     performance by ~10% and reduces code size. Bundling can be improved
     in the future by implementing a hazard recognizer for the scheduler to
     build better bundles.
55. LLVM has been built with the HP aCC compiler and stdcxx, the Apache
     C++ Standard Library (see Apache C++ Standard Library ). While
     building with compilers other than g++ is not supported, doing so
     should now be more straight-forward.

Alpha-specific Code Generator Improvements:

56. Andrew rewrote the alpha instruction selector to use the new DAG-to-DAG
     instruction selection framework.
57. Andrew fixed several bugs handling weak and linkonce linkage.

SPARC-Specific Code Generator Improvements:

58. LLVM 1.7 includes a completely rewritten SPARC backend. This backend
     has several advantages over the previous LLVM SPARC backend, and will
     replace it entirely in LLVM 1.8. This backend is only about 3700
     lines of code (making it a good reference for new targets), supports
     Sparc V8 and V9 instructions, and produces code that is slightly
     better than GCC on SPEC2000. For more details see:

llvm-gcc 4.0:

59. llvm-gcc4 is a new C/C++/ObjC/ObjC++ front-end, rewritten from scratch,
     based on GCC 4.0.1. This front-end is currently only supported on
     Mac OS/X PowerPC and Intel systems, but we hope to extend support to
     the other LLVM-supported systems in the future.
60. Supports for the GCC "section", "used" and "align" attributes.
61. Full support for the GCC generic vector extension.
62. Full support for PowerPC/Altivec and IA32/SSE intrinsics.
63. Full support for GCC inline assembly (note that there are currently
     some limitations in the code generator though).
64. Full support for C99 Variable Length Arrays.
65. llvm-gcc 4.0 fixes a broad range of long term bugs that have afflicted
     llvm-gcc3 in areas such as ABI compliance, union layout, and bitfield
     handling. There are currently 30 bugs dependent on
     [llvm-gcc] [meta] Make llvm-gcc4 completely replace llvm-gcc3 · Issue #870 · llvm/llvm-project · GitHub .

Other Improvements:

66. The primary LLVM domain name is now http://llvm.org/ .
67. Web form registration is no longer required to download LLVM releases.
68. Eric Kidd contributed the llvm-config utility, to make it easier to
     build and link programs against the LLVM libraries:
69. All LLVM builds now default to having assertions enabled (even release
     builds). To disable them, use 'make DISABLE_ASSERTIONS=1'.
70. Builds from official LLVM releases (such as LLVM 1.7) now default to
     building Release binaries instead of Debug binaries.
71. Saem Ghani extended the PostOrderIterator class to permit external
72. The nightly tester output now color codes performance deltas to make
     it easier to read at a glance.
73. Reid added support for multiple -rpath options to the linker.
74. Reid finished consolidating the host specific code into the libsystem
75. Reid removed use of fork() from bugpoint, allowing it to work on Win32
76. Andrew improved bugpoint's handling of dynamically loaded
     optimization plugins.
77. Morten contributed patches for better support of Visual C++ 2005.

In addition to the new features and infrastructure we have built, we
have also fixed many minor bugs and have made many small optimization
improvements. LLVM 1.7 is the clearly our best release yet, and upgrading
from a previous release is highly recommended.

Finally, Tanya deserves many thanks for spearheading this release and making it happen. If not for her, the release might have been several months later. :slight_smile: Further, she is planning to ensure that future releases happen in a more timely manner than this one. We'd like to get a new LLVM release out every 3-4 months instead of every 6 months.

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.6 announcement: