LLVM 2.6 Release Notes
  1. Introduction
  2. Sub-project Status Update
  3. External Projects Using LLVM 2.6
  4. What's New in LLVM 2.6?
  5. Installation Instructions
  6. Portability and Supported Platforms
  7. Known Problems
  8. Additional Information

Written by the LLVM Team

Introduction

This document contains the release notes for the LLVM Compiler Infrastructure, release 2.6. Here we describe the status of LLVM, including major improvements from the previous release and significant known problems. All LLVM releases may be downloaded from the LLVM releases web site.

For more information about LLVM, including information about the latest 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.

Note that if you are reading this file from a Subversion checkout or the main LLVM web page, this document applies to the next release, not the current one. To see the release notes for a specific release, please see the releases page.

Sub-project Status Update

The LLVM 2.6 distribution currently consists of code from the core LLVM repository —which roughly includes the LLVM optimizers, code generators and supporting tools — and the llvm-gcc repository. In addition to this code, the LLVM Project includes other sub-projects that are in development. The two which are the most actively developed are the Clang Project and the VMKit Project.

Clang: C/C++/Objective-C Frontend Toolkit

The Clang project is an effort to build a set of new 'LLVM native' front-end technologies for the LLVM optimizer and code generator. While Clang is not included in the LLVM 2.6 release, it is continuing to make major strides forward in all areas. Its C and Objective-C parsing and code generation support is now very solid. For example, it is capable of successfully building many real-world applications for X86-32 and X86-64, including the FreeBSD kernel and gcc 4.2. C++ is also making incredible progress, and work on templates has recently started. If you are interested in fast compiles and good diagnostics, we encourage you to try it out by building from mainline and reporting any issues you hit to the Clang front-end mailing list.

In the LLVM 2.6 time-frame, the Clang team has made many improvements:

Clang Static Analyzer

Previously announced in the 2.4 LLVM release, the Clang project also includes an early stage static source code analysis tool for automatically finding bugs in C and Objective-C programs. The tool performs a growing set of checks to find bugs that occur on a specific path within a program.

In the LLVM 2.6 time-frame there have been many significant improvements to XYZ.

The set of checks performed by the static analyzer continues to expand, and future plans for the tool include full source-level inter-procedural analysis and deeper checks such as buffer overrun detection. There are many opportunities to extend and enhance the static analyzer, and anyone interested in working on this project is encouraged to get involved!

VMKit: JVM/CLI Virtual Machine Implementation

The VMKit project is an implementation of a JVM and a CLI Virtual Machines (Microsoft .NET is an implementation of the CLI) using the Just-In-Time compiler of LLVM.

Following LLVM 2.6, VMKit has its XYZ release that you can find on its webpage. The release includes bug fixes, cleanup and new features. The major changes are:

External Projects Using LLVM 2.6
Pure

Pure is an algebraic/functional programming language based on term rewriting. Programs are collections of equations which are used to evaluate expressions in a symbolic fashion. Pure offers dynamic typing, eager and lazy evaluation, lexical closures, a hygienic macro system (also based on term rewriting), built-in list and matrix support (including list and matrix comprehensions) and an easy-to-use C interface. The interpreter uses LLVM as a backend to JIT-compile Pure programs to fast native code.

In addition to the usual algebraic data structures, Pure also has MATLAB-style matrices in order to support numeric computations and signal processing in an efficient way. Pure is mainly aimed at mathematical applications right now, but it has been designed as a general purpose language. The dynamic interpreter environment and the C interface make it possible to use it as a kind of functional scripting language for many application areas.

LLVM D Compiler

LDC is an implementation of the D Programming Language using the LLVM optimizer and code generator. The LDC project works great with the LLVM 2.6 release. General improvements in this cycle have included new inline asm constraint handling, better debug info support, general bugfixes, and better x86-64 support. This has allowed some major improvements in LDC, getting us much closer to being as fully featured as the original DMD compiler from DigitalMars.

Roadsend PHP

Roadsend PHP (rphp) is an open source implementation of the PHP programming language that uses LLVM for its optimizer, JIT, and static compiler. This is a reimplementation of an earlier project that is now based on LLVM.

Unladen Swallow

Unladen Swallow is a branch of Python intended to be fully compatible and significantly faster. It uses LLVM's optimization passes and JIT compiler.

Rubinius

Rubinius is a new virtual machine for Ruby. It leverages LLVM to dynamically compile Ruby code down to machine code using LLVM's JIT.

What's New in LLVM 2.6?

This release includes a huge number of bug fixes, performance tweaks, and minor improvements. Some of the major improvements and new features are listed in this section.

Major New Features

LLVM 2.6 includes several major new capabilities:

llvm-gcc 4.2 Improvements

LLVM fully supports the llvm-gcc 4.2 front-end, which marries the GCC front-ends and driver with the LLVM optimizer and code generator. It currently includes support for the C, C++, Objective-C, Ada, and Fortran front-ends.

LLVM IR and Core Improvements

LLVM IR has several new features that are used by our existing front-ends and can be useful if you are writing a front-end for LLVM:

Optimizer Improvements

In addition to a large array of bug fixes and minor performance tweaks, this release includes a few major enhancements and additions to the optimizers:

Target Independent Code Generator Improvements

We have put a significant amount of work into the code generator infrastructure, which allows us to implement more aggressive algorithms and make it run faster:

X86-32 and X86-64 Target Improvements

New features of the X86 target include:

PIC16 Target Improvements

New features of the PIC16 target include:

Things not yet supported:

Improvements in LLVMC

New features include:

Major Changes and Removed Features

If you're already an LLVM user or developer with out-of-tree changes based on LLVM 2.5, this section lists some "gotchas" that you may run into upgrading from the previous release.

In addition, many APIs have changed in this release. Some of the major LLVM API changes are:

Portability and Supported Platforms

LLVM is known to work on the following platforms:

The core LLVM infrastructure uses GNU autoconf to adapt itself to the machine and operating system on which it is built. However, minor porting may be required to get LLVM to work on new platforms. We welcome your portability patches and reports of successful builds or error messages.

Known Problems

This section contains significant known problems with the LLVM system, listed by component. If you run into a problem, please check the LLVM bug database and submit a bug if there isn't already one.

Experimental features included with this release

The following components of this LLVM release are either untested, known to be broken or unreliable, or are in early development. These components should not be relied on, and bugs should not be filed against them, but they may be useful to some people. In particular, if you would like to work on one of these components, please contact us on the LLVMdev list.

Known problems with the X86 back-end
Known problems with the PowerPC back-end
Known problems with the ARM back-end
Known problems with the SPARC back-end
Known problems with the MIPS back-end
Known problems with the Alpha back-end
Known problems with the IA64 back-end
Known problems with the C back-end
Known problems with the llvm-gcc C front-end

llvm-gcc does not currently support Link-Time Optimization on most platforms "out-of-the-box". Please inquire on the LLVMdev mailing list if you are interested.

The only major language feature of GCC not supported by llvm-gcc is the __builtin_apply family of builtins. However, some extensions are only supported on some targets. For example, trampolines are only supported on some targets (these are used when you take the address of a nested function).

If you run into GCC extensions which are not supported, please let us know.

Known problems with the llvm-gcc C++ front-end

The C++ front-end is considered to be fully tested and works for a number of non-trivial programs, including LLVM itself, Qt, Mozilla, etc.

Known problems with the llvm-gcc Fortran front-end
Known problems with the llvm-gcc Ada front-end
The llvm-gcc 4.2 Ada compiler works fairly well; however, this is not a mature technology, and problems should be expected.
Additional Information

A wide variety of additional information is available on the LLVM web page, in particular in the documentation section. The web page also contains versions of the API documentation which is up-to-date with the Subversion 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 lists.


Valid CSS Valid HTML 4.01 LLVM Compiler Infrastructure
Last modified: $Date$