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