LLVM 1.5 Release Notes

This document contains the release notes for the LLVM compiler -infrastructure, release 1.5. Here we describe the status of LLVM, including any +infrastructure, release 1.6. Here we describe the status of LLVM, including any known problems and major improvements from the previous release. The most up-to-date version of this document can be found on the LLVM 1.5 web site. If you are +href="http://llvm.cs.uiuc.edu/releases/1.6/">LLVM 1.6 web site. If you are not reading this on the LLVM web pages, you should probably go there because this document may be updated after the release.

@@ -60,286 +60,32 @@ href="http://llvm.cs.uiuc.edu/releases/">releases page.

This is the sixth public release of the LLVM Compiler Infrastructure.

This is the seventh public release of the LLVM Compiler Infrastructure.

LLVM 1.5 is known to correctly compile a wide range of C and C++ programs, -includes bug fixes for those problems found since the 1.4 release, and includes +

LLVM 1.6 is known to correctly compile a wide range of C and C++ programs, +includes bug fixes for those problems found since the 1.5 release, and includes a large number of new features and enhancements, described below.

-New Features in LLVM 1.5 -

- - -

New Native Code -Generators

- -

-This release includes new native code generators for Alpha, IA-64, and SPARC-V8 (32-bit SPARC). These code generators are still -beta quality, but are progressing rapidly. The Alpha backend is implemented -with an eye towards being compatible with the widely used SimpleScalar -simulator. -

- - -

New Instruction -Selector Framework

- -

This release 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 -generating efficient code for getelementptr instructions, promoting -small integer types to larger types (e.g. for RISC targets with one size of -integer registers), expanding 64-bit integer operations for 32-bit targets, etc. -Currently, the X86, PowerPC, Alpha, and IA-64 backends use this framework. The -SPARC backends will be migrated when time permits. -

- - -

New Support for Per-Function -Calling Conventions

- -

LLVM 1.5 adds supports for per-function -calling conventions. Traditionally, the LLVM code generators match the -native C calling conventions for a target. This is important for compatibility, -but is not very flexible. This release allows custom calling conventions to be -established for functions, and defines three target-independent conventions (C call, fast call, and cold call) which may -be supported by code generators. When possible, the LLVM optimizer promotes C -functions to use the "fastcc" convention, allowing the use of more efficient -calling sequences (e.g., parameters are passed in registers in the X86 target). -

- -

Targets may now also define target-specific calling conventions, allowing -LLVM to fully support calling convention altering options (e.g. GCC's --mregparm flag) and well-defined target conventions (e.g. stdcall and -fastcall on X86).

- - -

New Support for -Proper Tail Calls

- -

The release now includes support for proper tail calls, as -required to implement languages like Scheme. Tail calls make use of two -features: custom calling conventions (described above), which allow the code -generator to use a convention where the caller deallocates its stack before it -returns. The second feature is a flag on the call -instruction, which indicates that the callee does not access the caller's -stack frame (indicating that it is acceptable to deallocate the caller stack -before invoking the callee). LLVM proper tail calls run on the system stack (as -do normal calls), supports indirect tail calls, tail calls with arbitrary -numbers of arguments, tail calls where the callee requires more argument space -than the caller, etc. The only case not supported are varargs calls, but that -could be added if desired. -

- -

To ensure a call is interpreted as a tail call, a front-end must mark -functions as "fastcc", mark calls with the 'tail' marker, and follow the call -with a return of the called value (or void). The optimizer and code generator -attempt to handle more general cases, but the simple case will always work if -the code generator supports tail calls. Here is an example:

- -

-    fastcc int %bar(int %X, int(double, int)* %FP) {       ; fastcc
-        %Y = tail call fastcc int %FP(double 0.0, int %X)  ; tail, fastcc
-        ret int %Y
-    }
-

- -

In LLVM 1.5, the X86 code generator is the only target that has been enhanced -to support proper tail calls (other targets will be enhanced in future). -Further, because this support was added very close to the release, it is -disabled by default. Pass -enable-x86-fastcc to llc to enable it (this -will be enabled by default in the next release). The example above compiles to: -

- -

-    bar:
-        sub ESP, 8                   # Callee uses more space than the caller
-        mov ECX, DWORD PTR [ESP + 8] # Get the old return address
-        mov DWORD PTR [ESP + 4], 0   # First half of 0.0
-        mov DWORD PTR [ESP + 8], 0   # Second half of 0.0
-        mov DWORD PTR [ESP], ECX     # Put the return address where it belongs
-        jmp EDX                      # Tail call "FP"
-

- -

-With fastcc on X86, the first two integer arguments are passed in EAX/EDX, the -callee pops its arguments off the stack, and the argument area is always a -multiple of 8 bytes in size. -

- -

- - -

Other New Features

- -

LLVM now includes an - Interprocedural Sparse Conditional Constant Propagation pass, named - -ipsccp, which is run by default at link-time.
LLVM 1.5 is now about 15% faster than LLVM 1.4 and its core data - structures use about 30% less memory.
Support for Microsoft Visual Studio is improved, and now documented. Most LLVM tools build - natively with Visual C++ now.
Configuring LLVM to build a subset - of the available targets is now implemented, via the - --enable-targets= option.
LLVM can now create native shared libraries with 'llvm-gcc ... - -shared -Wl,-native' (or with -Wl,-native-cbe).
LLVM now supports a new "llvm.prefetch - " intrinsic, and llvm-gcc now supports __builtin_prefetch. -
LLVM now supports intrinsics for bit - counting and llvm-gcc now implements the GCC - __builtin_popcount, __builtin_ctz, and - __builtin_clz builtins.
LLVM now mostly builds on HP-UX with the HP aCC Compiler.
The LLVM X86 backend can now emit Cygwin-compatible .s files.
LLVM now includes workarounds in the code generator generator which - reduces the likelyhood of GCC - hitting swap during optimized builds.
The LLVM - Transformation Visualizer (llvm-tv) project has been updated to - work with LLVM 1.5.
Nightly tester output is now archived on the - llvm-testresults mailing list.

+New Features in LLVM 1.6

-Code Quality Improvements in LLVM 1.5 +Code Quality Improvements in LLVM 1.6

The new -simplify-libcalls pass improves code generated for well-known -library calls. The pass optimizes calls to many of the string, memory, and -standard I/O functions (e.g. replace the calls with simpler/faster calls) when -possible, given information known statically about the arguments to the call. -
The -globalopt pass now promotes non-address-taken static globals that are -only accessed in main to SSA registers.
Loops with trip counts based on array pointer comparisons (e.g. "for (i -= 0; &A[i] != &A[n]; ++i) ...") are optimized better than before, -which primarily helps iterator-intensive C++ code.
The optimizer now eliminates simple cases where redundant conditions exist - between neighboring blocks.
The reassociation pass (which turns (1+X+3) into (X+1+3) among other -things), is more aggressive and intelligent.
The -prune-eh pass now detects no-return functions in addition to the - no-unwind functions it did before.
The -globalsmodref alias analysis generates more precise results in some - cases.

- -

-Code Generator Improvements in LLVM 1.5 -

- -

The code generator now can provide and use information about commutative - two-address instructions when performing register allocation.
The code generator now tracks function live-in registers explicitly, - instead of requiring the target to generate 'implicit defs' at the - entry to a function.
The code generator can lower integer division by a constant to - multiplication by a magic constant and multiplication by a constant into - shift/add sequences.
The code generator compiles fabs/fneg/sin/cos/sqrt to assembly instructions - when possible.
The PowerPC backend generates better code in many cases, making use of - FMA instructions and the recording ("dot") forms of various PowerPC - instructions.

+Code Generator Improvements in LLVM 1.6

-Significant Bugs Fixed in LLVM 1.5 -

- -

- - -

Bugs fixed in the LLVM Core:

[dse] DSE deletes stores that - are partially overwritten by smaller stores
[instcombine] miscompilation of - setcc or setcc in one case
Transition code for LLVM 1.0 style varargs was removed from the .ll file - parser. LLVM 1.0 bytecode files are still supported.

- -

Code Generator Bugs:

[cbackend] Logical constant - expressions (and/or/xor) not implemented.
[cbackend] C backend does not - respect 'volatile'.
The JIT sometimes miscompiled globals and constant pool entries for - 64-bit integer constants on 32-bit hosts.
The C backend should no longer produce code that crashes ICC 8.1.

- -

Bugs in the C/C++ front-end:

- +Significant Bugs Fixed in LLVM 1.6