The LLVM Project is a collection of modular and reusable compiler and
toolchain technologies. Despite its name, LLVM has little to do with
traditional virtual machines, though it does provide helpful libraries that
can be used to build them.
From its humble beginnings as a research project at
the University of Illinois, LLVM has
grown to be an umbrella project consisting of a number of different
subprojects, many of which are being used in production by a wide variety of
commercial and open source projects
as well as being widely used in academic research. Code
in the LLVM project is licensed under the "UIUC" BSD-Style license.
The primary sub-projects of LLVM are:
The LLVM Core libraries provide a modern source- and
target-independent optimizer, along with
code generation support for many
popular CPUs (as well as some less common ones!) These libraries are built
around a well specified code representation
known as the LLVM intermediate representation ("LLVM IR"). The LLVM Core
libraries are well documented, and it is particularly
easy to invent your own language (or port an existing compiler) to use
LLVM as a optimizer and code generator.
Clang is an "LLVM native"
C/C++/Objective-C compiler, which aims to deliver amazingly fast compiles
(e.g. about 3x faster than GCC when
compiling Objective-C code in a debug configuration), extremely useful error and warning messages
and to provide a platform for building great source level tools. The
Clang Static Analyzer is a
tool automatically finds bugs in your code, and is a great example of the
sort of tool that can be built using the Clang frontend as a library to
parse C/C++ code.
llvm-gcc 4.2 and
dragonegg integrate the LLVM
optimizers and code generator with the GCC 4.2 (which is GPL2) and GCC 4.5
(which is GPL3) parsers, respectively. This allows LLVM to compile Ada,
Fortran, and other languages supported by the GCC compiler frontends, and
provides high-fidelity drop-in compatibility with their
respective versions of GCC.
The LLDB project builds on
libraries provided by LLVM and Clang to provide a great native debugger.
It uses the Clang ASTs and expression parser, LLVM JIT, LLVM disassembler,
etc so that it provides an experience that "just works". It is also
blazing fast and much more memory efficient than GDB at loading symbols.
The libc++ project provides
a standard conformant and high-performance implementation of the C++
Standard Library, with an aim of supporting C++'0x when the standard is
ratified.
The compiler-rt project
provides highly tuned implementations of the low-level code generator
support routines like "__fixunsdfdi" and other calls generated when
a target doesn't have a short sequence of native instructions to implement
a core IR operation.
The vmkit project is an
implementation of the Java and .NET Virtual Machines that is built on LLVM
technologies.
The klee project implements a
"symbolic virtual machine" which uses a theorem prover to try to evaluate
all dynamic paths through a program, in an effort to find bugs and to prove
properties of functions. A major feature of klee is that it can produce a
testcase in the event that it detects a bug.
In addition to official subprojects of LLVM, there are a broad variety of
other projects that use components
of LLVM for various tasks. Through these external projects you can use
LLVM to compile Ruby, Python, Haskell, Java, D, PHP, Pure, Lua, and a number of
other languages. A major strength of LLVM is its versatility, flexibility, and
reusability, which is why it is being used for such a wide variety of different
tasks: everything from doing light-weight JIT compiles of embedded languages
like Lua to compiling Fortran code for massive super computers.
As much as everything else, LLVM has a broad and friendly community of people
who are interested in building great low-level tools. If you are interested in
getting involved, a good first place is to skim the LLVM Blog and to sign up for the LLVM Developer mailing
list.