diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..5973a95
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+USE_LLVM_COMPILER
diff --git a/build/Android.common.mk b/build/Android.common.mk
index a4cdc34..525ca83 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -14,6 +14,18 @@
 # limitations under the License.
 #
 
+# Use llvm as the backend
+ifneq ($(wildcard art/USE_LLVM_COMPILER),)
+ART_USE_LLVM_COMPILER := true
+else
+ART_USE_LLVM_COMPILER := false
+endif
+
+ifeq ($(ART_USE_LLVM_COMPILER),true)
+LLVM_ROOT_PATH := external/llvm
+include $(LLVM_ROOT_PATH)/llvm.mk
+endif
+
 # art-cache
 ART_CACHE_DIR := /data/art-cache
 ART_CACHE_OUT := $(TARGET_OUT_DATA)/art-cache
@@ -53,6 +65,11 @@
 	-fno-align-jumps \
 	-fstrict-aliasing
 
+ifeq ($(ART_USE_LLVM_COMPILER),true)
+art_cflags := \
+	-DART_USE_LLVM_COMPILER=1
+endif
+
 ifeq ($(HOST_OS),linux)
   art_non_debug_cflags := \
 	-Wframe-larger-than=1728
@@ -113,18 +130,6 @@
 	src/class_loader.cc \
 	src/compiled_method.cc \
 	src/compiler.cc \
-	src/compiler/Dataflow.cc \
-	src/compiler/Frontend.cc \
-	src/compiler/IntermediateRep.cc \
-	src/compiler/Ralloc.cc \
-	src/compiler/SSATransformation.cc \
-	src/compiler/Utility.cc \
-	src/compiler/codegen/RallocUtil.cc \
-	src/compiler/codegen/arm/ArchUtility.cc \
-	src/compiler/codegen/arm/ArmRallocUtil.cc \
-	src/compiler/codegen/arm/Assemble.cc \
-	src/compiler/codegen/arm/LocalOptimizations.cc \
-	src/compiler/codegen/arm/armv7-a/Codegen.cc \
 	src/dalvik_system_DexFile.cc \
 	src/dalvik_system_VMDebug.cc \
 	src/dalvik_system_VMRuntime.cc \
@@ -208,6 +213,28 @@
 	src/utils.cc \
 	src/zip_archive.cc
 
+ifeq ($(ART_USE_LLVM_COMPILER),true)
+LIBART_COMMON_SRC_FILES += \
+	src/compiler_llvm/compiler_llvm.cc \
+	src/compiler_llvm/frontend.cc \
+	src/compiler_llvm/ir_builder.cc \
+	src/compiler_llvm/method_compiler.cc
+else
+LIBART_COMMON_SRC_FILES += \
+	src/compiler/Dataflow.cc \
+	src/compiler/Frontend.cc \
+	src/compiler/IntermediateRep.cc \
+	src/compiler/Ralloc.cc \
+	src/compiler/SSATransformation.cc \
+	src/compiler/Utility.cc \
+	src/compiler/codegen/RallocUtil.cc \
+	src/compiler/codegen/arm/ArchUtility.cc \
+	src/compiler/codegen/arm/ArmRallocUtil.cc \
+	src/compiler/codegen/arm/Assemble.cc \
+	src/compiler/codegen/arm/LocalOptimizations.cc \
+	src/compiler/codegen/arm/armv7-a/Codegen.cc
+endif
+
 LIBART_TARGET_SRC_FILES := \
 	$(LIBART_COMMON_SRC_FILES) \
 	src/jdwp/jdwp_adb.cc \
diff --git a/build/Android.libart.mk b/build/Android.libart.mk
index 872c6d3..d7ebefe 100644
--- a/build/Android.libart.mk
+++ b/build/Android.libart.mk
@@ -43,6 +43,8 @@
   endif
 
   LOCAL_MODULE_TAGS := optional
+  LOCAL_MODULE_CLASS := SHARED_LIBRARIES
+
   ifeq ($$(art_target_or_host),target)
     LOCAL_SRC_FILES := $(LIBART_TARGET_SRC_FILES)
   else # host
@@ -68,6 +70,9 @@
     endif
   endif
   LOCAL_C_INCLUDES += $(ART_C_INCLUDES)
+  ifeq ($(ART_USE_LLVM_COMPILER),true)
+    LOCAL_STATIC_LIBRARIES += libLLVMBitWriter libLLVMCore libLLVMSupport
+  endif
   LOCAL_SHARED_LIBRARIES := liblog libnativehelper
   ifeq ($$(art_target_or_host),target)
     LOCAL_SHARED_LIBRARIES += libcutils libstlport libz libdl libdynamic_annotations
@@ -81,8 +86,17 @@
   endif
   LOCAL_STATIC_LIBRARIES += libdex
   ifeq ($$(art_target_or_host),target)
+    ifeq ($(ART_USE_LLVM_COMPILER),true)
+      include $(LLVM_GEN_INTRINSICS_MK)
+      include $(LLVM_DEVICE_BUILD_MK)
+    endif
     include $(BUILD_SHARED_LIBRARY)
   else # host
+    LOCAL_IS_HOST_MODULE := true
+    ifeq ($(ART_USE_LLVM_COMPILER),true)
+      include $(LLVM_GEN_INTRINSICS_MK)
+      include $(LLVM_HOST_BUILD_MK)
+    endif
     include $(BUILD_HOST_SHARED_LIBRARY)
   endif
 endef
diff --git a/src/compiled_method.cc b/src/compiled_method.cc
index eb79e0e..7c7460c 100644
--- a/src/compiled_method.cc
+++ b/src/compiled_method.cc
@@ -18,6 +18,13 @@
 
 namespace art {
 
+#if defined(ART_USE_LLVM_COMPILER)
+CompiledMethod::CompiledMethod(art::InstructionSet instruction_set,
+                               llvm::Function *func)
+    : instruction_set_(instruction_set), func_(func), frame_size_in_bytes_(0),
+      core_spill_mask_(0), fp_spill_mask_(0) {
+}
+#else
 CompiledMethod::CompiledMethod(InstructionSet instruction_set,
                                const std::vector<uint16_t>& short_code,
                                const size_t frame_size_in_bytes,
@@ -56,13 +63,16 @@
 
   DCHECK_EQ(vmap_table_[0], static_cast<uint32_t>(__builtin_popcount(core_spill_mask) + __builtin_popcount(fp_spill_mask)));
 }
+#endif
 
 void CompiledMethod::SetGcMap(const std::vector<uint8_t>& gc_map) {
   CHECK_NE(gc_map.size(), 0U);
 
+#if !defined(ART_USE_LLVM_COMPILER)
   // Should only be used with CompiledMethods created with oatCompileMethod
   CHECK_NE(mapping_table_.size(), 0U);
   CHECK_NE(vmap_table_.size(), 0U);
+#endif
 
   gc_map_ = gc_map;
 }
diff --git a/src/compiled_method.h b/src/compiled_method.h
index 15211e7..834ead0 100644
--- a/src/compiled_method.h
+++ b/src/compiled_method.h
@@ -22,10 +22,19 @@
 #include "constants.h"
 #include "utils.h"
 
+namespace llvm {
+  class Function;
+}
+
 namespace art {
 
 class CompiledMethod {
  public:
+#if defined(ART_USE_LLVM_COMPILER)
+  // Create a CompiledMethod from the oatCompileMethod
+  CompiledMethod(InstructionSet instruction_set,
+                 llvm::Function* func);
+#else
   // Create a CompiledMethod from the oatCompileMethod
   CompiledMethod(InstructionSet instruction_set,
                  const std::vector<uint16_t>& code,
@@ -34,6 +43,7 @@
                  const uint32_t fp_spill_mask,
                  const std::vector<uint32_t>& mapping_table,
                  const std::vector<uint16_t>& vmap_table);
+#endif
 
   // Add a GC map to a CompiledMethod created by oatCompileMethod
   void SetGcMap(const std::vector<uint8_t>& gc_map);
@@ -74,6 +84,9 @@
 
  private:
   const InstructionSet instruction_set_;
+#if defined(ART_USE_LLVM_COMPILER)
+  llvm::Function* func_;
+#endif
   std::vector<uint8_t> code_;
   const size_t frame_size_in_bytes_;
   const uint32_t core_spill_mask_;
diff --git a/src/compiler.cc b/src/compiler.cc
index b1a7066..35108bb 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -34,12 +34,18 @@
 #include "stl_util.h"
 #include "timing_logger.h"
 
+#if defined(ART_USE_LLVM_COMPILER)
+#include "compiler_llvm/compiler_llvm.h"
+#endif
+
 namespace art {
 
+#if !defined(ART_USE_LLVM_COMPILER)
 CompiledMethod* oatCompileMethod(Compiler& compiler, const DexFile::CodeItem* code_item,
                                  uint32_t access_flags, uint32_t method_idx,
                                  const ClassLoader* class_loader,
                                  const DexFile& dex_file, InstructionSet);
+#endif
 
 namespace arm {
   ByteArray* CreateAbstractMethodErrorStub();
@@ -172,7 +178,12 @@
       compiled_invoke_stubs_lock_("compiled invoke stubs lock"),
       image_(image),
       thread_count_(thread_count),
-      image_classes_(image_classes) {
+      image_classes_(image_classes)
+#if defined(ART_USE_LLVM_COMPILER)
+      ,
+      compiler_llvm_(new compiler_llvm::CompilerLLVM(this, instruction_set))
+#endif
+      {
   CHECK(!Runtime::Current()->IsStarted());
   if (!image_) {
     CHECK(image_classes_ == NULL);
@@ -293,6 +304,9 @@
 void Compiler::PostCompile(const ClassLoader* class_loader,
                            const std::vector<const DexFile*>& dex_files) {
   SetGcMaps(class_loader, dex_files);
+#if defined(ART_USE_LLVM_COMPILER)
+  compiler_llvm_->MaterializeLLVMModule();
+#endif
   SetCodeAndDirectMethods(dex_files);
 }
 
@@ -914,8 +928,14 @@
     CHECK(compiled_method != NULL);
   } else if ((access_flags & kAccAbstract) != 0) {
   } else {
+#if defined(ART_USE_LLVM_COMPILER)
+    compiled_method =
+      compiler_llvm_->CompileDexMethod(code_item, access_flags, method_idx,
+                                       class_loader, dex_file);
+#else
     compiled_method = oatCompileMethod(*this, code_item, access_flags, method_idx, class_loader,
                                        dex_file, kThumb2);
+#endif
     CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
   }
   uint64_t duration_ns = NanoTime() - start_ns;
diff --git a/src/compiler.h b/src/compiler.h
index 1c71330..186d433 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -31,6 +31,10 @@
 #include "object.h"
 #include "runtime.h"
 
+#if defined(ART_USE_LLVM_COMPILER)
+#include "compiler_llvm/compiler_llvm.h"
+#endif
+
 namespace art {
 
 class Context;
@@ -176,6 +180,12 @@
   bool ComputeInvokeInfo(uint32_t method_idx, CompilationUnit* cUnit, bool is_interface,
                          bool is_super, int& vtable_idx);
 
+#if defined(ART_USE_LLVM_COMPILER)
+  compiler_llvm::CompilerLLVM* GetCompilerLLVM() const {
+    return compiler_llvm_.get();
+  }
+#endif
+
  private:
 
   // Checks if class specified by type_idx is one of the image_classes_
@@ -244,6 +254,11 @@
 
   const std::set<std::string>* image_classes_;
 
+
+#if defined(ART_USE_LLVM_COMPILER)
+  UniquePtr<compiler_llvm::CompilerLLVM> compiler_llvm_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(Compiler);
 };
 
diff --git a/src/compiler_llvm/backend_types.h b/src/compiler_llvm/backend_types.h
new file mode 100644
index 0000000..86b0ea2
--- /dev/null
+++ b/src/compiler_llvm/backend_types.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_COMPILER_LLVM_BACKEND_TYPES_H_
+#define ART_SRC_COMPILER_LLVM_BACKEND_TYPES_H_
+
+#include "logging.h"
+
+
+namespace art {
+namespace compiler_llvm {
+
+
+enum JType {
+  kVoid,
+  kBoolean,
+  kByte,
+  kChar,
+  kShort,
+  kInt,
+  kLong,
+  kFloat,
+  kDouble,
+  kObject,
+};
+
+
+enum JTypeSpace {
+  kAccurate,
+  kReg,
+  kField,
+  kArray,
+};
+
+
+enum RegCategory {
+  kRegUnknown,
+  kRegZero,
+  kRegCat1nr,
+  kRegCat2,
+  kRegObject,
+};
+
+
+inline JType GetJTypeFromShorty(char shorty_jty) {
+  switch (shorty_jty) {
+  case 'V':
+    return kVoid;
+
+  case 'Z':
+    return kBoolean;
+
+  case 'B':
+    return kByte;
+
+  case 'C':
+    return kChar;
+
+  case 'S':
+    return kShort;
+
+  case 'I':
+    return kInt;
+
+  case 'J':
+    return kLong;
+
+  case 'F':
+    return kFloat;
+
+  case 'D':
+    return kDouble;
+
+  case 'L':
+    return kObject;
+
+  default:
+    LOG(FATAL) << "Unknown Dalvik shorty descriptor: " << shorty_jty;
+    return kVoid;
+  }
+}
+
+
+inline RegCategory GetRegCategoryFromJType(JType jty) {
+  switch (jty) {
+  case kVoid:
+    return kRegUnknown;
+
+  case kBoolean:
+  case kByte:
+  case kChar:
+  case kShort:
+  case kInt:
+  case kFloat:
+    return kRegCat1nr;
+
+  case kLong:
+  case kDouble:
+    return kRegCat2;
+
+  case kObject:
+    return kRegObject;
+  }
+
+  LOG(FATAL) << "Uknown java type: " << jty;
+  return kRegUnknown;
+}
+
+
+inline RegCategory GetRegCategoryFromShorty(char shorty) {
+  return GetRegCategoryFromJType(GetJTypeFromShorty(shorty));
+}
+
+
+} // namespace compiler_llvm
+} // namespace art
+
+
+#endif // ART_SRC_COMPILER_LLVM_BACKEND_TYPES_H_
diff --git a/src/compiler_llvm/compiler_llvm.cc b/src/compiler_llvm/compiler_llvm.cc
new file mode 100644
index 0000000..c0f5881
--- /dev/null
+++ b/src/compiler_llvm/compiler_llvm.cc
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compiler_llvm.h"
+
+#include "compiler.h"
+#include "ir_builder.h"
+#include "method_compiler.h"
+
+#include <llvm/ADT/OwningPtr.h>
+#include <llvm/Bitcode/ReaderWriter.h>
+#include <llvm/DerivedTypes.h>
+#include <llvm/LLVMContext.h>
+#include <llvm/Module.h>
+#include <llvm/Support/ToolOutputFile.h>
+
+using namespace art;
+using namespace art::compiler_llvm;
+
+
+CompilerLLVM::CompilerLLVM(Compiler* compiler, InstructionSet insn_set)
+: compiler_(compiler), compiler_lock_("llvm_compiler_lock"),
+  insn_set_(insn_set), context_(new llvm::LLVMContext()) {
+
+  // Create the module and include the runtime function declaration
+  module_ = new llvm::Module("art", *context_);
+
+  // Create IRBuilder
+  irb_.reset(new IRBuilder(*context_, *module_));
+}
+
+
+CompilerLLVM::~CompilerLLVM() {
+}
+
+
+void CompilerLLVM::MaterializeLLVMModule() {
+#if !defined(NDEBUG)
+  // TODO: For device, need to use another temporary path.
+  WriteBitcodeToFile("/tmp/art_llvm_module.bc");
+#endif
+}
+
+
+void CompilerLLVM::WriteBitcodeToFile(std::string const &filepath) {
+  std::string error_msg;
+
+  // Write the translated bitcode
+  llvm::OwningPtr<llvm::tool_output_file>
+    out(new llvm::tool_output_file(filepath.c_str(), error_msg,
+                                   llvm::raw_fd_ostream::F_Binary));
+
+  if (!error_msg.empty()) {
+    LOG(FATAL) << "Unable to open file: " << error_msg;
+    return;
+  }
+
+  llvm::WriteBitcodeToFile(module_, out->os());
+  out->keep();
+
+  LOG(DEBUG) << "Bitcode Written At: " << filepath;
+}
+
+
+CompiledMethod*
+CompilerLLVM::CompileDexMethod(DexFile::CodeItem const* code_item,
+                               uint32_t access_flags,
+                               uint32_t method_idx,
+                               ClassLoader const* class_loader,
+                               DexFile const& dex_file) {
+
+  MutexLock GUARD(compiler_lock_);
+
+  ClassLinker *class_linker = Runtime::Current()->GetClassLinker();
+  DexCache *dex_cache = class_linker->FindDexCache(dex_file);
+
+  UniquePtr<MethodCompiler> method_compiler(
+    new MethodCompiler(insn_set_, compiler_, class_linker, class_loader,
+                       &dex_file, dex_cache, code_item, method_idx,
+                       access_flags));
+
+  return method_compiler->Compile();
+}
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
new file mode 100644
index 0000000..74f8ba1
--- /dev/null
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_COMPILER_LLVM_LLVM_COMPILER_H_
+#define ART_SRC_COMPILER_LLVM_LLVM_COMPILER_H_
+
+#include "constants.h"
+#include "dex_file.h"
+#include "macros.h"
+
+#include <UniquePtr.h>
+
+#include <string>
+
+namespace art {
+  class ClassLoader;
+  class CompiledMethod;
+  class Compiler;
+  class Mutex;
+}
+
+
+namespace llvm {
+  class Function;
+  class LLVMContext;
+  class Module;
+  class PointerType;
+  class StructType;
+  class Type;
+}
+
+
+namespace art {
+namespace compiler_llvm {
+
+class IRBuilder;
+
+class CompilerLLVM {
+ public:
+  CompilerLLVM(Compiler* compiler, InstructionSet insn_set);
+
+  ~CompilerLLVM();
+
+  void MaterializeLLVMModule();
+
+  void WriteBitcodeToFile(std::string const &filename);
+
+  Compiler* GetCompiler() const {
+    return compiler_;
+  }
+
+  InstructionSet GetInstructionSet() const {
+    return insn_set_;
+  }
+
+  llvm::Module* GetModule() const {
+    return module_;
+  }
+
+  llvm::LLVMContext* GetLLVMContext() const {
+    return context_.get();
+  }
+
+  IRBuilder* GetIRBuilder() const {
+    return irb_.get();
+  }
+
+  CompiledMethod* CompileDexMethod(DexFile::CodeItem const* code_item,
+                                   uint32_t access_flags,
+                                   uint32_t method_idx,
+                                   ClassLoader const* class_loader,
+                                   DexFile const& dex_file);
+
+ private:
+  Compiler* compiler_;
+
+  Mutex compiler_lock_;
+
+  InstructionSet insn_set_;
+
+  UniquePtr<llvm::LLVMContext> context_;
+
+  UniquePtr<IRBuilder> irb_;
+
+  llvm::Module* module_;
+
+  DISALLOW_COPY_AND_ASSIGN(CompilerLLVM);
+};
+
+
+} // namespace compiler_llvm
+} // namespace art
+
+#endif // ART_SRC_COMPILER_LLVM_LLVM_COMPILER_H_
diff --git a/src/compiler_llvm/frontend.cc b/src/compiler_llvm/frontend.cc
new file mode 100644
index 0000000..d2a4ad4
--- /dev/null
+++ b/src/compiler_llvm/frontend.cc
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "method_compiler.h"
+
+#include "class_linker.h"
+#include "class_loader.h"
+#include "compiler.h"
+#include "constants.h"
+#include "dex_file.h"
+#include "runtime.h"
+
+#include <UniquePtr.h>
+#include <stdint.h>
+
+using namespace art::compiler_llvm;
+
+namespace art {
+
+int oatVRegOffset(const art::DexFile::CodeItem* code_item,
+                  uint32_t core_spills, uint32_t fp_spills,
+                  size_t frame_size, int reg) {
+  UNIMPLEMENTED(FATAL);
+  return 0;
+}
+
+} // namespace art
diff --git a/src/compiler_llvm/ir_builder.cc b/src/compiler_llvm/ir_builder.cc
new file mode 100644
index 0000000..ea773bd
--- /dev/null
+++ b/src/compiler_llvm/ir_builder.cc
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ir_builder.h"
+
+#include <llvm/Module.h>
+
+using namespace art::compiler_llvm;
+
+
+//----------------------------------------------------------------------------
+// General
+//----------------------------------------------------------------------------
+
+IRBuilder::IRBuilder(llvm::LLVMContext& context, llvm::Module& module)
+: LLVMIRBuilder(context) {
+
+  // Get java object type from module
+  llvm::Type* jobject_struct_type =
+    llvm::StructType::create(context, "JavaObject");
+  jobject_type_ = jobject_struct_type->getPointerTo();
+}
+
+
+//----------------------------------------------------------------------------
+// Type Helper Function
+//----------------------------------------------------------------------------
+
+llvm::Type* IRBuilder::getJTypeInAccurateSpace(JType jty) {
+  switch (jty) {
+  case kVoid:
+    return getJVoidTy();
+
+  case kBoolean:
+    return getJBooleanTy();
+
+  case kByte:
+    return getJByteTy();
+
+  case kChar:
+    return getJCharTy();
+
+  case kShort:
+    return getJShortTy();
+
+  case kInt:
+    return getJIntTy();
+
+  case kLong:
+    return getJLongTy();
+
+  case kFloat:
+    return getJFloatTy();
+
+  case kDouble:
+    return getJDoubleTy();
+
+  case kObject:
+    return getJObjectTy();
+  }
+
+  LOG(FATAL) << "Unknown java type: " << jty;
+  return NULL;
+}
+
+
+llvm::Type* IRBuilder::getJTypeInRegSpace(JType jty) {
+  switch (GetRegCategoryFromJType(jty)) {
+  case kRegUnknown:
+  case kRegZero:
+    return NULL;
+
+  case kRegCat1nr:
+    return getInt32Ty();
+
+  case kRegCat2:
+    return getInt64Ty();
+
+  case kRegObject:
+    return getJObjectTy();
+  }
+
+  return NULL;
+}
+
+
+llvm::Type* IRBuilder::getJTypeInArraySpace(JType jty) {
+  switch (jty) {
+  case kVoid:
+    return NULL;
+
+  case kBoolean:
+  case kByte:
+    return getInt8Ty();
+
+  case kChar:
+  case kShort:
+    return getInt16Ty();
+
+  case kInt:
+    return getInt32Ty();
+
+  case kLong:
+    return getInt64Ty();
+
+  case kFloat:
+    return getFloatTy();
+
+  case kDouble:
+    return getDoubleTy();
+
+  case kObject:
+    return getJObjectTy();
+  }
+
+  return NULL;
+}
diff --git a/src/compiler_llvm/ir_builder.h b/src/compiler_llvm/ir_builder.h
new file mode 100644
index 0000000..03ca2d7
--- /dev/null
+++ b/src/compiler_llvm/ir_builder.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_COMPILER_LLVM_IR_BUILDER_H_
+#define ART_SRC_COMPILER_LLVM_IR_BUILDER_H_
+
+#include "backend_types.h"
+
+#include <llvm/Constants.h>
+#include <llvm/DerivedTypes.h>
+#include <llvm/Support/IRBuilder.h>
+#include <llvm/Type.h>
+
+#include <stdint.h>
+
+
+namespace art {
+namespace compiler_llvm {
+
+
+typedef llvm::IRBuilder<> LLVMIRBuilder;
+// NOTE: Here we define our own LLVMIRBuilder type alias, so that we can
+// switch "preserveNames" template parameter easily.
+
+
+class IRBuilder : public LLVMIRBuilder {
+ public:
+  //--------------------------------------------------------------------------
+  // General
+  //--------------------------------------------------------------------------
+
+  IRBuilder(llvm::LLVMContext& context, llvm::Module& module);
+
+
+  //--------------------------------------------------------------------------
+  // Type Helper Function
+  //--------------------------------------------------------------------------
+
+  llvm::Type* getJType(char shorty_jty, JTypeSpace space) {
+    return getJType(GetJTypeFromShorty(shorty_jty), space);
+  }
+
+  llvm::Type* getJType(JType jty, JTypeSpace space) {
+    switch (space) {
+    case kAccurate:
+      return getJTypeInAccurateSpace(jty);
+
+    case kReg:
+    case kField: // Currently field space is equivalent to register space.
+      return getJTypeInRegSpace(jty);
+
+    case kArray:
+      return getJTypeInArraySpace(jty);
+    }
+
+    return NULL;
+  }
+
+  llvm::Type* getJVoidTy() {
+    return getVoidTy();
+  }
+
+  llvm::IntegerType* getJBooleanTy() {
+    return getInt1Ty();
+  }
+
+  llvm::IntegerType* getJByteTy() {
+    return getInt8Ty();
+  }
+
+  llvm::IntegerType* getJCharTy() {
+    return getInt16Ty();
+  }
+
+  llvm::IntegerType* getJShortTy() {
+    return getInt16Ty();
+  }
+
+  llvm::IntegerType* getJIntTy() {
+    return getInt32Ty();
+  }
+
+  llvm::IntegerType* getJLongTy() {
+    return getInt64Ty();
+  }
+
+  llvm::Type* getJFloatTy() {
+    return getFloatTy();
+  }
+
+  llvm::Type* getJDoubleTy() {
+    return getDoubleTy();
+  }
+
+  llvm::PointerType* getJObjectTy() {
+    return jobject_type_;
+  }
+
+
+  //--------------------------------------------------------------------------
+  // Constant Value Helper Function
+  //--------------------------------------------------------------------------
+
+  llvm::ConstantInt* getJBoolean(bool is_true) {
+    return (is_true) ? getTrue() : getFalse();
+  }
+
+  llvm::ConstantInt* getJByte(int8_t i) {
+    return llvm::ConstantInt::getSigned(getJByteTy(), i);
+  }
+
+  llvm::ConstantInt* getJChar(int16_t i) {
+    return llvm::ConstantInt::getSigned(getJCharTy(), i);
+  }
+
+  llvm::ConstantInt* getJShort(int16_t i) {
+    return llvm::ConstantInt::getSigned(getJShortTy(), i);
+  }
+
+  llvm::ConstantInt* getJInt(int32_t i) {
+    return llvm::ConstantInt::getSigned(getJIntTy(), i);
+  }
+
+  llvm::ConstantInt* getJLong(int64_t i) {
+    return llvm::ConstantInt::getSigned(getJLongTy(), i);
+  }
+
+  llvm::Constant* getJFloat(float f) {
+    return llvm::ConstantFP::get(getJFloatTy(), f);
+  }
+
+  llvm::Constant* getJDouble(double d) {
+    return llvm::ConstantFP::get(getJDoubleTy(), d);
+  }
+
+  llvm::ConstantPointerNull* getJNull() {
+    return llvm::ConstantPointerNull::get(getJObjectTy());
+  }
+
+  llvm::Constant* getJZero(char shorty_jty) {
+    return getJZero(GetJTypeFromShorty(shorty_jty));
+  }
+
+  llvm::Constant* getJZero(JType jty) {
+    switch (jty) {
+    case kVoid:
+      return NULL;
+
+    case kBoolean:
+      return getJBoolean(false);
+
+    case kByte:
+      return getJByte(0);
+
+    case kChar:
+      return getJChar(0);
+
+    case kShort:
+      return getJShort(0);
+
+    case kInt:
+      return getJInt(0);
+
+    case kLong:
+      return getJLong(0);
+
+    case kFloat:
+      return getJFloat(0.0f);
+
+    case kDouble:
+      return getJDouble(0.0);
+
+    case kObject:
+      return getJNull();
+    }
+
+    LOG(FATAL) << "Unknown java type: " << jty;
+    return NULL;
+  }
+
+
+ private:
+  //--------------------------------------------------------------------------
+  // Type Helper Function (Private)
+  //--------------------------------------------------------------------------
+
+  llvm::Type* getJTypeInAccurateSpace(JType jty);
+  llvm::Type* getJTypeInRegSpace(JType jty);
+  llvm::Type* getJTypeInArraySpace(JType jty);
+
+
+ private:
+  llvm::PointerType* jobject_type_;
+
+};
+
+
+} // namespace compiler_llvm
+} // namespace art
+
+#endif // ART_SRC_COMPILER_LLVM_IR_BUILDER_H_
diff --git a/src/compiler_llvm/libdex.h b/src/compiler_llvm/libdex.h
new file mode 100644
index 0000000..40668fc
--- /dev/null
+++ b/src/compiler_llvm/libdex.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_COMPILER_LLVM_LIBDEX_H_
+#define ART_SRC_COMPILER_LLVM_LIBDEX_H_
+
+#include <assert.h>
+
+// From Common.h
+// TODO: remove all these and just use the long names
+typedef uint8_t             u1;
+typedef uint16_t            u2;
+typedef uint32_t            u4;
+typedef uint64_t            u8;
+typedef int8_t              s1;
+typedef int16_t             s2;
+typedef int32_t             s4;
+typedef int64_t             s8;
+typedef unsigned long long  u8;
+
+// Skip old DexFile.h
+#define LIBDEX_DEXFILE_H_
+
+// Skip old vm/Common.h
+#define DALVIK_COMMON_H_
+
+// Make inlines inline
+#define DEX_INLINE inline
+#include "DexOpcodes.h"
+#include "InstrUtils.h"
+
+
+#endif // ART_SRC_COMPILER_LLVM_LIBDEX_H_
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
new file mode 100644
index 0000000..4aec8b1
--- /dev/null
+++ b/src/compiler_llvm/method_compiler.cc
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "method_compiler.h"
+
+#include "compiler.h"
+#include "ir_builder.h"
+#include "logging.h"
+#include "object.h"
+#include "object_utils.h"
+#include "stl_util.h"
+
+#include <iomanip>
+
+#include <llvm/Analysis/Verifier.h>
+#include <llvm/Function.h>
+
+using namespace art::compiler_llvm;
+
+
+MethodCompiler::MethodCompiler(art::InstructionSet insn_set,
+                               art::Compiler const* compiler,
+                               art::ClassLinker* class_linker,
+                               art::ClassLoader const* class_loader,
+                               art::DexFile const* dex_file,
+                               art::DexCache* dex_cache,
+                               art::DexFile::CodeItem const* code_item,
+                               uint32_t method_idx,
+                               uint32_t access_flags)
+: insn_set_(insn_set),
+  compiler_(compiler), compiler_llvm_(compiler->GetCompilerLLVM()),
+  class_linker_(class_linker), class_loader_(class_loader),
+  dex_file_(dex_file), dex_cache_(dex_cache), code_item_(code_item),
+  method_(dex_cache->GetResolvedMethod(method_idx)),
+  method_helper_(method_), method_idx_(method_idx),
+  access_flags_(access_flags), module_(compiler_llvm_->GetModule()),
+  context_(compiler_llvm_->GetLLVMContext()),
+  irb_(*compiler_llvm_->GetIRBuilder()), func_(NULL) {
+}
+
+
+MethodCompiler::~MethodCompiler() {
+}
+
+
+void MethodCompiler::EmitPrologue() {
+  // TODO: Not implemented!
+}
+
+
+void MethodCompiler::EmitEpilogue() {
+}
+
+
+void MethodCompiler::EmitInstruction(uint32_t addr,
+                                     art::Instruction const* insn) {
+  // TODO: Not implemented!
+}
+
+
+art::CompiledMethod *MethodCompiler::Compile() {
+  // TODO: Not implemented!
+  return new art::CompiledMethod(insn_set_, NULL);
+}
diff --git a/src/compiler_llvm/method_compiler.h b/src/compiler_llvm/method_compiler.h
new file mode 100644
index 0000000..2d9f91c
--- /dev/null
+++ b/src/compiler_llvm/method_compiler.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_COMPILER_LLVM_METHOD_COMPILER_H_
+#define ART_SRC_COMPILER_LLVM_METHOD_COMPILER_H_
+
+#include "constants.h"
+#include "dex_file.h"
+#include "dex_instruction.h"
+#include "object_utils.h"
+
+#include <llvm/Support/IRBuilder.h>
+
+#include <vector>
+
+#include <stdint.h>
+
+
+namespace art {
+  class ClassLinker;
+  class ClassLoader;
+  class CompiledMethod;
+  class Compiler;
+  class DexCache;
+}
+
+
+namespace llvm {
+  class AllocaInst;
+  class BasicBlock;
+  class Function;
+  class FunctionType;
+  class LLVMContext;
+  class Module;
+  class Type;
+}
+
+
+namespace art {
+namespace compiler_llvm {
+
+class CompilerLLVM;
+class IRBuilder;
+
+class MethodCompiler {
+ private:
+  art::InstructionSet insn_set_;
+  art::Compiler const* compiler_;
+  art::compiler_llvm::CompilerLLVM* compiler_llvm_;
+
+  art::ClassLinker* class_linker_;
+  art::ClassLoader const* class_loader_;
+
+  art::DexFile const* dex_file_;
+  art::DexCache* dex_cache_;
+  art::DexFile::CodeItem const* code_item_;
+
+  art::Method* method_;
+  art::MethodHelper method_helper_;
+
+  uint32_t method_idx_;
+  uint32_t access_flags_;
+
+  llvm::Module* module_;
+  llvm::LLVMContext* context_;
+  IRBuilder& irb_;
+  llvm::Function* func_;
+
+ public:
+  MethodCompiler(art::InstructionSet insn_set,
+                 art::Compiler const* compiler,
+                 art::ClassLinker* class_linker,
+                 art::ClassLoader const* class_loader,
+                 art::DexFile const* dex_file,
+                 art::DexCache* dex_cache,
+                 art::DexFile::CodeItem const* code_item,
+                 uint32_t method_idx,
+                 uint32_t access_flags);
+
+  ~MethodCompiler();
+
+  art::CompiledMethod* Compile();
+
+ private:
+  void CreateFunction();
+
+  void EmitPrologue();
+  void EmitInstructions();
+  void EmitInstruction(uint32_t addr, art::Instruction const* insn);
+  void EmitEpilogue();
+
+};
+
+
+} // namespace compiler_llvm
+} // namespace art
+
+#endif // ART_SRC_COMPILER_LLVM_METHOD_COMPILER_H_