+
LLVM (Low-Level Virtual Machine) provides enough
+infrastructure to use it as the backend for your compiled, or
+JIT-compiled language. It provides extensive optimization support, and
+static and dynamic (JIT) backends for many platforms. See the website at
+http://www.llvm.org/ to discover more.
+
Python bindings for LLVM provides a gentler learning curve for working
+with the LLVM APIs. It should also prove easier to create working
+prototypes and experimental languages using this medium.
+
License
+
Both LLVM and llvm-py are distributed under (different) permissive
+open source licenses. llvm-py uses the
+new BSD license. More
+information is available here.
+
Platforms
+
Currently, llvm-py has been built and tested only on Linux/x86. However,
+it should be trivial to build it on other unices. Windows is not
+supported, for a variety of reasons.
+
Versions
+
As of now, llvm-py requires the latest SVN version of LLVM. It will
+not work with version 2.2 of LLVM. However, 2.3 should be release soon,
+and llvm-py should work with stock 2.3 LLVM.
+
llvm-py has been built and tested with Python 2.5. It should work with
+Python 2.4, with minimal changes, if any.
+
+
llvm-py is distributed as a source tarball. You'll need to build and
+install it before it can be used. At least the following will be
+required for this:
+
+-
+
+compilers, both gcc and g++
+
+
+-
+
+Python itself
+
+
+-
+
+Python development files (headers and libraries)
+
+
+-
+
+LLVM, either installed or built
+
+
+
+
On debian-based systems, the first three can be installed with the
+command `sudo apt-get install gcc g++ python python-dev'. Note that
+ubuntu repository has an old version of llvm (1.8) which will not work
+with llvm-py.
+
llvm-config
+
Inorder to build llvm-py, it's build script needs to know from where to
+invoke the llvm helper program, llvm-config. If you've installed LLVM,
+then this will be available in your PATH, and nothing further needs to
+be done. If you've built LLVM yourself, or for any reason llvm-config
+is not in your PATH, you'll need to pass the full path of
+llvm-config to the build script.
+
Steps
+
The commands illustrated below assume that the LLVM source is available
+under /home/mdevan/llvm. If you've a previous version of llvm-py
+installed, you must remove it first, as described
+below.
+
If you have llvm-config in your path, you can build and install
+llvm-py this way:
+
+
+
$ tar jxvf llvm-py-0.2.tar.bz2
+$ cd llvm-py-0.2
+$ sudo python setup.py install
+
+
If you need to tell the build script where llvm-config is, do it this
+way:
+
+
+
$ tar jxvf llvm-py-0.2.tar.bz2
+$ cd llvm-py-0.2
+$ sudo python setup.py install --llvm-config=/home/mdevan/llvm/Release/bin/llvm-config
+
+
To build a debug version of llvm-py, that links against the debug
+libraries of LLVM, use this:
+
+
+
$ tar jxvf llvm-py-0.2.tar.bz2
+$ cd llvm-py-0.2
+$ python setup.py build -g --llvm-config=/home/mdevan/llvm/Debug/bin/llvm-config
+$ sudo python setup.py install -g --llvm-config=/home/mdevan/llvm/Debug/bin/llvm-config
+
+
Be warned that debug binaries will be huge (65MB+) !
+
Uninstall
+
To get rid of llvm-py completely, if you wish to do so:
+
+
+
# rm -rf /usr/lib/python2.5/site-packages/llvm
+# rm -f /usr/lib/python2.5/site-packages/llvm_py-0.1.egg-info
+
+
+-
+
+You need to be root to do this.
+
+
+-
+
+Paths are for debian-based systems, in other distros it might be different.
+
+
+-
+
+Note that there are version numbers (both Python's and llvm-py's)
+ which you might need to change to suit your system.
+
+
+
+
+
This section explains a few concepts related to LLVM.
+
Intermediate Representation
+
The intermediate representation, or IR for short, is an in-memory data
+structure that represents executable code. The IR data structures allow
+for creation of types, constants, functions, function arguments,
+instructions, global variables and so on. For example, to create a
+function sum that takes two integers and returns their sum, we need to
+follow these steps:
+
+-
+
+create an integer type ti of required bitwidth
+
+
+-
+
+create a function type tf which takes two ti -s and returns
+ another ti
+
+
+-
+
+create a function of type tf named sum
+
+
+-
+
+add a basic block to the function
+
+
+-
+
+using a helper object called an instruction builder, add two
+ instructions into the basic block:
+
+
+-
+
+an instruction to add the two arguments and store the result into
+ a temporary variable
+
+
+-
+
+a return instruction to return the value of the temporary variable
+
+
+
+
+
+
(A basic block is a block of instructions.)
+
LLVM has it's own instruction set; the instructions used above (add
+and ret) are from this set. The LLVM instructions are at a higher
+level than the usual assembly language; for example there are
+instructions related to variable argument handling, exception handling,
+and garbage collection. These allow high-level languages to be
+represented cleanly in the IR.
+
The full set of instructions are:
+
TODO
+
SSA Form and PHI Nodes
+
All LLVM instructions are represented in the Static Single Assignment
+(SSA) form. Essentially, this means that any variable can be assigned to
+only once. Such a representation facilitates better optimization, among
+other benefits.
+
A consequence of single assignment are PHI (Φ) nodes. These
+are required when a variable can be assigned a different value based on
+the path of control flow. For example, the value of b at the end of
+execution of the snippet below:
+
+
+
a = 1;
+if (v < 10)
+ a = 2;
+b = a;
+
+
cannot be determined statically. The value of 2 cannot be assigned to
+the original a, since a can be assigned to only once. There are
+two a 's in there, and the last assignment has to choose between which
+version to pick. This is accomplished by adding a PHI node:
+
+
+
a1 = 1;
+if (v < 10)
+ a2 = 2;
+b = PHI(a1, a2);
+
+
The PHI node selects a1 or a2, depending on where the control
+reached the PHI node. The argument a1 of the PHI node is associated
+with the block "a1 = 1;" and a2 with the block "a2 = 2;".
+
PHI nodes have to be explicitly created in the LLVM IR. The LLVM
+instruction set therefore has an instruction called phi.
+
LLVM Assembly Language
+
The LLVM IR can be represented offline in two formats
+- a textual, human-readable form, similar to assembly language, called
+ the LLVM assembly language (files with .ll extension) (XXX ?)
+- a binary form, called the LLVM bitcode (files with .bc extension)
+All three formats (the in-memory IR, the LLVM assembly language and the
+LLVM bitcode) represent the same information. Each format can be
+converted into the other two formats (using LLVM APIs).
+
The LLVM demo page lets you type in C or C++
+code, converts it into LLVM IR and outputs the IR as LLVM assembly
+language code.
+
Here's a function in C, that calculates the sum of the first n
+fibonacci numbers:
+
+
+
int fibsum(int n)
+{
+}
+
+
And here's the corresponding LLVM assembly listing, as provided by the
+demo page:
+
+
Note the … TODO …
+
The LLVM Language Reference
+defines the LLVM assembly language including the entire instruction set.
+
Modules
+
Modules, in the LLVM IR, are similar to a single C language source
+file (.c file). A module contains:
+
+-
+
+functions (declarations and definitions)
+
+
+-
+
+global variables and constants
+
+
+-
+
+global type aliases (typedef-s)
+
+
+
+
Modules are top-level containers; all executable code representation is
+contained within modules.
+
Optimization and Passes
+
LLVM provides quite a few optimization algorithms that work on the IR.
+These algorithms are organized as passes. Each pass does something
+specific, like combining redundant instructions. Passes need not always
+optimize the IR, it can also do other operations like inserting
+instrumentation code, or analysing the IR (the result of which can be
+used by passes that do optimizations) or even printing call graphs.
+
This LLVM documentation page
+describes all the available passes, and what they do.
+
LLVM does not automatically choose to run any passes, anytime. Passes
+have to be explicitly selected and run on each module. This gives you
+the flexibility to choose transformations and optimizations that are
+most suitable for the code in the module.
+
There is a LLVM binary called opt,
+which lets you run passes on bitcode files from the command line. You
+can write your own passes (in C/C++, as a shared library). This can be
+loaded and executed by opt. (Although llvm-py does not allow you to
+write your own passes, it does allow you to navigate the entire IR at
+any stage, and perform any transforms on it as you like.)
+
Passes are run using a pass manager. For our purposes, there are two
+
Execution Engine
+
TODO
+
BitCode
+
TODO
+
llvm-gcc
+
TODO
+
+
modules overview: llvm, llvm.core, llvm.ee, llvm.passes
+
importing modules
+
core:
+
types
+
constants
+
values
+
+