Chris Lattner

Jello: a retargetable Just-In-Time compiler for LLVM bytecode

We present the design and implementation of Jello, a re- targetable Just-In-Time (JIT) compiler f... more We present the design and implementation of Jello, a re- targetable 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 ecien t run-time code generation, while emphasizing retargetability. Our approach uses an abstract machine code representation in Static Single As- signment form that is machine-independent, but can han- dle machine-specic 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 plat- forms without changing the code generator. Jello&amp;amp;#x27;s ultimate goal is to provide a exible host for future research in run- time optimization for programs written in languages which are traditionally compiled statically.

Addressing Fundamental Bottlenecks in Link-Time and Dynamic Optimization

The popularity of object-oriented programming languages, component libraries, and dynamically lin... more The popularity of object-oriented programming languages, component libraries, and dynamically linked libraries all significantly limit the effectiveness of static analysis and optimization. These trends have led to significant recent interest in link-time interprocedural optimization and runtime optimization. Unfortunately, these approaches present some difficult technical challenges that have limited their use so far. One common limitation is that machine-level object code (the output of traditional source-level compilers) can be very diflicult to analyze and transform. Link-time and runtime optimizers working with machine code generally cannot perform sophisticated high-level analyses and optimizations, e.g., sophisticated pointer analysis exploiting high-level type information and function signatures, data structure layout reorganization, loop transformations requiring array dependence analysis, and many others. A second fundamental limitation of runtime optimization is its runti...

The LLVM Instruction Set and Compilation Strategy

This document introduces the LLVM compiler infrastructure and instruction set, a simple approach ... more This document introduces the LLVM compiler infrastructure and instruction set, a simple approach that enables sophisticated code transformations at link time, runtime, and in the field. It is a pragmatic approach to compilation, interfering with programmers and tools as little as possible, while still retaining extensive high-level information from source-level compilers for later stages of an application's lifetime. We describe the LLVM instruction set, the design of the LLVM system, and some of its key components.

Architecture for a Next-Generation GCC

This paper presents a design and implementation of a whole-program interprocedural optimizer buil... more This paper presents a design and implementation of a whole-program interprocedural optimizer built in the GCC framework. Through the introduction of a new language-independent intermediate representation, we extend the current GCC architecture to include a powerful mid-level optimizer and add link-time interprocedural analysis and optimization capabilities. This intermediate representation is an SSA-based, low-level, strongly-typed, representation which is designed to support both e#cient global optimizations and high-level analyses. Because most of the program is available at link-time, aggressive "whole-program" optimizations and analyses are possible, improving the time and space requirements of compiled programs. The final proposed organization of GCC retains the important features which make it successful today, requires almost no modification to either the frontor back-ends of GCC, and is completely compatible with user makefiles.

Download

Data Structure Analysis: An Efficient Context-Sensitive Heap Analysis

This paper presents an efficient context-sensitive heap analysis algorithm called Data Structure ... more This paper presents an efficient context-sensitive heap analysis algorithm called Data Structure Analysis designed to enable analyses and transformations on entire disjoint recursive data structures. The analysis has several challenging properties needed to enable such transformations: context-sensitivity with cloning (essential for proving disjointness), field-sensitivity, and the use of an explicit heap model rather than just alias information. It is also applicable to arbitrary C programs. To our knowledge no prior work provides all these properties and is efficient and scalable enough for large programs. Measurements for 29 programs show that the algorithm is extremely fast, space-efficient, and scales almost linearly across 3 orders-of-magnitude of code size.

Introduction to the LLVM Compiler System

Developing a Graphical Robotics Simulator

An interactive robotics graphical computer simulation program, GRAS (Graphical Robot Animator and... more An interactive robotics graphical computer simulation program, GRAS (Graphical Robot Animator and Simulator), has been developed. The GRAS program reads a data file of robot geometry data and displays the robot configuration as a 3D solid model. It simulates a teach pendant for user interaction. The program was written in Java language for maximum portability and application. GRAS is a

Macroscopic data structure analysis and optimization

Data Structure Analysis: An Ecien t Context-Sensitive Heap Analysis

This paper presents an ecien t context-sensitive heap analysis algorithm called Data Structure An... more This paper presents an ecien t context-sensitive heap analysis algorithm called Data Structure Analysis designed to enable analyses and transformations on entire disjoint recursive data structures. The analysis has several challenging properties needed to enable such transformations: context-sensitivity with cloning (essential for proving disjointness), eld-sensitivity , and the use of an explicit heap model rather than just alias information. It

Architecture for a next-generation gcc

This paper presents a design and implementation of a whole-program interprocedural optimizer buil... more This paper presents a design and implementation of a whole-program interprocedural optimizer built in the GCC framework. Through the introduction of a new languageindependent intermediate representation, we extend the current GCC architecture to include a powerful mid-level optimizer and add linktime interprocedural analysis and optimization capabilities. This intermediate representation is an SSA-based, low-level, strongly-typed, representation which is designed to support both efficient global optimizations and highlevel analyses. Because most of the program is available at link-time, aggressive "wholeprogram" optimizations and analyses are possible, improving the time and space requirements of compiled programs. The final proposed organization of GCC retains the important features which make it successful today, requires almost no modification to either the front-or back-ends of GCC, and is completely compatible with user makefiles.

Download

Automatic pool allocation

ACM SIGPLAN Notices, 2005

This paper describes Automatic Pool Allocation, a transformation framework that segregates distin... more This paper describes Automatic Pool Allocation, a transformation framework that segregates distinct instances of heap-based data structures into seperate memory pools and allows heuristics to be used to partially control the internal layout of those data structures. The primary goal of this work is performance improvement, not automatic memory management, and the paper makes several new contributions. The key contribution is a new compiler algorithm for partitioning heap objects in imperative programs based on a context-sensitive pointer analysis, including a novel strategy for correct handling of indirect (and potentially unsafe) function calls. The transformation does not require type safe programs and works for the full generality of C and C++. Second, the paper describes several optimizations that exploit data structure partitioning to further improve program performance. Third, the paper evaluates how memory hierarchy behavior and overall program performance are impacted by the new transformations. Using a number of benchmarks and a few applications, we find that compilation times are extremely low, and overall running times for heap intensive programs speed up by 10-25% in many cases, about 2x in two cases, and more than 10x in two small benchmarks. Overall, we believe this work provides a new framework for optimizing pointer intensive programs by segregating and controlling the layout of heapbased data structures.

Download

Automatic pool allocation for disjoint data structures

ACM SIGPLAN Notices, 2003

This paper presents an analysis technique and a novel program transformation that can enable powe... more This paper presents an analysis technique and a novel program transformation that can enable powerful optimizations for entire linked data structures. The fully automatic transformation converts ordinary programs to use pool (aka region) allocation for heap-based data structures. The transformation relies on an efficient link-time interprocedural analysis to identify disjoint data structures in the program, to check whether these data structures are accessed in a type-safe manner, and to construct a Disjoint Data Structure Graph that describes the connectivity pattern within such structures. We present preliminary experimental results showing that the data structure analysis and pool allocation are effective for a set of pointer intensive programs in the Olden benchmark suite. To illustrate the optimizations that can be enabled by these techniques, we describe a novel pointer compression transformation and briefly discuss several other optimization possibilities for linked data structures.

Download

LLVM: A compilation framework for lifelong program analysis & transformation

International Symposium on Code Generation and Optimization, 2004. CGO 2004., 2004

This paper describes LLVM (Low Level Virtual Machine), a compiler framework designed to support t... more This paper describes LLVM (Low Level Virtual Machine), a compiler framework designed to support transparent, lifelong program analysis and transformation for arbitrary programs, by providing high-level information to compiler transformations at compile-time, link-time, run-time, and offline. LLVM defines a common, low-level code representation in Static Single Assignment (SSA) form, with several novel features: a simple, language-independent type-system that exposes the primitives commonly used to implement high-level language features; an instruction for typed address arithmetic; and a simple mechanism that can be used to implement the exception handling features of high-level languages (and setjmp/longjmp in C) uniformly and efficiently. The LLVM compiler framework and code representation together provide a combination of key capabilities that are important for practical, lifelong analysis and transformation of programs. To our knowledge, no existing compilation approach provides all these capabilities. We describe the design of the LLVM representation and compiler framework, and evaluate the design in three ways: (a) the size and effectiveness of the representation, including the type information it provides; (b) compiler performance for several interprocedural problems; and (c) illustrative examples of the benefits LLVM provides for several challenging compiler problems.

Download

LLVA: a low-level virtual instruction set architecture

22nd Digital Avionics Systems Conference. Proceedings (Cat. No.03CH37449), 2003

A virtual instruction set architecture (V-ISA) implemented via a processor-specific software tran... more A virtual instruction set architecture (V-ISA) implemented via a processor-specific software translation layer can provide great flexibility to processor designers. Recent examples such as Crusoe and DAISY, however, have used existing hardware instruction sets as virtual ISAs, which complicates translation and optimization. In fact, there has been little research on specific designs for a virtual ISA for processors. This paper proposes a novel virtual ISA (LLVA) and a translation strategy for implementing it on arbitrary hardware. The instruction set is typed, uses an infinite virtual register set in Static Single Assignment form, and provides explicit control-flow and dataflow information, and yet uses low-level operations closely matched to traditional hardware. It includes novel mechanisms to allow more flexible optimization of native code, including a flexible exception model and minor constraints on self-modifying code. We propose a translation strategy that enables offline translation and transparent offline caching of native code and profile information, while remaining completely OS-independent. It also supports optimizations directly on the representation at install-time, runtime, and offline between executions. We show experimentally that despite its rich information content, virtual object code is comparable in size to native machine code, virtual instructions expand to only 2-4 ordinary hardware instructions on average, and simple translation costs under 1% of total execution time except for very short runs. Hardware Processor Application Software Operating System Kernel ISA (I−ISA) Implementation translator Processor−specific Virtual ISA (V−ISA)

Download

The LLVM Compiler Framework and Infrastructure Tutorial

Lecture Notes in Computer Science, 2005

... A third goal is to provide a flexible infrastructure for new compiler development and researc... more

Automatic pool allocation for disjoint data structures

Proceedings of the workshop on Memory system performance - MSP '02, 2002

This paper presents an analysis technique and a novel program transformation that can enable powe... more This paper presents an analysis technique and a novel program transformation that can enable powerful optimizations for entire linked data structures. The fully automatic transformation converts ordinary programs to use pool (aka region) allocation for heap-based data structures. The transformation relies on an efficient link-time interprocedural analysis to identify disjoint data structures in the program, to check whether these data structures are accessed in a type-safe manner, and to construct a Disjoint Data Structure Graph that describes the connectivity pattern within such structures. We present preliminary experimental results showing that the data structure analysis and pool allocation are effective for a set of pointer intensive programs in the Olden benchmark suite. To illustrate the optimizations that can be enabled by these techniques, we describe a novel pointer compression transformation and briefly discuss several other optimization possibilities for linked data structures.

Download

Transparent pointer compression for linked data structures

Proceedings of the 2005 workshop on Memory system performance - MSP '05, 2005

bit address spaces are increasingly important for modern applications, but they come at a price: ... more bit address spaces are increasingly important for modern applications, but they come at a price: pointers use twice as much memory, reducing the effective cache capacity and memory bandwidth of the system (compared to 32-bit ad- dress spaces). This paper presents a sophisticated, auto- matic transformation that shrinks pointers from 64-bits to 32-bits. The approach is &amp;quot;macroscopic,&amp;quot; i.e., it operates

Memory safety without runtime checks or garbage collection

ACM SIGPLAN Notices, 2003

... Dinakar Dhurjati Sumant Kowshik Vikram Adve Chris Lattner ... be checked are discussed in Sec... more

LLVM: An Infrastructure for Multistage Optimization

Abstract: Modern programming languages and software engineering principles are causing increasing... more Abstract: Modern programming languages and software engineering principles are causing increasing problems for compiler systems. Traditional approaches, which use a simple compile-link-execute model, are unable to provide adequate application performance under the demands of the new conditions. Traditional approaches to interprocedural and profile-driven compilation can provide the application performance needed, but require infeasible amounts of compilation time to build the application. This thesis...

Download

The LLVM Instruction Set and Compilation Strategy

This document introduces the LLVM compiler infrastructure and instruction set, a simple approach ... more This document introduces the LLVM compiler infrastructure and instruction set, a simple approach that enables sophisticated code transformations at link time, runtime, and in the field. It is a pragmatic approach to compilation, interfering with programmers and tools as little as possible, while still retaining extensive high-level information from source-level compilers for later stages of an application's lifetime. We describe the LLVM instruction set, the design of the LLVM system, and some of its key components.

Uploads

Papers by Chris Lattner

Log In