The LLVM Compiler Infrastructure

Hi Everyone, I'm happy to say that LLVM has made many leaps and bounds since the last update in November. Because we are bumping the major version number with this release, we're letting the release go for twice as long as our planned release ... [More] schedule (6 months instead of 3). We are currently half way through the LLVM 2.0 development cycle. So far, many important and invasive changes have landed in 2.0, including a complete replacement of the integer type system (necessitating replacement of many instructions), lots of new features have been added (e.g. ARM/Thumb is now fully supported), and of course many bugs have been found and fixed. Here are some of the most notable aspects of LLVM CVS (to become LLVM 2.0) so far: Major LLVM Changes: 1. llvm-gcc3 is now officially unsupported. LLVM 2.0 will require users to upgrade to llvm-gcc4. llvm-gcc4 includes many features over llvm-gcc3, is faster, and is much easier to build. Whenever I refer to llvm-gcc in this email, I mean llvm-gcc4. 2. Reid contributed changes to make the integer types in LLVM completely signless. This means that we have types like i8/i16/i32 instead of ubyte/sbyte/short/ushort/int etc. In order to support this, the LLVM operations that depend on sign have been split up into separate instructions. For example, instead of shr, we now have ashr/lshr. Instead of 'cast', we now 12 explicit instructions like trunc, zext, and sext. See http://llvm.org/PR950 for more details. This change makes the IR more powerful and efficient. We now no-longer have casts that simply change sign (e.g. int <-> uint), and we now support new operations like bitcast from fp to integer. 3. Reid and Sheng contributed changes to support arbitrary bitwidth integers (e.g. i13, i36, i42, etc) in the front-end and LLVM IR (the code generator does not support them yet). CVS currently supports bitwidths <= 64 bits. Work to support bitwidths larger than 64 bits is underway. See http://llvm.org/PR1043 for more details. 4. Reid removed the 'type planes' of LLVM 1.x. It is no longer possible to have two values with the same name in the same symbol table. This simplifies LLVM internals, allowing significant speedups. See http://llvm.org/PR411 for more information. 5. Global variables and functions in .ll files are now prefixed with < at > instead of %. This fixes some long-standing ambiguity problems with some cases. See http://llvm.org/PR645 for more details. New Features: 6. Devang implemented support for Precompiled Headers (PCH) in llvm-gcc. 7. Anton contributed support for external weak linkage and hidden visibility. 8. Andrew contributed support for packed structure types, which allows LLVM to express unaligned data more naturally. 9. Support for inline assembly in llvm-gcc is much improved, and many related bugs have been fixed. 10. Duncan Sands has contributed many llvm-gcc patches to better support Ada, including support for nested functions. 11. Reid added support for tracking function parameter/result attributes in LLVM. Optimizer Improvements: 12. Devang rewrote the pass manager, making it significantly smaller, simpler and more extensible. He added support for running FunctionPass's interlaced with CallGraphSCCPass's, which improves the cost model in the inliner and speeds it up. 13. The -scalarrepl pass can now promote unions containing FP values into a register, it can also handle unions of vectors of the same size. 14. Nick Lewycky contributed significant improvements to the predicate simplifier pass, making it able to do simple value range propagation and eliminate more conditionals. Target-Independent Code Generator Enhancements: 15. Jim contributed initial pieces of support for Zero-cost DWARF exception handling. It is now possible to throw through LLVM-compiled stack frames (callee save registers are properly restored) and C 'catch' statements work in simple cases. 16. Owen extended TargetData to support better target parameterization in the .ll/.bc files, eliminating the 'pointersize/endianness' attributes in the files. See http://llvm.org/PR761 for more info. 17. Scott Michel contributed patches to generalize TargetData for finer grained alignment handling, handling of vector alignment, and handling of preferred alignment. 18. Evan improved the scheduler to better reduce register pressure on X86 and other targets that are register pressure sensitive. 19. Evan contributed support for software floating point routines. 20. Jim improved DWARF debug information generation. LLVM now passes most of the GDB testsuite on MacOS and debug info is more dense. 21. Nate's work on a direct Mach-o .o file writer is making great progress. Many small apps work, but it is not quite complete yet. X86-Specific Code Generator Enhancements: 22. Dan Gohman contributed several patches to improve linux/x86-64 support. 23. Anton contributed PIC support for linux/x86. 24. Anton contributed support for the GCC regparm attribute, and code in the X86 backend to respect it. 25. Evan added various improvements for the X86-64 JIT, allowing it to generate code in the large code model. 26. LLVM now supports inline asm with multiple constraint letters per operand (like "ri") which is common in X86 inline asms. 27. Andrew contributed early support for X86 inline asm in the C backend. Other Target-Specific Code Generator Enhancements: 28. Lauro and Rafael contributed several improvements to the ARM backend, including basic inline asm support, weak linkage support, static ctor/dtor support and many bug fixes. 29. Evan contributed major enhancements to the ARM backend, including support for ARM v4-v6, vfp support, soft float, pre/postinc support, load/store multiple generation, and constant pool entry motion (to support large functions). 30. Evan contributed support for Thumb code generation (an ARM subtarget). 31. The PowerPC 64 JIT now supports addressing code loaded above the 2G boundary. 32. Nick Lewycky contributed several patches to improve support for the Linux/ppc ABI. 33. Jim contributed many bug fixes for PowerPC 64. Internal Cleanups: 34. Sheng merged the ConstantBool, ConstantIntegral and ConstantInt classes together, we now just have ConstantInt. 35. LLVM no longer relies on static destructors to shut itself down. Instead, it lazily initializes itself and shuts down when llvm_shutdown() is explicitly called. 36. LLVM now has significantly fewer static contructors, reducing startup time. 37. Bill refactored several classes to reduce the amount of code that gets linked into apps that use the JIT. 38. Dan Gohman contributed patches to simplify construction of intrinsic function declarations. Other Changes: 39. Reid contributed the llvm-upgrade tool, which migrates LLVM 1.9 .ll files to LLVM 2.0 syntax. This is the primary upgrade path for files compiled with LLVM 1.x to LLVM 2.x. 40. Reid removed the gccas/gccld tools. They have been replaced with small shell scripts that invoke opt/llvm-ld respectively. These scripts may be removed before LLVM 2.0 is released, so please migrate away from them. This reduces LLVM's install footprint. 41. LLVM has had a lot of performance work, specifically designed to tune datastructure usage. This makes several critical components faster. http://llvm.org/docs/ProgrammersManual.html#datastructure 42. As the community has continued to grow, we found it useful to codify some of the development practices we use for new contributors. If you're interested in our "community architecture", I encourage you to read through the 'LLVM Developer Policy' document: http://llvm.org/docs/DeveloperPolicy.html As usual, there have been a ton of bug fixes and other improvements. LLVM has successfully built a number of large projects like Mozilla, Qt, etc. There have also been a large number of minor codegen improvements - the compiler generates better code than ever before. As you can see, LLVM 2.0 is shaping up to be an amazing release. Many thanks go out to everyone who has contributed to it in both large and small ways. The LLVM community is vibrant and growing! Finally, here is the previous status report, the LLVM 1.9 Release: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2006-November/ 000020.html If you have any questions or comments, please contact the LLVMdev mailing list (llvmdev at cs.uiuc.edu)! -Chris [Less]

LLVM 1.9 is available now! Download it here: http://llvm.org/ releases/ or view the release here: http://llvm.org/releases/1.9/docs/ ReleaseNotes.html This is a huge new release with many improvements, new features, better codegen, faster ... [More] compiles, and many bugs fixed. One telling feature is that LLVM now correctly builds itself and passes all its regression tests when self-hosted: an impressive feat, considering that it is ~400,000 lines of complex C/C++ code. While LLVM 1.9 stuck to our planned 3-month release cycle, we plan to extend this cycle to 6 months for the 2.0 release. This longer release cycle will allow us to focus on cleaning up LLVM APIs and removing some old backward compatibility code we have maintained since 1.0. As such, we plan for LLVM 2.0 to drop support for some really old .bc and .ll files (LLVM 1.4 and earlier), and LLVM 2.0 will probably drop support for llvm-gcc3. I plan to send out a status update in 3 months to update everyone on the progress of LLVM 2.0. Here are some of the most notable aspects of the LLVM 1.9 Release: Major new Features: 1. Evan contributed a new X86-64 backend. Currently it supports Darwin/x86-64, and other operating systems in -static mode. Support for PIC codegen on other target should be straight-forward to add if someone is interested. 2. Devang contributed liblto, a library which allows a system linker to efficiently and tightly integrate LLVM Link-Time- Optimization: http://llvm.org/docs/LinkTimeOptimization.html 3. Bill and Nate integrated support for SPECCPU2006 into the llvm-test makefile system, which allows it to work with our nightly tester and automatic testcase reduction tools. 4. Reid wrote a new FAQ for the oft-misunderstood getelementptr instruction: http://llvm.org/docs/GetElementPtr.html Mid-Level Optimizer Enhancements: 5. Nick Lewycky contributed a new 'predicate simplifier' pass, which currently performs dominator tree-based optimizations. 6. Owen extended the loop unroll pass to support unrolling of multiple basic block loops. 7. The 'globalopt' pass can now perform the scalar replacement of aggregates transformation on some heap allocations. 8. The globalsmodref-aa alias analysis can now track 'indirect pointer globals' more accurately. 9. The instruction combiner now performs element propagation analysis of vector expressions, eliminating computation of vector elements that are not used. 10. The Loop Closed SSA pass is significantly faster at updating SSA. 11. Several LLVM transformations which had compile time explosions have been fixed. 12. Devang fixed several cases of nondeterministic behavior and tracked down several bugs blocking LLVM from building itself. Target-Independent Code Generator Enhancements: 13. LLVM now includes a late branch folding pass which optimizes code layout, performs several branch optimizations, and deletes unreachable code. 14. Evan contributed common code generator support for targets that support pre/post-increment addressing modes. 15. Jim added support for dynamically-loadable register allocators and schedulers. 16. Evan modified the DAG instruction selector to be iterative instead of recursive, fixing "out of stack space" problems with very large basic blocks when LLVM is compiled with GCC 4.x. 17. LLVM 1.9 includes several improvements to inline asm support, including support for new constraints and modifiers. 18. The register coalescer is now more aggressive than before, allowing it to eliminate more copies. 19. The core SelectionDAG data structures are now much more efficient, which yields faster compiles. 20. Bill sped up PHI elimination and live variables significantly on large functions by eliminating N^2 algorithms. 21. The target-independent switch lowering code now produces better code in several situations for common idioms. 22. Jim added several enhancements to speed up debug info generation and reduce the size of the emitted debug info. Target-specific Enhancements: 23. Anton contributed support for Win32 dllimport/dllexport linkage and stdcall/fastcall calling conventions. 24. Jim contributed support for Darwin/x86 debug information. 25. Reid contributed basic Linux/X86 support for LLVM debug info. 26. Anton contributed basic debug support for Cygwin and MingW when those environments are configured to use DWARF. 27. Anton contributed several patches to improve compatibility with MingW. 28. Evan added code generator support for machine-specific constant pool entries. 29. Rafael enhanced the LLVM ARM backend to support more instructions and the use of a frame pointer. It is now possible to build libgcc and a simple cross compiler, but it is not considered "complete" yet. 30. Nate contributed initial support for a direct Mach-o object file writer, but it is not yet complete. Target Description Enhancements: 31. tblgen now allows definition of 'multiclasses' which can be used to factor instruction patterns more aggressively in .td files. 32. Jim added a new TargetAsmInfo class which captures a variety of information about the target assembly language format. 33. .td files now support "${:foo}" syntax for encoding subtarget- specific assembler syntax into instruction descriptions. Major LLVM IR / API Changes: 34. Reid merged the ConstantUInt and ConstantSInt classes together into a single ConstantInt class. 35. Reid split the 'div' instruction into fdiv/sdiv/udiv operations and 'rem' into frem/srem/urem. We hope that LLVM 2.0 will split all instructions that vary behavior based on the signedness of their operands. See http://llvm.org/PR950 for more details. 36. ConstantBool::True and False have been renamed to ConstantBool::getTrue() and ConstantBool::getFalse(). LLVM Build System Changes: 37. The LLVM library dependency graph is now acyclic, allowing llvm-config to always work. The LLVM build system itself now internally uses llvm-config. 38. Reid updated autoconf/libtool to newer versions. 39. Reid contributed changes to eliminate C++ exception handling use from several libraries. Almost all of LLVM now builds with -fno-exceptions, which shrinks executables significantly. 40. Reid contributed changes to make LLVM -Woverloaded-virtual and -Wunused clean. These are now enabled by default. 41. Jeff Cohen contributed changes to ensure LLVM builds with MSVC++ 7.1 and updated project files to work with it. 42. Jim updated the Xcode project files. Other Changes: 43. Patrick contributed a new mode to bugpoint: -find-bugs. This asks bugpoint to permute pass sequences to try to expose bugs due to pass sequencing. 44. The JIT now supports lazily streaming code from multiple modules at a time, implicitly linking the code as it goes. 45. Bill and Fernando contributed new sections describing the code generator: http://llvm.org/docs/CodeGenerator.html 46. Reid merged the functionality of the 'analyze' tool into the 'opt' tool, cutting LLVM's disk footprint significantly. 47. Domagoj Babic contributed patches to make bugpoint converge faster when reducing programs. 48. LLVM now uses far fewer static constructors than it used to: it now lazily initializes global datastructures and provides an explicit 'teardown' API for releasing the memory associated with them. 49. Devang changed llvm-gcc to obey several GCC optimization options, including -funroll-loops, -fno-unit-at-a-time, -fno-inline-functions, etc. In addition to the new features and infrastructure we have built, we also fixed many minor bugs and made many diverse optimization improvements. LLVM 1.9 is the clearly our best release yet, and upgrading from a previous release is highly recommended. This release wouldn't be possible without the LLVM community building new features, reporting bugs, testing the pre-release bits, and contributing in many other ways. Tanya (our release manager) deserves a lot of credit for this being the smoothest and best release so far! Here is the previous status report, the LLVM 1.8 Release: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2006-August/000019.html If you have any questions or comments, please contact the LLVMdev mailing list (llvmdev at cs.uiuc.edu)! -Chris [Less]

LLVM 1.9 is available now! Download it here: http://llvm.org/ releases/ or view the release here: http://llvm.org/releases/1.9/docs/ ReleaseNotes.html This is a huge new release with many improvements, new features, better codegen, faster ... [More] compiles, and many bugs fixed. One telling feature is that LLVM now correctly builds itself and passes all its regression tests when self-hosted: an impressive feat, considering that it is ~400,000 lines of complex C/C code. While LLVM 1.9 stuck to our planned 3-month release cycle, we plan to extend this cycle to 6 months for the 2.0 release. This longer release cycle will allow us to focus on cleaning up LLVM APIs and removing some old backward compatibility code we have maintained since 1.0. As such, we plan for LLVM 2.0 to drop support for some really old .bc and .ll files (LLVM 1.4 and earlier), and LLVM 2.0 will probably drop support for llvm-gcc3. I plan to send out a status update in 3 months to update everyone on the progress of LLVM 2.0. Here are some of the most notable aspects of the LLVM 1.9 Release: Major new Features: 1. Evan contributed a new X86-64 backend. Currently it supports Darwin/x86-64, and other operating systems in -static mode. Support for PIC codegen on other target should be straight-forward to add if someone is interested. 2. Devang contributed liblto, a library which allows a system linker to efficiently and tightly integrate LLVM Link-Time- Optimization: http://llvm.org/docs/LinkTimeOptimization.html 3. Bill and Nate integrated support for SPECCPU2006 into the llvm-test makefile system, which allows it to work with our nightly tester and automatic testcase reduction tools. 4. Reid wrote a new FAQ for the oft-misunderstood getelementptr instruction: http://llvm.org/docs/GetElementPtr.html Mid-Level Optimizer Enhancements: 5. Nick Lewycky contributed a new 'predicate simplifier' pass, which currently performs dominator tree-based optimizations. 6. Owen extended the loop unroll pass to support unrolling of multiple basic block loops. 7. The 'globalopt' pass can now perform the scalar replacement of aggregates transformation on some heap allocations. 8. The globalsmodref-aa alias analysis can now track 'indirect pointer globals' more accurately. 9. The instruction combiner now performs element propagation analysis of vector expressions, eliminating computation of vector elements that are not used. 10. The Loop Closed SSA pass is significantly faster at updating SSA. 11. Several LLVM transformations which had compile time explosions have been fixed. 12. Devang fixed several cases of nondeterministic behavior and tracked down several bugs blocking LLVM from building itself. Target-Independent Code Generator Enhancements: 13. LLVM now includes a late branch folding pass which optimizes code layout, performs several branch optimizations, and deletes unreachable code. 14. Evan contributed common code generator support for targets that support pre/post-increment addressing modes. 15. Jim added support for dynamically-loadable register allocators and schedulers. 16. Evan modified the DAG instruction selector to be iterative instead of recursive, fixing "out of stack space" problems with very large basic blocks when LLVM is compiled with GCC 4.x. 17. LLVM 1.9 includes several improvements to inline asm support, including support for new constraints and modifiers. 18. The register coalescer is now more aggressive than before, allowing it to eliminate more copies. 19. The core SelectionDAG data structures are now much more efficient, which yields faster compiles. 20. Bill sped up PHI elimination and live variables significantly on large functions by eliminating N^2 algorithms. 21. The target-independent switch lowering code now produces better code in several situations for common idioms. 22. Jim added several enhancements to speed up debug info generation and reduce the size of the emitted debug info. Target-specific Enhancements: 23. Anton contributed support for Win32 dllimport/dllexport linkage and stdcall/fastcall calling conventions. 24. Jim contributed support for Darwin/x86 debug information. 25. Reid contributed basic Linux/X86 support for LLVM debug info. 26. Anton contributed basic debug support for Cygwin and MingW when those environments are configured to use DWARF. 27. Anton contributed several patches to improve compatibility with MingW. 28. Evan added code generator support for machine-specific constant pool entries. 29. Rafael enhanced the LLVM ARM backend to support more instructions and the use of a frame pointer. It is now possible to build libgcc and a simple cross compiler, but it is not considered "complete" yet. 30. Nate contributed initial support for a direct Mach-o object file writer, but it is not yet complete. Target Description Enhancements: 31. tblgen now allows definition of 'multiclasses' which can be used to factor instruction patterns more aggressively in .td files. 32. Jim added a new TargetAsmInfo class which captures a variety of information about the target assembly language format. 33. .td files now support "${:foo}" syntax for encoding subtarget- specific assembler syntax into instruction descriptions. Major LLVM IR / API Changes: 34. Reid merged the ConstantUInt and ConstantSInt classes together into a single ConstantInt class. 35. Reid split the 'div' instruction into fdiv/sdiv/udiv operations and 'rem' into frem/srem/urem. We hope that LLVM 2.0 will split all instructions that vary behavior based on the signedness of their operands. See http://llvm.org/PR950 for more details. 36. ConstantBool::True and False have been renamed to ConstantBool::getTrue() and ConstantBool::getFalse(). LLVM Build System Changes: 37. The LLVM library dependency graph is now acyclic, allowing llvm-config to always work. The LLVM build system itself now internally uses llvm-config. 38. Reid updated autoconf/libtool to newer versions. 39. Reid contributed changes to eliminate C exception handling use from several libraries. Almost all of LLVM now builds with -fno-exceptions, which shrinks executables significantly. 40. Reid contributed changes to make LLVM -Woverloaded-virtual and -Wunused clean. These are now enabled by default. 41. Jeff Cohen contributed changes to ensure LLVM builds with MSVC 7.1 and updated project files to work with it. 42. Jim updated the Xcode project files. Other Changes: 43. Patrick contributed a new mode to bugpoint: -find-bugs. This asks bugpoint to permute pass sequences to try to expose bugs due to pass sequencing. 44. The JIT now supports lazily streaming code from multiple modules at a time, implicitly linking the code as it goes. 45. Bill and Fernando contributed new sections describing the code generator: http://llvm.org/docs/CodeGenerator.html 46. Reid merged the functionality of the 'analyze' tool into the 'opt' tool, cutting LLVM's disk footprint significantly. 47. Domagoj Babic contributed patches to make bugpoint converge faster when reducing programs. 48. LLVM now uses far fewer static constructors than it used to: it now lazily initializes global datastructures and provides an explicit 'teardown' API for releasing the memory associated with them. 49. Devang changed llvm-gcc to obey several GCC optimization options, including -funroll-loops, -fno-unit-at-a-time, -fno-inline-functions, etc. In addition to the new features and infrastructure we have built, we also fixed many minor bugs and made many diverse optimization improvements. LLVM 1.9 is the clearly our best release yet, and upgrading from a previous release is highly recommended. This release wouldn't be possible without the LLVM community building new features, reporting bugs, testing the pre-release bits, and contributing in many other ways. Tanya (our release manager) deserves a lot of credit for this being the smoothest and best release so far! Here is the previous status report, the LLVM 1.8 Release: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2006-August/000019.html If you have any questions or comments, please contact the LLVMdev mailing list (llvmdev at cs.uiuc.edu)! -Chris [Less]

LLVM 1.8 is available now! Download it here: http://llvm.org/releases/ Release notes here: http://llvm.org/releases/1.8/docs/ReleaseNotes.html This is a great new release with great new features and lots of refinements (better codegen, faster ... [More] compiles, bugs fixed). One particularly nice feature of this release is that we're back to a regular 3-month release cycle, allowing users to have fresh bits that are well tested. The LLVM community is vibrant and growing: many thanks to all who contributed to this release - in both large and small ways! Here are some of the major new features of LLVM 1.8: High Level Changes: 1. Jim has finished enough support for DWARF debugging information that it is now enabled by default in llvm-gcc4! Currently it is limited to only working with Mac OS (X86 and PowerPC), and only is generated at -O0. The debug info has good support for C with initial C support. We'd welcome help adding support for x86-linux and other targets. 2. Patrick Jenkins built a new centralized LLVM nightly tester (http://llvm.org/nightlytest/). This tester can generate reports and graph data across time, works with tester machines that live behind firewalls, automatically alerts the llvm-testresults list of significant performance regressions and improvements, and will eventually support generation of reports correlating changes in data across machines. 3. Rafael Avila de Espindola has started work on a new LLVM ARM backend. It is still in early stages of development, but is making strong progress. 4. The llvm-config tool is now built by default, is heavily tested (e.g. used by the llvm-gcc4 build), and includes several new enhancements (--libfiles and other new options, allows running from an objdir, allow relocating install dir, captures more info about the build, etc). 5. Reid contributed the llvm2cpp tool which converts LLVM modules into C code that (when executed) creates the module. 6. The "SparcV9" target has been removed, the "Sparc" target introduced in LLVM 1.7 has replaced it. Mid-Level Optimizer Improvements: 7. Owen contributed a new "Loop Closed SSA Pass" and updated various loop optimizers to use/preserve it. LCSSA makes it much easier for loop transformations to update SSA form after making changes to code. 8. As part of the LCSSA work, Owen changed loop-unswitch to be more aggressive: it is now able to unswitch loops with live-out values. 9. The Inliner pass now constant folds and DCE's on the fly, making it faster and making its cost model more accurate. 10. LLVM now includes a new byte-swap intrinsic, which the X86 and PPC code generator use these to emit bswap register/load/store instructions as appropriate. 11. Because llvm-gcc has no byte-swap builtin, the LLVM optimizer recognizes common bswap idioms and automatically changes them to use the intrinsic. 12. llvm-gcc now bootstraps correctly on darwin-x86/ppc, x86-linux and probably others), which exposed several cases where optimizers were nondeterministic. Target Independent Code Generator Improvements: 13. Nate contributed support for lowering switch instructions into jump tables, instead of always lowering them to conditional branch trees. 14. The ExecutionEngine::freeMachineCodeForFunction now actually frees machine code for functions from the JIT code cache, allowing the JIT to be used in long-running environments without running out of space. 15. The register spiller has been improved in several ways to make it produce better optimized spill code. The effect is particularly noticable on X86, but does apply to all targets. 16. The DAG Combiner now tracks sign information through arithmetic operations allowing more aggressive sign extension elimination. 17. The code generator now lowers formal arguments and function calls like any other unsupported operation, simplifying target lowering code. 18. LLVM now includes better support for targets whose ABI handles struct-return functions in unusual ways, e.g. implementing PR729. 19. Many people (particularly Nate, Evan, Owen and I): lots of cleanup and simplification throughout the code generator. 20. Several serious bugs (due to bitrot) in the 'local' (intra-basic-block) register allocator have been fixed, and it is now used by llvm-gcc4 at -O0. 21. Many bugs relating to inline asm support have been fixed, and llvm-gcc4 now supports global and local "asm register" variables. X86 Target Improvements: 22. Evan fixed several bugs in SSE code generation and implemented many performance tweaks. 23. Evan implemented the correct ABI for vector arg/retval passing in SSE registers. 24. Evan made significant improvements to the register-pressure-reducing scheduler, which is used primarily by the x86 target. 25. Jeff Cohen implemented support in the X86 backend for the Microsoft ML assembler ("masm"). 26. The X86 backend now supports most GCC inline asm, the most significant missing piece is support for multiple alternatives (PR839). PowerPC Target Improvements: 27. The PPC backend now includes initial support for 64-bit code generation on Darwin/PPC. There are still some minor known ABI bugs (particularly with struct-return functions) and the JIT only works in limited cases, but many applications work fine in 64-bit mode. 28. The PPC backend now passes vector arguments/retvals in registers according to the Darwin ABI. 29. Nate changed the PPC JIT to generate code using the static relocation model instead of "dynamic-no-pic", since the JIT knows exactly where all globals are located when it is generating code. 30. Nate implemented a new, more aggressive, PPC rlwimi pattern matcher, which allows LLVM to produce much better code for bitfield operations in some cases. Compiler Cleanups, Speedups, and Code Size Reductions: 31. The JIT code emitter (and thus the JIT) is much faster than before (http://llvm.org/PR469). 31. Jim, Evan, and I made several changes to reduce the size and number of relocations needed for code autogenerated by tblgen from the target .td files. 31. Evan made several tblgen changes that significantly reduces the stack usage of the generated instruction selector. This is important when compiling LLVM with gcc 4.x, until GCC PR25505 is fixed. 31. Many small cleanups and a couple of tricky bugs have been fixed due to input from a Coverity run. 32. Many people contributed various fixes to reduce code size for pieces of LLVM. 33. Anton Korobeynikov and Reid made many small changes to build LLVM with the '-pedantic' option. Most of LLVM is now '-pedantic'-clean. The Amazing Miscellaneous Stuff Department: 34. Anton contributed many fixes for mingw and cygwin. llvm-gcc4 now builds on mingw, and a binary version of the front-end available. It is still experimental, as it is missing stdcall and some other support. 35. Nick Lewycky contributed support for bugpoint to debug optimizers that get stuck in an infinite loop, by killing the optimizer after a certain amount of time passes. 36. Reid & Vladimir Prus made several improvements to documentation generated by doxygen, exposing comments previously only visible in the header files into the doxygen output. 37. --version now prints more detailed output, including the version number, build configuration, and vendor information. 38. Andrew added basic inline asm support to the Alpha backend. 39. Several new LLVM-related publications are available at http://llvm.org/pubs/ . 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.8 is the clearly our best release yet, and upgrading from a previous release is highly recommended. Thanks to Tanya for spearheading this release and to those who tested the results, contributed binaries of the front-ends, and those who filed bugs. Each contribution helps make LLVM that much better and that much easier for people to use. Finally, here is the previous status report, the LLVM 1.7 Release: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2006-April/000018.html If you have any questions or comments, please contact the LLVMdev mailing list (llvmdev at cs.uiuc.edu)! -Chris [Less]

LLVM 1.8 is available now! Download it here: http://llvm.org/releases/ Release notes here: http://llvm.org/releases/1.8/docs/ReleaseNotes.html This is a great new release with great new features and lots of refinements (better codegen, faster ... [More] compiles, bugs fixed). One particularly nice feature of this release is that we're back to a regular 3-month release cycle, allowing users to have fresh bits that are well tested. The LLVM community is vibrant and growing: many thanks to all who contributed to this release - in both large and small ways! Here are some of the major new features of LLVM 1.8: High Level Changes: 1. Jim has finished enough support for DWARF debugging information that it is now enabled by default in llvm-gcc4! Currently it is limited to only working with Mac OS (X86 and PowerPC), and only is generated at -O0. The debug info has good support for C with initial C++ support. We'd welcome help adding support for x86-linux and other targets. 2. Patrick Jenkins built a new centralized LLVM nightly tester (http://llvm.org/nightlytest/). This tester can generate reports and graph data across time, works with tester machines that live behind firewalls, automatically alerts the llvm-testresults list of significant performance regressions and improvements, and will eventually support generation of reports correlating changes in data across machines. 3. Rafael Avila de Espindola has started work on a new LLVM ARM backend. It is still in early stages of development, but is making strong progress. 4. The llvm-config tool is now built by default, is heavily tested (e.g. used by the llvm-gcc4 build), and includes several new enhancements (--libfiles and other new options, allows running from an objdir, allow relocating install dir, captures more info about the build, etc). 5. Reid contributed the llvm2cpp tool which converts LLVM modules into C++ code that (when executed) creates the module. 6. The "SparcV9" target has been removed, the "Sparc" target introduced in LLVM 1.7 has replaced it. Mid-Level Optimizer Improvements: 7. Owen contributed a new "Loop Closed SSA Pass" and updated various loop optimizers to use/preserve it. LCSSA makes it much easier for loop transformations to update SSA form after making changes to code. 8. As part of the LCSSA work, Owen changed loop-unswitch to be more aggressive: it is now able to unswitch loops with live-out values. 9. The Inliner pass now constant folds and DCE's on the fly, making it faster and making its cost model more accurate. 10. LLVM now includes a new byte-swap intrinsic, which the X86 and PPC code generator use these to emit bswap register/load/store instructions as appropriate. 11. Because llvm-gcc has no byte-swap builtin, the LLVM optimizer recognizes common bswap idioms and automatically changes them to use the intrinsic. 12. llvm-gcc now bootstraps correctly on darwin-x86/ppc, x86-linux and probably others), which exposed several cases where optimizers were nondeterministic. Target Independent Code Generator Improvements: 13. Nate contributed support for lowering switch instructions into jump tables, instead of always lowering them to conditional branch trees. 14. The ExecutionEngine::freeMachineCodeForFunction now actually frees machine code for functions from the JIT code cache, allowing the JIT to be used in long-running environments without running out of space. 15. The register spiller has been improved in several ways to make it produce better optimized spill code. The effect is particularly noticable on X86, but does apply to all targets. 16. The DAG Combiner now tracks sign information through arithmetic operations allowing more aggressive sign extension elimination. 17. The code generator now lowers formal arguments and function calls like any other unsupported operation, simplifying target lowering code. 18. LLVM now includes better support for targets whose ABI handles struct-return functions in unusual ways, e.g. implementing PR729. 19. Many people (particularly Nate, Evan, Owen and I): lots of cleanup and simplification throughout the code generator. 20. Several serious bugs (due to bitrot) in the 'local' (intra-basic-block) register allocator have been fixed, and it is now used by llvm-gcc4 at -O0. 21. Many bugs relating to inline asm support have been fixed, and llvm-gcc4 now supports global and local "asm register" variables. X86 Target Improvements: 22. Evan fixed several bugs in SSE code generation and implemented many performance tweaks. 23. Evan implemented the correct ABI for vector arg/retval passing in SSE registers. 24. Evan made significant improvements to the register-pressure-reducing scheduler, which is used primarily by the x86 target. 25. Jeff Cohen implemented support in the X86 backend for the Microsoft ML assembler ("masm"). 26. The X86 backend now supports most GCC inline asm, the most significant missing piece is support for multiple alternatives (PR839). PowerPC Target Improvements: 27. The PPC backend now includes initial support for 64-bit code generation on Darwin/PPC. There are still some minor known ABI bugs (particularly with struct-return functions) and the JIT only works in limited cases, but many applications work fine in 64-bit mode. 28. The PPC backend now passes vector arguments/retvals in registers according to the Darwin ABI. 29. Nate changed the PPC JIT to generate code using the static relocation model instead of "dynamic-no-pic", since the JIT knows exactly where all globals are located when it is generating code. 30. Nate implemented a new, more aggressive, PPC rlwimi pattern matcher, which allows LLVM to produce much better code for bitfield operations in some cases. Compiler Cleanups, Speedups, and Code Size Reductions: 31. The JIT code emitter (and thus the JIT) is much faster than before (http://llvm.org/PR469). 31. Jim, Evan, and I made several changes to reduce the size and number of relocations needed for code autogenerated by tblgen from the target .td files. 31. Evan made several tblgen changes that significantly reduces the stack usage of the generated instruction selector. This is important when compiling LLVM with gcc 4.x, until GCC PR25505 is fixed. 31. Many small cleanups and a couple of tricky bugs have been fixed due to input from a Coverity run. 32. Many people contributed various fixes to reduce code size for pieces of LLVM. 33. Anton Korobeynikov and Reid made many small changes to build LLVM with the '-pedantic' option. Most of LLVM is now '-pedantic'-clean. The Amazing Miscellaneous Stuff Department: 34. Anton contributed many fixes for mingw and cygwin. llvm-gcc4 now builds on mingw, and a binary version of the front-end available. It is still experimental, as it is missing stdcall and some other support. 35. Nick Lewycky contributed support for bugpoint to debug optimizers that get stuck in an infinite loop, by killing the optimizer after a certain amount of time passes. 36. Reid & Vladimir Prus made several improvements to documentation generated by doxygen, exposing comments previously only visible in the header files into the doxygen output. 37. --version now prints more detailed output, including the version number, build configuration, and vendor information. 38. Andrew added basic inline asm support to the Alpha backend. 39. Several new LLVM-related publications are available at http://llvm.org/pubs/ . 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.8 is the clearly our best release yet, and upgrading from a previous release is highly recommended. Thanks to Tanya for spearheading this release and to those who tested the results, contributed binaries of the front-ends, and those who filed bugs. Each contribution helps make LLVM that much better and that much easier for people to use. Finally, here is the previous status report, the LLVM 1.7 Release: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2006-April/000018.html If you have any questions or comments, please contact the LLVMdev mailing list (llvmdev at cs.uiuc.edu)! -Chris [Less]

LLVM 1.7 is available now! Download it here: http://llvm.org/releases/ Release notes here: http://llvm.org/releases/1.7/docs/ReleaseNotes.html This release is huge! It contains about twice the number of new features as any previous release, and ... [More] 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. http://llvm.org/docs/LangRef.html#vectorops 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 form. 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 http://llvm.org/docs/SourceLevelDebugging.html 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 detectors. 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 http://incubator.apache.org/stdcxx/ ). 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: http://lists.cs.uiuc.edu/pipermail/llvmdev/2006-February/005228.html 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 http://llvm.org/PR498 . 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: http://llvm.org/docs/CommandGuide/html/llvm-config.html 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 storage. 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 library. 75. Reid removed use of fork() from bugpoint, allowing it to work on Win32 systems. 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. :) 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: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2005-November/000017.html -Chris [Less]

LLVM 1.7 is available now! Download it here: http://llvm.org/releases/ Release notes here: http://llvm.org/releases/1.7/docs/ReleaseNotes.html This release is huge! It contains about twice the number of new features as any previous release, and ... [More] 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. http://llvm.org/docs/LangRef.html#vectorops 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 form. 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 http://llvm.org/docs/SourceLevelDebugging.html 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 detectors. 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 http://incubator.apache.org/stdcxx/ ). 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: http://lists.cs.uiuc.edu/pipermail/llvmdev/2006-February/005228.html 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 http://llvm.org/PR498 . 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: http://llvm.org/docs/CommandGuide/html/llvm-config.html 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 storage. 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 library. 75. Reid removed use of fork() from bugpoint, allowing it to work on Win32 systems. 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. :) 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: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2005-November/000017.html -Chris [Less]

Hi Everyone, LLVM 1.6 is out! Get it here: http://llvm.org/releases/ or read about it here: http://llvm.org/releases/1.6/docs/ReleaseNotes.html#whatsnew This release is the culmination of a ton of great work by many people in the LLVM community. ... [More] This release cycle has been much longer than any previous release cycle, and reflects that in its content. However, because we think that 3-4 months between releases is ideal, we are aiming for more frequent releases in the future. The main focus of this release has been improving the code generator: we now generate better code, it is now easier to write an LLVM target, and several of the individual targets are more sophisticated. Another major feature of this release is increased maturity of the PowerPC backend and darwin port. Finally, an exciting aspect of the project is that more and more people are using LLVM for a variety of purposes. One of the most visible uses is for academic research projects: groups from across the globe are using LLVM to host their work: http://llvm.org/pubs/ . With 1.6 behind us, work is now starting on LLVM 1.7: we already have several great new features in the works. Stay tuned! Here is more detail on the highlights of the LLVM 1.6 release: Major New Features: 1. Reid added guards to the JIT, enabling it to JIT multithreaded code (on systems with pthreads). Threads support can be disabled by configuring LLVM with the --disable-threads switch. 2. LLVM includes a new optimization to statically evaluate C++ static variable constructors when they are simple enough. For example, it can now statically initialize "struct X { int a; X() : a(4) {} } g;". 3. The Loop Strength Reduction pass is completely rewritten, far more aggressive and enabled by default on most RISC targets. On PPC, we find that it often speeds up programs from 10-40% depending on the program. 4. LLVM now includes support for auto-generating large portions of the instruction selectors from target descriptions. This allows us to write patterns in the target .td file, instead of writing lots of nasty C++ code. Most of the PowerPC instruction selector is now generated from the PowerPC target description files and other targets are adding support that will be live for LLVM 1.7. 5. Andrew has dramatically improved the LLVM Alpha backend to the point where it is now considered fully functional and off the 'beta' list. Major Code Generator Changes: 6. Nate wrote a new component for the backend, a DAG Combiner. This allows the backend to take advantage of identities and do low-level peephole-style optimizations on the DAG. 7. Nate added support for a new TargetSubtarget interface, which determines which parts of the target to enable based on the target-triple (e.g., whether to use GAS or Intel asm printers on X86). 8. Jim Laskey extended sub-target support to include -mcpu and -mattr, allowing the target to think about what to do when particular features are enabled, but allowing the end-user to think about what CPU they have. 9. Jim also contributed a new light-weight instruction scheduler, available to targets that use DAG-to-DAG instruction selectors. In this release, the scheduler is fully operational but needs tuning, so it is not enabled by default. 10. The instruction selector framework now supports DAG-to-DAG instruction selection, where the instruction selector does pattern matching but no code emission (necessary for scheduling & .td file autogeneration). Other Code Generator Changes: 11. Duraid contributed many small improvements to the Itanium backend, and is actively moving it to the new isel framework. 12. Andrew Lenharth contributed a major change to the varargs support, allowing LLVM to work with targets whose va_list type is a struct. 13. The instruction selection framework that debuted in LLVM 1.5 is far more mature/robust and knows about many more strange target features. 14. Andrew added initial JIT support to the Alpha backend, which can run some simple programs. It is not fully complete yet, though. 15. Jim Laskey contributed patches to improve the instruction selection in the PowerPC backend, matching more RLWIMI cases, for example. 16. Nate implemented most of the PowerPC DAG-to-DAG instruction selector. 17. The tblgen tool & code generator now have more assertions and checking, which catch errors early, making it easier to work on the backend. 18. The default register allocator is now far faster on some testcases, particularly on targets with a large number of registers (e.g. IA64 and PPC). 19. Jim extended tblgen to allow description of subtarget features in the .td files for the target. 20. There have been several minor improvements to the register allocator to coalesce more aggressively and coalesce spill code with copies more effectively. Miscellaneous Improvements: 21. Andrew added support to the JIT to built a Global Offset Table if needed by a target. 22. Alexander Friedman improved the .ll file parser to be able to read from a text buffer in addition to a file. 23. Bryan Turner tried LLVM with Quest, a random testcase generator, and exposed several bugs (which are now fixed). 24. The llvm-test suite can now use the NAG Fortran to C compiler to compile SPEC FP programs, if available (allowing us to test all of SPEC'95 & 2K). 25. The JIT-debugger mode of bugpoint is now much faster than before. 26. When bugpoint is grinding away and the user hits ctrl-C, it now gracefully stops and gives what it has reduced so far (instead of giving up completely). 27. LLVM now includes Xcode project files. 28. Jim Laskey added bitvector support to the command line option parsing library. See http://llvm.org/docs/CommandLine.html#bits 29. We no longer build two versions of most LLVM libraries, which reduces the time required to build LLVM. 30. Documentation for the code generator is improving, though it is still incomplete: http://llvm.org/docs/CodeGenerator.html 31. The code produced when exception handling is enabled is far more efficient in some cases, particularly on Mac OS/X. 32. LLVM should build faster than before: it only links each library in one configuration (instead of two), and some old code has been removed. Portability Improvements: 33. Nate added support for Mac OS/X on Intel. 34. X86 tail calls now work with the JIT and Jeff Cohen added code to support them under Visual C++. 35. Nate contributed a patch to allow LLVM to build with GCC 4.x, and Reid contributed several cleanup patches to silence GCC 4 warnings. 36. The llvm-test suite is now fully compatible with Mac OS/X (non-portabilities in the programs have been fixed). 37. Jeff Cohen contributed portability fixes to build on AMD64. 38. Jeff and Reid improved the Visual C++ build to not require any GNU utilities like flex, bison, or sed. In addition to the new features and infrastructure we have built, we have also fixed many minor bugs in the C/C++ front-end, optimizers, and code generator including 63 bugzilla bugs (search for target milestone = 1.6). LLVM 1.6 is by far the best release we've had yet! Also, special thanks to John, Bill and Tanya for organizing the 1.6 release process and testing the prerelease tarballs! 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.5 announcement: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2005-May/000016.html -Chris [Less]

Hi Everyone, LLVM 1.6 is out! Get it here: http://llvm.org/releases/ or read about it here: http://llvm.org/releases/1.6/docs/ReleaseNotes.html#whatsnew This release is the culmination of a ton of great work by many people in the LLVM community. ... [More] This release cycle has been much longer than any previous release cycle, and reflects that in its content. However, because we think that 3-4 months between releases is ideal, we are aiming for more frequent releases in the future. The main focus of this release has been improving the code generator: we now generate better code, it is now easier to write an LLVM target, and several of the individual targets are more sophisticated. Another major feature of this release is increased maturity of the PowerPC backend and darwin port. Finally, an exciting aspect of the project is that more and more people are using LLVM for a variety of purposes. One of the most visible uses is for academic research projects: groups from across the globe are using LLVM to host their work: http://llvm.org/pubs/ . With 1.6 behind us, work is now starting on LLVM 1.7: we already have several great new features in the works. Stay tuned! Here is more detail on the highlights of the LLVM 1.6 release: Major New Features: 1. Reid added guards to the JIT, enabling it to JIT multithreaded code (on systems with pthreads). Threads support can be disabled by configuring LLVM with the --disable-threads switch. 2. LLVM includes a new optimization to statically evaluate C static variable constructors when they are simple enough. For example, it can now statically initialize "struct X { int a; X() : a(4) {} } g;". 3. The Loop Strength Reduction pass is completely rewritten, far more aggressive and enabled by default on most RISC targets. On PPC, we find that it often speeds up programs from 10-40% depending on the program. 4. LLVM now includes support for auto-generating large portions of the instruction selectors from target descriptions. This allows us to write patterns in the target .td file, instead of writing lots of nasty C code. Most of the PowerPC instruction selector is now generated from the PowerPC target description files and other targets are adding support that will be live for LLVM 1.7. 5. Andrew has dramatically improved the LLVM Alpha backend to the point where it is now considered fully functional and off the 'beta' list. Major Code Generator Changes: 6. Nate wrote a new component for the backend, a DAG Combiner. This allows the backend to take advantage of identities and do low-level peephole-style optimizations on the DAG. 7. Nate added support for a new TargetSubtarget interface, which determines which parts of the target to enable based on the target-triple (e.g., whether to use GAS or Intel asm printers on X86). 8. Jim Laskey extended sub-target support to include -mcpu and -mattr, allowing the target to think about what to do when particular features are enabled, but allowing the end-user to think about what CPU they have. 9. Jim also contributed a new light-weight instruction scheduler, available to targets that use DAG-to-DAG instruction selectors. In this release, the scheduler is fully operational but needs tuning, so it is not enabled by default. 10. The instruction selector framework now supports DAG-to-DAG instruction selection, where the instruction selector does pattern matching but no code emission (necessary for scheduling & .td file autogeneration). Other Code Generator Changes: 11. Duraid contributed many small improvements to the Itanium backend, and is actively moving it to the new isel framework. 12. Andrew Lenharth contributed a major change to the varargs support, allowing LLVM to work with targets whose va_list type is a struct. 13. The instruction selection framework that debuted in LLVM 1.5 is far more mature/robust and knows about many more strange target features. 14. Andrew added initial JIT support to the Alpha backend, which can run some simple programs. It is not fully complete yet, though. 15. Jim Laskey contributed patches to improve the instruction selection in the PowerPC backend, matching more RLWIMI cases, for example. 16. Nate implemented most of the PowerPC DAG-to-DAG instruction selector. 17. The tblgen tool & code generator now have more assertions and checking, which catch errors early, making it easier to work on the backend. 18. The default register allocator is now far faster on some testcases, particularly on targets with a large number of registers (e.g. IA64 and PPC). 19. Jim extended tblgen to allow description of subtarget features in the .td files for the target. 20. There have been several minor improvements to the register allocator to coalesce more aggressively and coalesce spill code with copies more effectively. Miscellaneous Improvements: 21. Andrew added support to the JIT to built a Global Offset Table if needed by a target. 22. Alexander Friedman improved the .ll file parser to be able to read from a text buffer in addition to a file. 23. Bryan Turner tried LLVM with Quest, a random testcase generator, and exposed several bugs (which are now fixed). 24. The llvm-test suite can now use the NAG Fortran to C compiler to compile SPEC FP programs, if available (allowing us to test all of SPEC'95 & 2K). 25. The JIT-debugger mode of bugpoint is now much faster than before. 26. When bugpoint is grinding away and the user hits ctrl-C, it now gracefully stops and gives what it has reduced so far (instead of giving up completely). 27. LLVM now includes Xcode project files. 28. Jim Laskey added bitvector support to the command line option parsing library. See http://llvm.org/docs/CommandLine.html#bits 29. We no longer build two versions of most LLVM libraries, which reduces the time required to build LLVM. 30. Documentation for the code generator is improving, though it is still incomplete: http://llvm.org/docs/CodeGenerator.html 31. The code produced when exception handling is enabled is far more efficient in some cases, particularly on Mac OS/X. 32. LLVM should build faster than before: it only links each library in one configuration (instead of two), and some old code has been removed. Portability Improvements: 33. Nate added support for Mac OS/X on Intel. 34. X86 tail calls now work with the JIT and Jeff Cohen added code to support them under Visual C . 35. Nate contributed a patch to allow LLVM to build with GCC 4.x, and Reid contributed several cleanup patches to silence GCC 4 warnings. 36. The llvm-test suite is now fully compatible with Mac OS/X (non-portabilities in the programs have been fixed). 37. Jeff Cohen contributed portability fixes to build on AMD64. 38. Jeff and Reid improved the Visual C build to not require any GNU utilities like flex, bison, or sed. In addition to the new features and infrastructure we have built, we have also fixed many minor bugs in the C/C front-end, optimizers, and code generator including 63 bugzilla bugs (search for target milestone = 1.6). LLVM 1.6 is by far the best release we've had yet! Also, special thanks to John, Bill and Tanya for organizing the 1.6 release process and testing the prerelease tarballs! 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.5 announcement: http://lists.cs.uiuc.edu/pipermail/llvm-announce/2005-May/000016.html -Chris [Less]

The LLVM 1.5 is out! Get it here: http://llvm.cs.uiuc.edu/releases/ or read about it here: http://llvm.cs.uiuc.edu/releases/1.5/docs/ReleaseNotes.html#whatsnew This release adds several new major features to the LLVM compiler, allows it to be ... [More] used in domains where it couldn't before (e.g. for functional languages), supports new targets, generates faster code, and is much easier to port to a new target than before. Here are some of the biggest changes since the last status update (which also includes new features from 1.4). You can read the previous status update here: http://mail.cs.uiuc.edu/pipermail/llvm-announce/2005-February/000015.html High-Level Changes: 1. Duraid contributed a shiny new IA-64 backend (still beta). 2. Andrew has fixed many bugs in the Alpha backend, it it is making a lot of progress. 3. The new instruction selection framework is complete and in heavy use. Many extensions are still possible, but the basic functionality works well. 4. LLVM now supports per-function calling conventions, allowing us to support targets with multiple cc's (e.g. fastcall/stdcall on X86), and convention changing compiler flags (e.g. GCC's -mregparm). 5. LLVM now supports proper tail calls, as required to implement functional languages (such as Scheme and Haskell) efficiently. For more information, see: http://llvm.cs.uiuc.edu/releases/1.5/docs/ReleaseNotes.html#tailcalls 6. Misha updated the llvm-tv (LLVM Transformation Visualizer) project to work with LLVM CVS. 7. The LLVM_LIB_SEARCH_PATH environment still works, but should not be needed for most people now. llvm-gcc now always includes the libraries in /lib. Optimization Changes: 8. Reid has started a new -simplify-libcalls pass to optimize standard library function calls (e.g. it turns strcat(P, "foo") into memcpy(P+strlen(P), "foo", 4) and has implemented many transforms. 9. The globalsmodref alias analysis generates more precise results. 10. Several bugs in the andersensaa and steensaa passes were fixed, and their alias and mod/ref precision has improved. 11. The optimizer now eliminates simple cases where redundant conditions exist between neighboring blocks. 12. The -prune-eh pass now detects no-return functions in addition to the no-unwind functions it did before. Code Generator Changes: 13. 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. 14. Nate implemented the integer division by a constant strength reduction algorithm that uses multiplication by a magic constant. 15. Duraid implemented the multiplication by a constant strength reduction algorithm that emits sequences of shift/adds. 16. tblgen now allows lazy resolution of variables, making it easier to write more expressive and compact .td files in some cases. 17. The code generator now compiles fabs/fneg to assembly instructions when possible. 18. Morton Ofstad contributed generic codegen support and X86 backend support for sin/cos/sqrt. 19. Andrew contributed initial patches to track the LLVM pointer that SelectionDAG nodes point to, allowing the code generator to use LLVM alias analysis info (it does not currently use it though). Target Changes: 20. Nate wrote a new PowerPC instruction selector using the new SelectionDAG framework. 21. Nate added several optimizations to the PPC backend, including support for generating FMA instructions and using recording ("dot") forms of various PPC instructions. 22. The X86 backend uses a new SelectionDAG-based instruction selector. 23. The X86 codegen attempts to order code to reduce register pressure. However, the current implementation still has several deficiencies. 24. The C backend should no longer produce code that crashes ICC 8.1. Other Changes: 25. Reid and Andrew enhanced the LLVM configure script to support an --enable-targets= flag which permits building a subset of the targets (instead of all of them all the time). 26. Jeff continued working on the Visual C++ build scripts and portability to native Win32. Most LLVM tools work natively in win32 now, but there is no native C/C++ front-end support yet (must use cygwin). 27. Adam Treat contributed patches to the LLVM linker to handle programs containing combinations of native and bytecode libraries much better. 28. Adam Treat contributed patches to the LLVM linker, allowing it to build shared libraries with 'llvm-gcc -shared' and -Wl,-native or -Wl,-native-cbe. 29. The llvm-test suite works much better on FreeBSD and Darwin. 30. Nightly tester output is now archived on the llvm-testresults mailing list: http://mail.cs.uiuc.edu/pipermail/llvm-testresults/ 31. Evan Jones contributed patches to improve our doxygen output. 32. Misha renamed the llvm 'extract' tool to 'llvm-extract' (makes sense!) 33. Justin Wick contributed support for a new llvm.prefetch intrinsic. llvm-gcc now compiles __builtin_prefetch to it. 34. Andrew added llvm.ctpop,llvm.cttz and llvm.ctlz intrinsics. llvm-gcc now codegens __builtin_popcount, etc to these intrinsics. 35. Duraid contributed patches to build LLVM on HP-UX with the GNU toolchain. He also got it working with aCC, but it requires several work-arounds for the (rather old) STL it provides. Notable Bugs Fixed: PR496: Cannot build llvm without llvm-gcc PR510: [llvmgcc] Field offset miscalculated for some structure fields following bit fields PR513: [llvm-g++] Temporary lifetimes incorrect for short circuit logical operations PR517: [llvm-gcc] Crash compiling bitfield <-> aggregate assignment PR520: [llvm-g++] Error compiling virtual function thunk with an unnamed argument PR522: [llvm-gcc] Crash on certain C99 complex number routines PR529: [llvm-g++] Crash using placement new on an array type PR562: [llvm-gcc] crash on global variable nested union with initializer Finally, here's the previous status update: http://mail.cs.uiuc.edu/pipermail/llvm-announce/2005-February/000015.html 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)! On a more personal note, I recently finished up my Ph.D. In June, I'll be joining Apple Computer's Compiler and Tools group, where I will continue open-source LLVM development. Stay tuned for good things to come! Oh yeah, if you are interested in some of the nifty things that can be done with LLVM, take a look at my thesis: :) http://llvm.cs.uiuc.edu/pubs/2005-05-04-LattnerPHDThesis.html -Chris [Less]