| <!--#include virtual="../header.incl" --> |
| <div class="www_sectiontitle">Projects built with LLVM</div> |
| |
| <div class="www_text"> |
| |
| <p>This page is an incomplete list of the projects built with LLVM, sorted in |
| reverse chronological order. The idea of this list is to show some of the |
| things that have been done with LLVM for various course projects or for other |
| purposes, which can be used as a source of ideas for future projects. |
| Another good place to look is the list of <a href="../pubs">published papers |
| and theses that use LLVM</a>.</p> |
| |
| <p>Note that this page is not intended to reflect that current state of LLVM or |
| show endorsement of any particular project over another. This is just a |
| showcase of the hard work various people have done. It also shows a bit |
| about how the capabilities of LLVM have evolved over time.</p> |
| |
| <p>We are always looking for new contributions to this page. If you work on a |
| project that uses LLVM for a course or a publication, we would definitely |
| like to hear about it, and would like to include your work here as well. |
| Please just send email to <a href="mailto:llvm-dev@lists.llvm.org">the LLVM-dev |
| mailing list</a> with an entry like those below. We're not particularly |
| looking for source code (though we welcome source-code contributions through |
| the normal channels), but instead would like to put up the "polished results" |
| of your work, including reports, papers, presentations, posters, or anything |
| else you have.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="toc">Table of Contents</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_text"> |
| |
| <ul> |
| <li><a href="#dragonegg">dragonegg</a></li> |
| <li><a href="#vmkit">vmkit</a></li> |
| <li><a href="#dawncc">DawnCC</a></li> |
| <li><a href="#terralang">Terra Lang</a></li> |
| <li><a href="#codasip">Codasip Studio</a></li> |
| <li><a href="#pony">Pony Programming Language</a></li> |
| <li><a href="#smack">SMACK Software Verifier</a></li> |
| <li><a href="#discopop">DiscoPoP: A Parallelism Discovery Tool</a></li> |
| <li><a href="#jade">Just-in-time Adaptive Decoder Engine (Jade)</a></li> |
| <li><a href="#crack">The Crack Programming Language</a></li> |
| <li><a href="#rubinius">Rubinius: a Ruby implementation</a></li> |
| <li><a href="#macruby">MacRuby</a></li> |
| <li><a href="#pocl">pocl: Portable Computing Language</a></li> |
| <li><a href="#tta-tce">TTA-based Codesign Environment (TCE)</a></li> |
| <li><a href="#icedtea">The IcedTea Version of Sun's OpenJDK</a></li> |
| <li><a href="#pure">The Pure Programming Language Compiler</a></li> |
| <li><a href="#LDC">LDC - the LLVM-based D Compiler</a></li> |
| <li><a href="#compilerwrite">How to Write Your Own Compiler</a></li> |
| <li><a href="#puzzles">Register Allocation by Puzzle Solving</a></li> |
| <li><a href="#faust">Faust Real-Time Signal Processing System</a></li> |
| <li><a href="#adobe-hydra">Adobe "Hydra" Language</a></li> |
| <li><a href="#Calysto">Calysto Static Checker</a></li> |
| <li><a href="#ssa_ra">Improvements on SSA-Based Register Allocation</a></li> |
| <li><a href="#LENS">LENS Project</a></li> |
| <li><a href="#trident">Trident Compiler</a></li> |
| <li><a href="#ascenium">Ascenium Reconfigurable Processor Compiler</a></li> |
| <li><a href="#scheme">Scheme to LLVM Translator</a></li> |
| <li><a href="#llvmtv">LLVM Visualization Tool</a></li> |
| <li><a href="#linearscan">Improvements to Linear Scan register |
| allocation</a></li> |
| <li><a href="#llvaemu">LLVA-emu project</a></li> |
| <li><a href="#spedi">SPEDI: Static Patch Extraction and Dynamic |
| Insertion</a></li> |
| <li><a href="#ssapre">An LLVM Implementation of SSAPRE</a></li> |
| <li><a href="#jello">Jello: a retargetable <b>J</b>ust-In-Time compil<b>e</b>r |
| for <b>LL</b>VM bytec<b>o</b>de</a></li> |
| <li><a href="#emscripten">Emscripten: An LLVM to JavaScript Compiler</a></li> |
| <li><a href="#rust">Rust: a safe, concurrent, practical language</a></li> |
| <li><a href="#ESL">ESL: Embedded Systems Language</a></li> |
| <li><a href="#RTSC">RTSC: The Real-Time Systems Compiler</a></li> |
| <li><a href="#vuo">Vuo: A modern visual programming language for multimedia artists</a></li> |
| </ul> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| |
| |
| <div class="www_subsection"> |
| <a name="dragonegg">dragonegg</a> |
| </div> |
| <div class="www_text"> |
| <p>Dragonegg integrates the LLVM optimizers and code generator with the GCC parsers. |
| This allows LLVM to compile Ada, Fortran, and other languages supported by |
| the GCC compiler frontends, and access to C features not supported by Clang. |
| See <a href="http://dragonegg.llvm.org">dragonegg webpage</a>. |
| </p> |
| </div> |
| |
| <div class="www_subsection"> |
| <a name="vmkit">VMKit: a substrate for virtual machines</a> |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| Current MREs are monolithic. Extending them to propose new features or reusing them to execute new languages is difficult. VMKit is a library that eases the development of new MREs and the process of experimenting with new mechanisms inside MREs. VMKit provides the basic components of MREs: a JIT compiler, a GC, and a thread manager. |
| See <a href="http://vmkit.llvm.org/">vmkit webpage</a>. |
| </p> |
| </div> |
| |
| <div class="www_subsection"> |
| <a name="dawncc">Automatic Insertion of Copy Annotation in Data-Parallel |
| Programs</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By Gleison Mendonca, Breno Campos Ferreira Guimaraes, Péricles Alves, |
| Marcio Machado Pereira, Guido Araéujo, and Fernando Magno Quintao |
| Pereira.<br/> |
| See Dawn project <a href="http://cuda.dcc.ufmg.br/dawn/">webpage</a>. |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| Directive-based programming models, such as OpenACC and OpenMP arise today as |
| promising techniques to support the development of parallel applications. |
| These systems allow developers to convert a sequential program into a parallel |
| one with minimum human intervention. However, inserting pragmas into |
| production code is a difficult and error-prone task, often requiring |
| familiarity with the target program. This difficulty restricts the ability of |
| developers to annotate code that they have not written themselves. This paper |
| provides one fundamental component in the solution of this problem. We |
| introduce a static program analysis that infers the bounds of memory regions |
| referenced in source code. Such bounds allow us to automatically insert |
| data-transfer primitives, which are needed when the parallelized code is meant |
| to be executed in an accelerator device, such as a GPU. To validate our ideas, |
| we have applied them onto Polybench, using two different architectures: Nvidia |
| and Qualcomm-based. We have successfully analyzed 98% of all the memory |
| accesses in Polybench. This result has enabled us to insert automatic |
| annotations into those benchmarks leading to speedups of over 100x. |
| </p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="terralang">Terra: A low-level counterpart to Lua</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://cs.stanford.edu/~zdevito">Zach DeVito</a> |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| <a href="http://terralang.org/">Terra</a> is a system programming language that is |
| embedded in and meta-programmed by Lua, which handles details like |
| conditional compilation, type systems, namespaces, and |
| templating/function specialization that are normally special |
| constructs in other languages. Terra code shares Lua's syntax and |
| control-flow constructs, and it can easily call Lua functions and vice |
| versa. Since the JIT compiler is available at runtime, libraries and |
| embedded domain specific languages can use it to dynamically generate |
| or auto-tune arbitrary high performance code with custom |
| optimizations. |
| </p> |
| |
| <p> |
| Terra is backwards compatible with (and embeddable in) existing C code |
| and is likewise a small, monomorphic, statically-typed, compiled |
| language with manual memory management. There is also built-in support |
| for SIMD operations and other low-level features like non-temporal |
| writes and prefetches. Terra can optionally run independently from |
| LuaJIT and LLVM. In fact, if your final program doesn’t need Lua, you |
| can save Terra code into an object file, shared library, or |
| executable. |
| </p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="codasip">Codasip Studio</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By <a href="https://www.codasip.com/">Codasip Ltd.</a> |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| Codasip Studio is a highly automated development environment that covers all |
| aspects of Application Specific Instruction-set Processor (ASIP) design |
| including LLVM-based C/C++ compiler generation. |
| </p> |
| |
| <p> |
| Starting with a high-level description of a processor written in CodAL |
| (Codasip's processor description language), users are able to generate the |
| design implementation, verification environment, virtual system prototype, |
| and complete redistributable programming environment. |
| </p> |
| |
| <p> |
| Codasip Studio includes a compiler backend generator that analyzes the CodAL |
| description and then automatically generates sources for an LLVM backend with |
| support of numerous extensions for ASIP programming. This way, users are able |
| to generate a working C/C++ compiler for their specific architecture within |
| several days. |
| </p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="pony">Pony Programming Language</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://www.ponylang.org">the Pony Development Team</a> |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| Pony is an object-oriented, actor-model, capabilities-secure, high |
| performance programming language. It emphasizes a concurrent mindset by |
| extending the class model with the actor model such that actors are |
| first-class citizens. The language is statically typed, type- and memory-safe |
| and comes with a collection of powerful guarantees: no data races, no |
| uncaught exceptions, and no deadlocks. Pony implements a |
| mark-and-don’t-sweep garbage collector without requiring generations |
| or read and write barriers. There is no “stop-the-world” step |
| required. All message passing between actors is causal. |
| </p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="smack">SMACK Software Verifier</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By <a href="https://github.com/smackers/smack/wiki/Smackers">smackers</a> |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| <a href="https://github.com/smackers/smack">SMACK</a> is an automated |
| software verifier, verifying assertions given in its input LLVM |
| intermediate representation (IR) programs. Under the hood, SMACK is a |
| translator from the LLVM IR into the Boogie intermediate verification |
| language (IVL). Targeting Boogie exploits a canonical platform which |
| simplifies the implementation of algorithms for verification, model |
| checking, and abstract interpretation. |
| </p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="discopop">DiscoPoP: A Parallelism Discovery Tool</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By the |
| <a href="http://www.grs-sim.de/research/parallel-programming/multicore-programming">DiscoPoP Development Team</a> |
| </div> |
| |
| <div class="www_text"> |
| <p> |
| <a href="http://www.grs-sim.de/discopop">DiscoPoP (Discovery of Potential |
| Parallelism)</a> is a tool that assists in identifying potential |
| parallelism in sequential C/C++ programs. It instruments the code for finding |
| both control and data dependences. A series of analyses are built on top of |
| dependence to explore potential parallelism and parallel patterns. |
| |
| The instrumentation is done with the help of LLVM. A modified version of |
| Clang with a new option "-dp" is also provided to invoke DiscoPoP. |
| </p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="jade">Just-in-time Adaptive Decoder Engine (Jade)</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By Jérôme Gorin (ARTEMIS/Institut Telecom/Telecom SudParis), Mickaël Raulet, Matthieu Wipliez (IETR/INSA Rennes) |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="https://github.com/orcc/jade">Jade</a> (Just-in-time Adaptive |
| Decoder Engine) is a generic video decoder engine using LLVM for just-in-time |
| compilation of video decoder configurations. Those configurations are |
| designed by MPEG Reconfigurable Video Coding (RVC) committee. MPEG RVC |
| standard is built on a stream-based dataflow representation of decoders. It |
| is composed of a standard library of coding tools written in RVC-CAL language |
| and a dataflow configuration — block diagram — of a decoder.</p> |
| |
| <p>Jade project is hosted as part of the Open RVC-CAL Compiler |
| (<a href="http://orcc.sf.net">Orcc</a>) and requires it to translate the |
| RVC-CAL standard library of video coding tools into an LLVM assembly |
| code.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="crack">The Crack Programming Language</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_text"> |
| <p><a href="http://code.google.com/p/crack-language/">Crack</a> aims to provide |
| the ease of development of a scripting language with the performance of a |
| compiled language. The language derives concepts from C++, Java and Python, |
| incorporating object-oriented programming, operator overloading and strong |
| typing.</p> |
| </div> |
| |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="rubinius">Rubinius</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://rubini.us/community.html">Evan Phoenix and the Rubinius team</a> |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="http://github.com/evanphx/rubinius">Rubinius</a> is a new virtual |
| machine for Ruby. It leverages LLVM to dynamically compile Ruby code down to |
| machine code using LLVM's JIT.</p> |
| </div> |
| |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="macruby">MacRuby</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By the <a href="http://www.macruby.org/project.html">MacRuby Project Team</a> |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="http://macruby.org">MacRuby</a> is an implementation of Ruby on top |
| of core Mac OS X technologies, such as the Objective-C common runtime and |
| garbage collector, and the CoreFoundation framework. It is principally |
| developed by Apple and aims at enabling the creation of full-fledged Mac OS X |
| applications.</p> |
| |
| <p>MacRuby uses LLVM for optimization passes, JIT and AOT compilation of Ruby |
| expressions. It also uses zero-cost DWARF exceptions to implement Ruby |
| exception handling.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="pocl">pocl: Portable Computing Language</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By various contributors. |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>In addition to producing an easily portable open source OpenCL |
| implementation, another major goal of <a href="http://portablecl.org">pocl</a> |
| is improving performance portability of OpenCL programs with |
| compiler optimizations, reducing the need for target-dependent manual |
| optimizations.</p> |
| |
| <p>An important part of pocl is a set of LLVM passes used to |
| statically parallelize multiple work-items with the kernel compiler, even in |
| the presence of work-group barriers. This enables static parallelization of |
| the fine-grained static concurrency in the work groups in multiple ways.</p> |
| |
| </div> |
| |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="tta-tce">TTA-based Codesign Environment (TCE)</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://cpc.cs.tut.fi">Customized Parallel Computing</a> group of Tampere University of Technology |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="http://tce.cs.tut.fi">TCE</a> |
| is a toolset for designing customized |
| exposed datapath processors based on the Transport triggered |
| architecture (TTA). </p> |
| |
| <p>The toolset provides a complete co-design flow from C/C++ |
| programs down to synthesizable VHDL/Verilog and parallel program binaries. |
| Processor customization points include the register files, function units, |
| supported operations, and the interconnection network.</p> |
| |
| <p>TCE uses Clang and LLVM for C/C++/OpenCL C language support, target independent |
| optimizations and also for parts of code generation. It generates |
| new LLVM-based code generators "on the fly" for the designed processors and |
| loads them in to the compiler backend as runtime libraries to avoid |
| per-target recompilation of larger parts of the compiler chain.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="icedtea">The IcedTea Version of Sun's OpenJDK</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By Gary Benson (Red Hat, USA) |
| </div> |
| |
| <div class="www_text"> |
| <p>The <a href="http://icedtea.classpath.org/">IcedTea</a> project was formed to |
| provide a harness to build OpenJDK using only free software build tools and |
| to provide replacements for the not-yet free parts of OpenJDK. Over time, |
| various extensions to OpenJDK have been included in IcedTea.</p> |
| |
| <p> One of these extensions |
| is <a href="http://openjdk.java.net/projects/zero/">Zero.</a> OpenJDK only |
| supports x86 and SPARC processors; Zero is a processor-independent layer |
| that allows OpenJDK to build and run using any processor. Zero contains a |
| JIT compiler |
| called <a href="http://icedtea.classpath.org/wiki/ZeroSharkFaq">Shark</a> |
| which uses LLVM to provide native code generation without introducing |
| processor-dependent code.</p> |
| |
| <p>The development of Zero and Shark were funded by Red Hat.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="pure">The Pure Programming Language Compiler</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By Albert Graef, Johannes Gutenberg University Mainz (Germany) |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="http://pure-lang.googlecode.com/">Pure</a> 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.</p> |
| |
| <p>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.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="LDC">LDC - the LLVM-based D Compiler</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By the <a href="http://wiki.dlang.org/LDC">LDC developers</a> |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="http://dlang.org/">D</a> is a language with C-like syntax and static |
| typing. It pragmatically combines efficiency, control, and modeling power, |
| with safety and programmer productivity. D supports powerful concepts like |
| Compile-Time Function Execution (CTFE) and Template Meta-Programming, |
| provides an innovative approach to concurrency and offers many classical |
| paradigms.</p> |
| <p>The <a href="http://wiki.dlang.org/LDC">LDC</a> compiler uses the frontend |
| from the reference compiler combined with LLVM as backend to produce |
| efficient native code.</p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="compilerwrite">How to Write Your Own Compiler</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://staff.polito.it/silvano.rivoira/">Silvano Rivoira, Politecnico di Torino</a> |
| </div> |
| |
| <div class="www_text"> |
| <p><a href="http://staff.polito.it/silvano.rivoira/HowToWriteYourOwnCompiler.htm"> |
| This project</a> describes the development of a compiler front end producing |
| LLVM Assembly Code for a Java-like programming language. It is used in a |
| course on Compilers to show how to incrementally design and implement the |
| successive phases of the translation process by means of common tools such as |
| JFlex and Cup. The source code developed at each step is made available.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="puzzles">Register Allocation by Puzzle Solving</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By Fernando Pereira and Jens Palsberg, UCLA. |
| </div> |
| |
| <div class="www_text"> |
| <p>In this project, we have shown that register allocation can be viewed as |
| solving a collection of puzzles. We model the register file as a puzzle |
| board and the program variables as puzzle pieces; pre-coloring and register |
| aliasing fit in naturally. For architectures such as x86, SPARC V8, and |
| StrongARM, we can solve the puzzles in polynomial time, and we have augmented |
| the puzzle solver with a simple heuristic for spilling. For SPEC CPU2000, |
| our implementation is as fast as the extended version of linear scan used by |
| LLVM. Our implementation produces Pentium code that is of similar quality to |
| the code produced by the slower, state-of-the-art iterated register |
| coalescing algorithm of George and Appel augmented with extensions by Smith, |
| Ramsey, and Holloway.</p> |
| |
| <p><a href="http://compilers.cs.ucla.edu/fernando/projects/puzzles/">Project |
| page</a> with a link to a tool that verifies the output of LLVM's register |
| allocator.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection" id="faust"> |
| Faust Real-Time Signal Processing System |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://www.grame.fr">Grame, National Center of Music Creation</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>FAUST is a compiled language for real-time audio signal processing. The name |
| FAUST stands for Functional AUdio STream. Its programming model combines two |
| approaches: functional programming and block diagram composition. You can |
| think of FAUST as a structured block diagram language with a textual syntax. |
| The project aims at developing a new backend for Faust that will directly |
| produce LLVM IR instead of the C++ class Faust currently produces. With a |
| (yet to come) library version of the Faust compiler, it will allow developers |
| to embed Faust + LLVM JIT to dynamically define, compile on the fly and |
| execute Faust plug-ins. LLVM IR and tools also allows some nice bytecode |
| manipulations like "partial evaluation/specialization" that will also be |
| investigated.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="adobe-hydra">Adobe "Hydra" Language</a> |
| <br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By Adobe Systems Incorporated |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>Efficient use of the computational resources available for image processing |
| is a goal of |
| the <a href="http://labs.adobe.com/wiki/index.php/AIF_Toolkit">Adobe Image |
| Foundation</a> project. Our language, "Hydra", is used to describe single- |
| and multi-stage image processing kernels, which are then compiled and run on |
| a target machine within a larger application. Similarly to how its namesake |
| had many heads, our Hydra can be run on the GPU or alternately on the host |
| CPU(s). AIF uses LLVM for our CPU path.</p> |
| |
| <p>The first Adobe application to use our system is the soon-to-ship After |
| Effects CS3. We welcome you to try out our public beta found |
| at <a href="http://labs.adobe.com/technologies/aftereffectscs3/">labs.adobe.com</a>.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="Calysto">Calysto Static Checker</a> |
| <br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By Domagoj Babic, UBC. |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="http://www.cs.ubc.ca/~babic/index_calysto.htm">Calysto</a> is a |
| scalable context- and path-sensitive SSA-based static assertion |
| checker. Unlike other static checkers, Calysto analyzes SSA directly, which |
| means that it not only checks the original code, but also the front-end |
| (including SSA-optimizations) of the compiler which was used to compile the |
| code. The advantage of doing static checking on the SSA is language |
| independency and the fact that the checked code is much closer to the |
| generated assembly than the source code.</p> |
| |
| <p>Several main factors contribute to Calysto's scalability: |
| <ul> |
| <li> A novel SSA symbolic execution algorithm that exploits the |
| structure of the control flow graph to minimize the number of |
| paths that need to be considered.</li> |
| |
| <li> Lazy interprocedural analysis.</li> |
| <li> Tight integration with the |
| <a href="http://www.cs.ubc.ca/~babic/index_spear.htm">Spear</a> |
| automated theorem prover, designed for software static |
| checking.</li> |
| <li> And, of course, fast implementations of the basic algorithms |
| in LLVM (dominator trees, postdominance, etc.).</li> |
| </ul> |
| </p> |
| |
| <p>Currently, Calysto is still in the development phase, and the first results |
| are encouraging. Most likely, the first public release will happen some time |
| in the fall |
| 2007. <a href="http://www.cs.ubc.ca/~babic/index_spear.htm">Spear</a> and |
| Calysto |
| generated <a href="http://www.cs.ubc.ca/~babic/index_benchmarks.htm">benchmarks</a> |
| are available.</p> |
| |
| </div> |
| |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="ssa_ra">Improvements on SSA-Based Register Allocation.</a> |
| </div> |
| |
| <div class="www_subsubsection"> |
| By Fernando Pereira, UCLA. |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>The register allocation problem has an exact polynomial solution when |
| restricted to programs in the Single Static Assignment (SSA) form. Although |
| striking, this major theoretical accomplishment has yet to be endorsed |
| empirically. This project consists in the implementation of a complete |
| SSA-based register allocator using the <a href="http://llvm.org/" |
| target="blank">LLVM</a> compiler framework. We have implemented a static |
| transformation of the target program that simplifies the implementation of |
| the register allocator and improves the quality of the code that it |
| generates. We also describe novel techniques to perform register coalescing |
| and SSA-elimination. In order to validate our allocation technique, we |
| extensively compare different flavors of our method against a modern and |
| heavily tuned extension of the linear-scan register allocator described |
| <a href="2004-Fall-CS426-LS.pdf">here</a>. The proposed algorithm |
| consistently produces faster code when the target architecture provides a |
| small number of registers. For instance, we have achieved an average |
| speed-up of 9.2% when limiting the number of registers to four general |
| purpose and three reserved register. By augmenting the algorithm with an |
| aggressive coalescing technique, we have been able to raise the speed |
| improvement up to 13.0%.</p> |
| |
| <p>This project was supported by the google's |
| <a href="http://code.google.com/soc/" target="blank">Summer of Code</a> |
| initiative. Fernando Pereira is funded |
| by <a href="http://www.capes.gov.br/capes/portal/" target="blank">CAPES</a> |
| under process number 218603-9.</p> |
| |
| <p><a href="http://compilers.cs.ucla.edu/fernando/projects/soc/">Project page.</a></p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="LENS">LENS Project</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By Michael O. McCracken, UCSD. |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>The <a href="http://www.cs.ucsd.edu/~mmccrack/lens/">LENS Project</a> is |
| intended to improve the task of measuring programs and investigating their |
| behavior. LENS defines an external representation of a program in XML to |
| store useful information that is accessible based on program structure, |
| including loop structure information.</p> |
| |
| <p>Lens defines a flexible naming scheme for program components based on XPath |
| and the LENS XML document structure. This allows users and tools to |
| selectively query program behavior from a uniform interface, allowing users |
| or tools to ask a variety of questions about program components, which can be |
| answered by any tool that understands the query. Queries, metrics and program |
| structure are all stored in the LENS file, and are annotated with version |
| names that support historical comparison and scientific record-keeping.</p> |
| |
| <p>Compiler writers can use LENS to expose results of transformations and |
| analyses for a program easily, without worrying about display or handling |
| information overload. This functionality has been demonstrated using |
| LLVM. LENS uses LLVM for two purposes: first, to generate the initial program |
| structure file in XML using an LLVM pass, and second, as a demonstration of |
| the advantages of selective querying for compiler information, with an |
| interface built into LLVM that allows LLVM passes to easily respond to |
| queries in a LENS file.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="trident">Trident Compiler</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://www.lanl.gov/">Los Alamos National Laboratory</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="http://trident.sf.net/">Trident</a> is a compiler for floating point |
| algorithms written in C, producing Register Transfer Level VHDL descriptions |
| of circuits targeted for reconfigurable logic devices. Trident automatically |
| extracts parallelism and pipelines loop bodies using conventional compiler |
| optimizations and scheduling techniques. Trident also provides an open |
| framework for experimentation, analysis, and optimization of floating point |
| algorithms on FPGAs and the flexibility to easily integrate custom floating |
| point libraries.</p> |
| |
| <p>Trident uses the LLVM C/C++ front-end to parse input languages and produce |
| low-level platform independent code.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="ascenium">Ascenium Reconfigurable Processor Compiler</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection"> |
| By <a href="http://www.ascenium.com/">Ascenium Corporation</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>Ascenium is a fine-grained continuously reconfigurable processor that handles |
| most instructions at hard-wired speeds while retaining the ability to be |
| targeted by conventional high level languages, giving users "all the |
| performance of hardware, all the ease of software."</p> |
| |
| <p>The Ascenium team prefers LLVM bytecodes as input to its code generator for |
| several reasons: |
| <ul> |
| <li>LLVM's all inclusive format makes global optimizations and consolidations |
| such as global data dependency analysis easy.</li> |
| <li>LLVM's rich and strictly typed format generally make subtle and |
| sophisticated optimizations easy.</li> |
| <li>LLVM's great ancillary tools and documentation make it easy to work with |
| — even hardware geeks can understand it!</li> |
| </ul> |
| </p> |
| |
| <p>Ascenium's <a href="http://www.hotchips.org/archives/hc17/">HOT CHIPS 17</a> |
| <a href="Ascenium.pdf">presentation</a> describes the architecture and |
| compiler in more detail.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="scheme">Scheme to LLVM Translator</a><br> |
| </div> |
| <!--=========================================================================--> |
| |
| <div class="www_subsubsection">By Tobias Nurmiranta</div> |
| |
| <div class="www_text"> |
| |
| <p>This is a <a href="http://www.ida.liu.se/~tobnu/scheme2llvm/">small scheme |
| compiler</a> for LLVM, written in scheme. It is good enough to compile |
| itself and work.</p> |
| |
| <p>The code is quite similar to the code in the book SICP (Structure and |
| Interpretation of Computer Programs), chapter five, with the difference that |
| it implements the extra functionality that SICP assumes that the explicit |
| control evaluator (virtual machine) already have. Much functionality of the |
| compiler is implemented in a subset of scheme, llvm-defines, which are |
| compiled to llvm functions.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="llvmtv">LLVM Visualization Tool</a> |
| </div> |
| <!--=========================================================================--> |
| <!-- CS497rej: Object-Oriented Programming and Design (Spring 2004) Project --> |
| |
| <!-- _______________________________________________________________________ --> |
| <div class="www_subsubsection"> |
| By <a href="http://misha.brukman.net/">Misha Brukman</a>, |
| <a href="http://nondot.org/tonic/">Tanya Brethour</a>, and |
| <a href="http://netfiles.uiuc.edu/gaeke/www/">Brian Gaeke</a><br> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>The LLVM Visualization Tool (LLVM-TV) can be used to visualize the effects of |
| transformations written in the LLVM framework. Our visualizations reflect |
| the state of a compilation unit at a single instant in time, between |
| transformations; we call these saved states "snapshots". A user can |
| visualize a sequence of snapshots of the same module—for example, as a |
| program is being optimized—or snapshots of different modules, for |
| comparison purposes.</p> |
| |
| <p>Our target audience consists of developers working within the LLVM framework, |
| who are trying to understand the LLVM representation and its analyses and |
| transformations. In addition, LLVM-TV has been designed to make it easy to |
| add new kinds of program visualization modules. LLVM-TV is based on |
| the <a href="http://www.wxwindows.org">wxWidgets</a> cross-platform GUI |
| framework, and uses AT&T |
| Research's <a href="http://www.research.att.com/sw/tools/graphviz">GraphViz</a> |
| to draw graphs.</p> |
| |
| <p><a href="http://wiki.cs.uiuc.edu/cs497rej/LLVM+Visualization+Tool">Wiki |
| page</a> with overview; design doc, and user manual. You can download |
| llvm-tv from LLVM SVN (http://llvm.org/svn/llvm-project/television/trunk).</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="linearscan">Improvements to Linear Scan register allocation</a> |
| </div> |
| <!--=========================================================================--> |
| <!-- CS426: Advanced Compilers (Fall 2003) Project<br>--> |
| |
| <!-- _______________________________________________________________________ --> |
| <div class="www_subsubsection"> |
| By <a href="mailto:alkis@cs.uiuc.edu">Alkis Evlogimenos</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>Linear scan register allocation is a fast global register allocation first |
| presented |
| in <a href="http://citeseer.ist.psu.edu/poletto99linear.html">Linear Scan |
| Register Allocation</a> as an alternative to the more widely used graph |
| coloring approach. In this paper, I apply the linear scan register allocation |
| algorithm in a system with SSA form and show how to improve the algorithm by |
| taking advantage of lifetime holes and memory operands, and also eliminate |
| the need for reserving registers for spill code.</p> |
| |
| <p>Project |
| report: <a href="2004-Fall-CS426-LS.ps">PS</a>, <a href="2004-Fall-CS426-LS.pdf">PDF</a></p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="llvaemu">LLVA-emu project</a> |
| </div> |
| <!--=========================================================================--> |
| <!-- CS497YYZ: Hot Topics in Operating Systems (Fall 2003) --> |
| |
| <!-- _______________________________________________________________________ --> |
| <div class="www_subsubsection"> |
| By <a href="http://misha.brukman.net/">Misha Brukman</a> and |
| <a href="http://netfiles.uiuc.edu/gaeke/www/">Brian Gaeke</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>Traditional architectures use the hardware instruction set for dual purposes: |
| first, as a language in which to express the semantics of software programs, |
| and second, as a means for controlling the hardware. The thesis of |
| the <a href="/pubs/2003-10-01-LLVA.html">Low-Level Virtual Architecture</a> |
| project is to decouple these two uses from one another, allowing software to |
| be expressed in a semantically richer, more easily-manipulated format, and |
| allowing for more powerful optimizations and whole-program analyses directly |
| on compiled code.</p> |
| |
| <p>The semantically rich format we use in LLVA, which is based on the LLVM |
| compiler infrastructure's intermediate representation, can best be understood |
| as a "virtual instruction set". This means that while its instructions are |
| closely matched to those available in the underlying hardware, they may not |
| correspond exactly to the instructions understood by the underlying hardware. |
| These underlying instructions we call the "implementation instruction set." |
| Between the two layers lives the translation layer, typically implemented in |
| software.</p> |
| |
| <p>In this project, we have taken our next logical steps in this effort by (1) |
| porting the entire Linux kernel to LLVA, and (2) engineering an environment |
| in which a kernel can be run directly from its LLVM bytecode representation |
| — essentially, a minimal, but complete, emulated computer system with |
| LLVA as its native instruction set. The emulator we have invented, llva-emu, |
| executes kernel code by translating programs "just-in-time" from the LLVM |
| bytecode format to the processor's native instruction set.</p> |
| |
| <p>Project |
| report: <a href="2003-Fall-CS497YYZ-LLVA-emu.ps">PS</a>, <a href="2003-Fall-CS497YYZ-LLVA-emu.pdf">PDF</a></p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="spedi">SPEDI: Static Patch Extraction and Dynamic Insertion</a> |
| </div> |
| <!--=========================================================================--> |
| |
| <!-- _______________________________________________________________________ --> |
| <div class="www_subsubsection"> |
| By Brian Fahs |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>As every modern computer user has experienced, software updates and upgrades |
| frequently require programs and sometimes the entire operating system to be |
| restarted. This can be a painful and annoying experience. What if this common |
| annoyance could be avoided completely or at least significantly reduced? |
| Imagine only rebooting your system when you wanted to shut your computer down |
| or only closing an application when you wanted rather than when an update |
| occurs. The purpose of this project is to investigate the potential of |
| performing dynamic patching of executables and create a patching tool capable |
| of automatically generating patches and applying them to applications that |
| are already running. This project should answer questions like: How can |
| dynamic updating be performed? What type of analysis is required? Can this |
| analysis be effectively automated? What can be updated in the running |
| executable (e.g., algorithms, organization, data, etc.)?</p> |
| |
| <p>Project report: <a href="2003-Fall-CS497YYZ-SPEDI.ps">PS</a>, <a |
| href="2003-Fall-CS497YYZ-SPEDI.pdf">PDF</a></p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="ssapre">An LLVM Implementation of SSAPRE</a> |
| </div> |
| <!--=========================================================================--> |
| <!--CS426: Advanced Compilers (Fall 2002)--> |
| |
| <!-- _______________________________________________________________________ --> |
| <div class="www_subsubsection"> |
| By <a href="http://nondot.org/tonic/">Tanya Brethour</a>, |
| Joel Stanley, and Bill Wendling |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>In this report we present implementation details, empirical performance data, |
| and notable modifications to an algorithm for PRE based on [the 1999 TOPLAS |
| SSAPRE paper]. In [the 1999 TOPLAS SSAPRE paper], a particular realization |
| of PRE, known as SSAPRE, is described, which is more efficient than |
| traditional PRE implementations because it relies on useful properties of |
| Static Single-Assignment (SSA) form to perform dataflow analysis in a much |
| more sparse manner than the traditional bit-vector-based approach. Our |
| implementation is specific to a SSA-based compiler infrastructure known as |
| LLVM (Low-Level Virtual Machine).</p> |
| |
| <p>Project report: <a href="2002-Fall-CS426-SSAPRE.ps">PS</a>, <a |
| href="2002-Fall-CS426-SSAPRE.pdf">PDF</a></p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="jello">Jello: a retargetable <u>J</u>ust-In-Time compil<u>e</u>r for |
| <u>LL</u>VM bytec<u>o</u>de</a> |
| </div> |
| <!--=========================================================================--> |
| <!-- CS497CZ: Dynamic Translation and Optimization (Spring 2002)--> |
| |
| <!-- _______________________________________________________________________ --> |
| <div class="www_subsubsection"> |
| By <a href="http://nondot.org/sabre/">Chris Lattner</a>, |
| <a href="http://misha.brukman.net/">Misha Brukman</a>, and |
| <a href="http://netfiles.uiuc.edu/gaeke/www/">Brian Gaeke</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p>We present the design and implementation of Jello, a <i>retargetable</i> |
| Just-In-Time (JIT) compiler for the Intel IA32 architecture. The input to |
| Jello is a C program statically compiled to Low-Level Virtual Machine (LLVM) |
| bytecode. Jello takes advantage of the features of the LLVM bytecode |
| representation to permit efficient run-time code generation, while |
| emphasizing retargetability. Our approach uses an abstract machine code |
| representation in Static Single Assignment form that is machine-independent, |
| but can handle machine-specific features such as implicit and explicit |
| register references. Because this representation is target-independent, many |
| phases of code generation can be target-independent, making the JIT easily |
| retargetable to new platforms without changing the code generator. Jello's |
| ultimate goal is to provide a flexible host for future research in runtime |
| optimization for programs written in languages which are traditionally |
| compiled statically.</p> |
| |
| <p>Note that Jello eventually evolved into the current LLVM JIT, which is part |
| of the tool <b>lli</b>.</p> |
| |
| <p>Project report: <a href="2002-Spring-CS497CZ-Jello.ps">PS</a>, <a |
| href="2002-Spring-CS497CZ-Jello.pdf">PDF</a></p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="emscripten">Emscripten: An LLVM to JavaScript Compiler</a> |
| </div> |
| <div class="www_subsubsection"> |
| By Alon Zakai and the rest of |
| the <a href="https://raw.github.com/kripken/emscripten/incoming/AUTHORS"> |
| Emscripten contributors</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="http://emscripten.org">Emscripten</a> compiles LLVM bitcode into |
| JavaScript, which makes it possible to compile C and C++ source code to |
| JavaScript (by first compiling it into LLVM bitcode using Clang), which can |
| be run on the web. Emscripten has been used to port large existing C and C++ |
| codebases, for example Python (the standard CPython implementation), the |
| Bullet physics engine, and the eSpeak speech synthesizer, among many |
| others.</p> |
| |
| <p>Emscripten itself is written in JavaScript. Significant components include the |
| <a href="https://github.com/kripken/emscripten/blob/master/docs/paper.pdf?raw=true"> |
| Relooper Algorithm</a> which generates high-level JavaScript control flow |
| structures ("if", "while", etc.) from the low-level basic block information |
| present in LLVM bitcode, as well as a JavaScript parser for LLVM assembly.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="rust">Rust: a safe, concurrent, practical language</a> |
| </div> |
| <div class="www_subsubsection"> |
| The <a href="https://github.com/rust-lang/rust/graphs/contributors"> |
| rust contributors</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="http://www.rust-lang.org/">rust</a> is a curly-brace, |
| block-structured expression language. It visually resembles the C language |
| family, but differs significantly in syntactic and semantic details. Its |
| design is oriented toward concerns of "programming in the large", that is, of |
| creating and maintaining <i>boundaries</i> - both abstract and operational - |
| that preserve large-system <i>integrity</i>, <i>availability</i> |
| and <i>concurrency</i>.</p> |
| |
| <p>It supports a mixture of imperative procedural, concurrent actor, |
| object-oriented and pure functional styles. Rust also supports generic |
| programming and metaprogramming, in both static and dynamic styles.</p> |
| |
| <p>The static/native compilation is using LLVM.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="ESL">Embedded Systems Language</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="https://github.com/bagel99/esl">ESL (Embedded Systems Language)</a> is |
| a new programming language designed for efficient implementation of embedded |
| systems and other low-level system programming projects. ESL is a typed |
| compiled language with features that allow the programmer to dictate the |
| concrete representation of data values; useful when dealing, for example, |
| with communication protocols or device registers.</p> |
| |
| <p>Novel features are: no reserved words, procedures can return multiple values, |
| automatic endian conversion, methods on types (but no classes). The syntax |
| is more Pascal-like than C-like, but with C bracketing. The compiler |
| bootstraps from LL IR.</p> |
| |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="RTSC">RTSC: The Real-Time Systems Compiler</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="http://www4.cs.fau.de/Research/RTSC/">The Real-Time Systems Compiler |
| (RTSC)</a> is an operating-system–aware compiler that allows for a generic |
| manipulation of the real-time system architecture of a given real-time |
| application.</p> |
| |
| <p>Currently, its most interesting application is the automatic migration of an |
| event-triggered (i.e. based on OSEK OS) system to a time-triggered |
| (i.e. based on OSEKTime) one. To achieve this, the RTSC derives an abstract |
| global dependency graph from the source code of the application formed by so |
| called "Atomic Basic Blocks" (ABBs). This "ABB-graph" is free of any |
| dependency to the original operating system but includes all control and data |
| dependencies of the application. Thus this graph can be mapped to another |
| target operating system. Currently input applications can be written for OSEK |
| OS and then be migrated to OSEKTime or POSIX systems.</p> |
| |
| <p>The LLVM-framework is used throughout the whole process. At first the static |
| analysis of the application needed to construct the ABB-graph is performed |
| using the LLVM-framework. Additionally the manipulation and final generation |
| of the target system are also based on the LLVM.</p> |
| </div> |
| |
| <!--=========================================================================--> |
| <div class="www_subsection"> |
| <a name="vuo">Vuo: A modern visual programming language for multimedia artists</a> |
| </div> |
| |
| <div class="www_text"> |
| |
| <p><a href="http://vuo.org">Vuo</a> is a modern visual programming language |
| for multimedia artists. The Vuo Compiler takes modular components written |
| in various languages, and a graph of dataflow between components. |
| <a href="http://vuo.org/node/31">Using the LLVM code generation API</a>, |
| the Vuo Compiler turns the graph into a native, multithreaded executable.</p> |
| |
| </div> |
| |
| <!--#include virtual="../footer.incl" --></html> |