This document contains the release notes for the LLVM compiler infrastructure, release 1.5. Here we describe the status of LLVM, including any -known problems and 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 not reading this on the LLVM web pages, you should probably go there because this document may be updated after the release.
@@ -60,48 +60,124 @@ href="http://llvm.cs.uiuc.edu/releases/">releases page.This is the sixth public release of the LLVM compiler infrastructure.
+This is the sixth public release of the LLVM Compiler Infrastructure.
-At this time, LLVM is known to correctly compile a broad range of C and -C++ programs, including the SPEC CPU95 & 2000 suite. TODO. It also includes -bug fixes for those problems found since the 1.4 release.
+At this time, LLVM is known to correctly compile a wide range of C and C++ +programs, including the SPEC CPU95 & 2000 suite. It includes bug fixes for +those problems found since the 1.4 release and a large number of new features +and enhancements, described below.
+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. +
+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 hosts, etc. +Currently, the X86, PowerPC, Alpha, and IA-64 backends use this framework. The +SPARC backends will be migrated when time permits. +
+LLVM 1.5 adds supports for custom and +target-specific 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).
+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 emit code for the caller to deallocate its own stack when it +returns. The second feature is a flag on the call +instruction, which indicates that the callee does not access the callers +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. +
+ +In order for a front-end to get guaranteed tail call, it 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 a simple 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. X86 +support will be enabled by default in the next LLVM release.
+Code Generator Bugs: