X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=docs%2FReleaseNotes.html;h=ca47bc58e1938bf7270706168aabdd99306b9afa;hb=6fc205fc446050a434e49e7cfcac89bb5d4435b1;hp=1c4a7ebc9c4c1c8d49e5acf1dcfae2b3b7948b4e;hpb=1b592f0bdf57ca1d1ed0e4a0c9291372fc75f964;p=oota-llvm.git diff --git a/docs/ReleaseNotes.html b/docs/ReleaseNotes.html index 1c4a7ebc9c4..ca47bc58e19 100644 --- a/docs/ReleaseNotes.html +++ b/docs/ReleaseNotes.html @@ -4,11 +4,11 @@
-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.7. 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.org/releases/">LLVM releases 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.
For more information about LLVM, including information about the latest -release, please check out the main LLVM +release, please check out the main LLVM web site. If you have questions or comments, the LLVM developer's mailing list is a good place to send them.
@@ -48,7 +48,7 @@ list is a good place to send them.Note that if you are reading this file from CVS or the main LLVM web page, this document applies to the next release, not the current one. To see the release notes for the current or previous releases, see the releases page.
+href="http://llvm.org/releases/">releases page.This is the sixth public release of the LLVM Compiler Infrastructure.
- -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 is the eighth public release of the LLVM Compiler Infrastructure. This +release incorporates a large number of enhancements and new features, +including vector support (Intel SSE and Altivec), a new GCC4.0-based +C/C++ front-end, Objective C/C++ support, inline assembly support, and many +other big features. +
-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. + +
LLVM 1.7 includes a brand new llvm-gcc, based on GCC 4.0.1. This version +of llvm-gcc solves many serious long-standing problems with llvm-gcc, including +all of those blocked by the llvm-gcc 4 meta +bug. In addition, llvm-gcc4 implements support for many new features, +including GCC inline assembly, generic vector support, SSE and Altivec +intrinsics, and several new GCC attributes. Finally, llvm-gcc4 is +significantly faster than llvm-gcc3, respects -O options, its -c/-S options +correspond to GCC's (they emit native code), supports Objective C/C++, and +it has debugging support well underway.
+ +If you can use it, llvm-gcc4 offers significant new functionality, and we +hope that it will replace llvm-gcc3 completely in a future release. +Unfortunately, it does not currently support C++ exception handling at all, and +it only works on Apple Mac OS/X machines with X86 or PowerPC processors.
+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. -
+ +The LLVM IR and llvm-gcc4 front-end now fully support arbitrary GCC inline assembly. The LLVM X86 and PowerPC +code generators have initial support for it, +being able to compile basic statements, but are missing some features. Please +report any inline asm statements that crash the compiler or that are miscompiled +as bugs.
+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).
+LLVM 1.7 includes a new, fully functional, SPARC backend built in the +target-independent code generator. This SPARC backend includes support for +SPARC V8 and SPARC V9 subtargets (controlling whether V9 features can be used), +and targets the 32-bit SPARC ABI.
+ +The LLVM 1.7 release is the last release that will include the LLVM "SparcV9" +backend, which was the very first LLVM native code generator. It will +be removed in LLVM 1.8, being replaced with the new SPARC backend.
+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:
+LLVM now includes significantly extended support for SIMD vectors in its +core instruction set. It now includes three new instructions for manipulating +vectors: extractelement, +insertelement, and +shufflevector. Further, +many bugs in vector handling have been fixed, and vectors are now supported by +the target-independent code generator. For example, if a vector operation is +not supported by a particular target, it will be correctly broken down and +executed as scalar operations.
-- 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 - } -+
Because llvm-gcc3 does not support GCC generic vectors or vector intrinsics, +llvm-gcc4 must be used.
+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. +
The LLVM X86 backend now supports Intel SSE 1, 2, and 3, and now uses scalar +SSE operations to implement scalar floating point math when the target supports +SSE1 (for floats) or SSE2 (for doubles). Vector SSE instructions are generated +by llvm-gcc4 when the generic vector mechanism or specific SSE intrinsics are +used. +
+ +The LLVM PowerPC backend now supports the Altivec instruction set, including +both GCC -maltivec and -faltivec modes. Altivec instructions are generated +by llvm-gcc4 when the generic vector mechanism or specific Altivec intrinsics +are used.
Bugs fixed in the LLVM Core:
-Code Generator Bugs:
-Bugs in the C/C++ front-end:
-LLVM is known to work on the following platforms:
This section contains all known problems with the LLVM system, listed by component. As new problems are discovered, they will be added to these sections. If you run into a problem, please check the LLVM bug database and submit a bug if +href="http://llvm.org/bugs/">LLVM bug database and submit a bug if there isn't already one.
+llvm-gcc3 has many significant problems that are fixed by llvm-gcc4. See + those blocked on the llvm-gcc4 meta bug. +Two major ones include:
+for (i = 0; i != 1000000; ++i) { @@ -400,8 +397,8 @@ components, please contact us on the llvmdev list. }
A wide variety of additional information is available on the LLVM web page,
-including mailing lists and
-publications describing algorithms and
+ A wide variety of additional information is available on the LLVM web page, including documentation and publications describing algorithms and
components implemented in LLVM. The web page also contains versions of the
API documentation which is up-to-date with the CVS version of the source code.
You can access versions of these documents specific to this release by going
into the "llvm/doc/" directory in the LLVM tree. If you have any questions or comments about LLVM, please feel free to contact
-us via the mailing
+us via the mailing
lists.