diff --git a/src/class_linker.cc b/src/class_linker.cc
index 5ff2293..20e6514 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1799,26 +1799,105 @@
 }
 
 void ClassLinker::VerifyClass(Class* klass) {
+  // TODO: assert that the monitor on the Class is held
   if (klass->IsVerified()) {
     return;
   }
 
-  CHECK_EQ(klass->GetStatus(), Class::kStatusResolved);
+  CHECK_EQ(klass->GetStatus(), Class::kStatusResolved) << PrettyClass(klass);
   klass->SetStatus(Class::kStatusVerifying);
 
-  if (verifier::DexVerifier::VerifyClass(klass)) {
+  // Try to use verification information from oat file, otherwise do runtime verification
+  const DexFile& dex_file = FindDexFile(klass->GetDexCache());
+  if (VerifyClassUsingOatFile(dex_file, klass) || verifier::DexVerifier::VerifyClass(klass)) {
+    // Make sure all classes referenced by catch blocks are resolved
+    ResolveClassExceptionHandlerTypes(dex_file, klass);
     klass->SetStatus(Class::kStatusVerified);
   } else {
     LOG(ERROR) << "Verification failed on class " << PrettyClass(klass);
     Thread* self = Thread::Current();
-    CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+    CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException()) << PrettyClass(klass);
     self->ThrowNewExceptionF("Ljava/lang/VerifyError;", "Verification of %s failed",
         PrettyDescriptor(klass).c_str());
-    CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying);
+    CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyClass(klass);
     klass->SetStatus(Class::kStatusError);
   }
 }
 
+bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass) {
+  if (!Runtime::Current()->IsStarted()) {
+    return false;
+  }
+  if (ClassLoader::UseCompileTimeClassPath()) {
+    return false;
+  }
+  const OatFile* oat_file = FindOatFileForDexFile(dex_file);
+  if (oat_file == NULL) {
+    return false;
+  }
+  const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
+  CHECK(oat_dex_file != NULL) << PrettyClass(klass);
+  const char* descriptor = ClassHelper(klass).GetDescriptor();
+  uint32_t class_def_index;
+  bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
+  CHECK(found) << descriptor;
+  UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
+  CHECK(oat_class.get() != NULL) << descriptor;
+  Class::Status status = oat_class->GetStatus();
+  if (status == Class::kStatusError) {
+    ThrowEarlierClassFailure(klass);
+    klass->SetVerifyErrorClass(Thread::Current()->GetException()->GetClass());
+    klass->SetStatus(Class::kStatusError);
+    return true;
+  }
+  if (status == Class::kStatusVerified || status == Class::kStatusInitialized) {
+    return true;
+  }
+  if (status == Class::kStatusNotReady) {
+    return false;
+  }
+  LOG(FATAL) << "Unexpected class status: " << status;
+  return false;
+}
+
+void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
+  for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
+    ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
+  }
+  for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
+    ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
+  }
+}
+
+void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* method) {
+  // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
+  const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
+  if (code_item == NULL) {
+    return;  // native or abstract method
+  }
+  if (code_item->tries_size_ == 0) {
+    return;  // nothing to process
+  }
+  const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
+  uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
+  ClassLinker* linker = Runtime::Current()->GetClassLinker();
+  for (uint32_t idx = 0; idx < handlers_size; idx++) {
+    CatchHandlerIterator iterator(handlers_ptr);
+    for (; iterator.HasNext(); iterator.Next()) {
+      // Ensure exception types are resolved so that they don't need resolution to be delivered,
+      // unresolved exception types will be ignored by exception delivery
+      if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
+        Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
+        if (exception_type == NULL) {
+          DCHECK(Thread::Current()->IsExceptionPending());
+          Thread::Current()->ClearException();
+        }
+      }
+    }
+    handlers_ptr = iterator.EndDataPointer();
+  }
+}
+
 static void CheckProxyConstructor(Method* constructor);
 static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype);
 
@@ -2025,7 +2104,7 @@
       return false;
     }
 
-    DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified);
+    DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
 
     klass->SetClinitThreadId(self->GetTid());
     klass->SetStatus(Class::kStatusInitializing);
@@ -2211,7 +2290,7 @@
       if (!super_initialized) {
         if (!can_run_clinit) {
          // Don't set status to error when we can't run <clinit>.
-         CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing);
+         CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
          klass->SetStatus(Class::kStatusVerified);
          return false;
         }
diff --git a/src/class_linker.h b/src/class_linker.h
index 45b1aa2..fde4d5f 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -266,6 +266,9 @@
   ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length);
 
   void VerifyClass(Class* klass);
+  bool VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass);
+  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass);
+  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* klass);
 
   Class* CreateProxyClass(String* name, ObjectArray<Class>* interfaces, ClassLoader* loader,
                           ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws);
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 8b0e1a1..f680d2b 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -439,7 +439,6 @@
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_methods_),           "dexCacheResolvedMethods"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_types_),             "dexCacheResolvedTypes"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_strings_),                    "dexCacheStrings"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, gc_map_),                               "gcMap"));
 
     // alphabetical 32-bit
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, access_flags_),        "accessFlags"));
@@ -448,6 +447,7 @@
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, core_spill_mask_),     "coreSpillMask"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, fp_spill_mask_),       "fpSpillMask"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, frame_size_in_bytes_), "frameSizeInBytes"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, gc_map_),              "gcMap"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, invoke_stub_),         "invokeStub"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, mapping_table_),       "mappingTable"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_dex_index_),    "methodDexIndex"));
diff --git a/src/common_test.h b/src/common_test.h
index c89527c..402766f 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -105,6 +105,7 @@
                                      const uint32_t fp_spill_mask,
                                      const uint32_t* mapping_table,
                                      const uint16_t* vmap_table,
+                                     const uint8_t* gc_map,
                                      const Method::InvokeStub* invoke_stub) {
       return OatFile::OatMethod(NULL,
                                 reinterpret_cast<uint32_t>(code),
@@ -113,6 +114,7 @@
                                 fp_spill_mask,
                                 reinterpret_cast<uint32_t>(mapping_table),
                                 reinterpret_cast<uint32_t>(vmap_table),
+                                reinterpret_cast<uint32_t>(gc_map),
                                 reinterpret_cast<uint32_t>(invoke_stub));
   }
 
@@ -148,6 +150,7 @@
                                                       compiled_method->GetFpSpillMask(),
                                                       &compiled_method->GetMappingTable()[0],
                                                       &compiled_method->GetVmapTable()[0],
+                                                      NULL,
                                                       method_invoke_stub);
       oat_method.LinkMethodPointers(method);
     } else {
@@ -160,6 +163,7 @@
                                                       0,
                                                       NULL,
                                                       NULL,
+                                                      NULL,
                                                       method_invoke_stub);
       oat_method.LinkMethodPointers(method);
     }
diff --git a/src/compiled_method.cc b/src/compiled_method.cc
index 67bdd9a..40230b4 100644
--- a/src/compiled_method.cc
+++ b/src/compiled_method.cc
@@ -5,16 +5,17 @@
 namespace art {
 
 CompiledMethod::CompiledMethod(InstructionSet instruction_set,
-                               std::vector<short>& short_code,
+                               const std::vector<uint16_t>& short_code,
                                const size_t frame_size_in_bytes,
                                const uint32_t core_spill_mask,
                                const uint32_t fp_spill_mask,
-                               std::vector<uint32_t>& mapping_table,
-                               std::vector<uint16_t>& vmap_table)
+                               const std::vector<uint32_t>& mapping_table,
+                               const std::vector<uint16_t>& vmap_table)
     : instruction_set_(instruction_set), frame_size_in_bytes_(frame_size_in_bytes),
       core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask) {
   CHECK_NE(short_code.size(), 0U);
   CHECK_GE(vmap_table.size(), 1U);  // should always contain an entry for LR
+  CHECK_LE(vmap_table.size(), (1U << 16) - 1); // length must fit in 2^16-1
 
   size_t code_byte_count = short_code.size() * sizeof(short_code[0]);
   std::vector<uint8_t> byte_code(code_byte_count);
@@ -42,8 +43,33 @@
   DCHECK_EQ(vmap_table_[0], static_cast<uint32_t>(__builtin_popcount(core_spill_mask) + __builtin_popcount(fp_spill_mask)));
 }
 
+void CompiledMethod::SetGcMap(const std::vector<uint8_t>& gc_map) {
+  CHECK_NE(gc_map.size(), 0U);
+
+  // Should only be used with CompiledMethods created with oatCompileMethod
+  CHECK_NE(mapping_table_.size(), 0U);
+  CHECK_NE(vmap_table_.size(), 0U);
+
+  std::vector<uint8_t> length_prefixed_gc_map;
+  length_prefixed_gc_map.push_back((gc_map.size() & 0xff000000) >> 24);
+  length_prefixed_gc_map.push_back((gc_map.size() & 0x00ff0000) >> 16);
+  length_prefixed_gc_map.push_back((gc_map.size() & 0x0000ff00) >> 8);
+  length_prefixed_gc_map.push_back((gc_map.size() & 0x000000ff) >> 0);
+  length_prefixed_gc_map.insert(length_prefixed_gc_map.end(),
+                                gc_map.begin(),
+                                gc_map.end());
+  DCHECK_EQ(gc_map.size() + 4, length_prefixed_gc_map.size());
+  DCHECK_EQ(gc_map.size(),
+            static_cast<size_t>((length_prefixed_gc_map[0] << 24) |
+                                (length_prefixed_gc_map[1] << 16) |
+                                (length_prefixed_gc_map[2] << 8) |
+                                (length_prefixed_gc_map[3] << 0)));
+
+  gc_map_ = length_prefixed_gc_map;
+}
+
 CompiledMethod::CompiledMethod(InstructionSet instruction_set,
-                               std::vector<uint8_t>& code,
+                               const std::vector<uint8_t>& code,
                                const size_t frame_size_in_bytes,
                                const uint32_t core_spill_mask,
                                const uint32_t fp_spill_mask)
@@ -82,6 +108,10 @@
   return vmap_table_;
 }
 
+const std::vector<uint8_t>& CompiledMethod::GetGcMap() const {
+  return gc_map_;
+}
+
 uint32_t CompiledMethod::AlignCode(uint32_t offset) const {
   return AlignCode(offset, instruction_set_);
 }
diff --git a/src/compiled_method.h b/src/compiled_method.h
index 4b5a78b..4528e52 100644
--- a/src/compiled_method.h
+++ b/src/compiled_method.h
@@ -14,16 +14,19 @@
  public:
   // Create a CompiledMethod from the oatCompileMethod
   CompiledMethod(InstructionSet instruction_set,
-                 std::vector<short>& code,
+                 const std::vector<uint16_t>& code,
                  const size_t frame_size_in_bytes,
                  const uint32_t core_spill_mask,
                  const uint32_t fp_spill_mask,
-                 std::vector<uint32_t>& mapping_table,
-                 std::vector<uint16_t>& vmap_table);
+                 const std::vector<uint32_t>& mapping_table,
+                 const std::vector<uint16_t>& vmap_table);
+
+  // Add a GC map to a CompiledMethod created by oatCompileMethod
+  void SetGcMap(const std::vector<uint8_t>& gc_map);
 
   // Create a CompiledMethod from the JniCompiler
   CompiledMethod(InstructionSet instruction_set,
-                 std::vector<uint8_t>& code,
+                 const std::vector<uint8_t>& code,
                  const size_t frame_size_in_bytes,
                  const uint32_t core_spill_mask,
                  const uint32_t fp_spill_mask);
@@ -37,6 +40,8 @@
   uint32_t GetFpSpillMask() const;
   const std::vector<uint32_t>& GetMappingTable() const;
   const std::vector<uint16_t>& GetVmapTable() const;
+  const std::vector<uint8_t>& GetGcMap() const;
+
   // Aligns an offset from a page aligned value to make it suitable
   // for code storage. important to ensure that PC relative value
   // computations work out as expected on ARM.
@@ -61,6 +66,7 @@
   const uint32_t fp_spill_mask_;
   std::vector<uint32_t> mapping_table_;
   std::vector<uint16_t> vmap_table_;
+  std::vector<uint8_t> gc_map_;
 };
 
 class CompiledInvokeStub {
diff --git a/src/compiler.cc b/src/compiler.cc
index 88e156d..d700adb 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -8,6 +8,7 @@
 #include "class_linker.h"
 #include "class_loader.h"
 #include "dex_cache.h"
+#include "dex_verifier.h"
 #include "jni_compiler.h"
 #include "jni_internal.h"
 #include "oat_file.h"
@@ -136,6 +137,7 @@
 
 void Compiler::PostCompile(const ClassLoader* class_loader,
                            const std::vector<const DexFile*>& dex_files) {
+  SetGcMaps(class_loader, dex_files);
   SetCodeAndDirectMethods(dex_files);
 }
 
@@ -481,6 +483,70 @@
   return it->second;
 }
 
+void Compiler::SetGcMaps(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
+    CHECK(dex_file != NULL);
+    SetGcMapsDexFile(class_loader, *dex_file);
+  }
+}
+
+void Compiler::SetGcMapsDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+  for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
+    const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
+    const char* descriptor = dex_file.GetClassDescriptor(class_def);
+    Class* klass = class_linker->FindClass(descriptor, class_loader);
+    if (klass == NULL || !klass->IsVerified()) {
+      Thread::Current()->ClearException();
+      continue;
+    }
+    const byte* class_data = dex_file.GetClassData(class_def);
+    if (class_data == NULL) {
+      // empty class such as a marker interface
+      continue;
+    }
+    ClassDataItemIterator it(dex_file, class_data);
+    while (it.HasNextStaticField()) {
+      it.Next();
+    }
+    while (it.HasNextInstanceField()) {
+      it.Next();
+    }
+    while (it.HasNextDirectMethod()) {
+      Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
+                                                   class_loader, true);
+      SetGcMapsMethod(dex_file, method);
+      it.Next();
+    }
+    while (it.HasNextVirtualMethod()) {
+      Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
+                                                   class_loader, false);
+      SetGcMapsMethod(dex_file, method);
+      it.Next();
+    }
+  }
+}
+
+void Compiler::SetGcMapsMethod(const DexFile& dex_file, Method* method) {
+  if (method == NULL) {
+    Thread::Current()->ClearException();
+    return;
+  }
+  uint16_t method_idx = method->GetDexMethodIndex();
+  MethodReference ref(&dex_file, method_idx);
+  CompiledMethod* compiled_method = GetCompiledMethod(ref);
+  if (compiled_method == NULL) {
+    return;
+  }
+  const std::vector<uint8_t>* gc_map = verifier::DexVerifier::GetGcMap(ref);
+  if (gc_map == NULL) {
+    return;
+  }
+  compiled_method->SetGcMap(*gc_map);
+}
+
 void Compiler::SetCodeAndDirectMethods(const std::vector<const DexFile*>& dex_files) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
diff --git a/src/compiler.h b/src/compiler.h
index f59587f..bf21ed6 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -58,10 +58,36 @@
 
   // A class is uniquely located by its DexFile and the class_defs_ table index into that DexFile
   typedef std::pair<const DexFile*, uint32_t> ClassReference;
+  struct ClassReferenceHash {
+    size_t operator()(const ClassReference& id) const {
+      size_t dex = reinterpret_cast<size_t>(id.first);
+      DCHECK_NE(dex, static_cast<size_t>(0));
+      dex += 33;  // dex is an aligned pointer, get some non-zero low bits
+      size_t idx = id.second;
+      if (idx == 0) {  // special case of a method index of 0
+        return dex * 5381;
+      } else {
+        return dex * idx;
+      }
+    }
+  };
   CompiledClass* GetCompiledClass(ClassReference ref) const;
 
   // A method is uniquely located by its DexFile and the method_ids_ table index into that DexFile
   typedef std::pair<const DexFile*, uint32_t> MethodReference;
+  struct MethodReferenceHash {
+    size_t operator()(const MethodReference& id) const {
+      size_t dex = reinterpret_cast<size_t>(id.first);
+      DCHECK_NE(dex, static_cast<size_t>(0));
+      dex += 33;  // dex is an aligned pointer, get some non-zero low bits
+      size_t idx = id.second;
+      if (idx == 0) {  // special case of a method index of 0
+        return dex * 5381;
+      } else {
+        return dex * idx;
+      }
+    }
+  };
   CompiledMethod* GetCompiledMethod(MethodReference ref) const;
 
   const CompiledInvokeStub* FindInvokeStub(bool is_static, const char* shorty) const;
@@ -116,6 +142,10 @@
   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, uint32_t method_idx,
                      const ClassLoader* class_loader, const DexFile& dex_file);
 
+  void SetGcMaps(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
+  void SetGcMapsDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
+  void SetGcMapsMethod(const DexFile& dex_file, Method* method);
+
   // After compiling, walk all the DexCaches and set the code and
   // method pointers of CodeAndDirectMethods entries in the DexCaches.
   void SetCodeAndDirectMethods(const std::vector<const DexFile*>& dex_files);
@@ -127,36 +157,10 @@
   InstructionSet instruction_set_;
   JniCompiler jni_compiler_;
 
-  struct ClassReferenceHash {
-    size_t operator()(const ClassReference& id) const {
-      size_t dex = reinterpret_cast<size_t>(id.first);
-      DCHECK_NE(dex, static_cast<size_t>(0));
-      dex += 33;  // dex is an aligned pointer, get some non-zero low bits
-      size_t idx = id.second;
-      if (idx == 0) {  // special case of a method index of 0
-        return dex * 5381;
-      } else {
-        return dex * idx;
-      }
-    }
-  };
   typedef std::tr1::unordered_map<const ClassReference, CompiledClass*, ClassReferenceHash> ClassTable;
   // All class references that this compiler has compiled
   ClassTable compiled_classes_;
 
-  struct MethodReferenceHash {
-    size_t operator()(const MethodReference& id) const {
-      size_t dex = reinterpret_cast<size_t>(id.first);
-      DCHECK_NE(dex, static_cast<size_t>(0));
-      dex += 33;  // dex is an aligned pointer, get some non-zero low bits
-      size_t idx = id.second;
-      if (idx == 0) {  // special case of a method index of 0
-        return dex * 5381;
-      } else {
-        return dex * idx;
-      }
-    }
-  };
   typedef std::tr1::unordered_map<const MethodReference, CompiledMethod*, MethodReferenceHash> MethodTable;
   // All method references that this compiler has compiled
   MethodTable compiled_methods_;
diff --git a/src/compiler/CompilerIR.h b/src/compiler/CompilerIR.h
index 49c84c1..2e89ab5 100644
--- a/src/compiler/CompilerIR.h
+++ b/src/compiler/CompilerIR.h
@@ -215,7 +215,7 @@
     int totalSize;                      // header + code size
     AssemblerStatus assemblerStatus;    // Success or fix and retry
     int assemblerRetries;
-    std::vector<short> codeBuffer;
+    std::vector<uint16_t> codeBuffer;
     std::vector<uint32_t> mappingTable;
     std::vector<uint16_t> coreVmapTable;
     std::vector<uint16_t> fpVmapTable;
diff --git a/src/compiler/codegen/arm/Assemble.cc b/src/compiler/codegen/arm/Assemble.cc
index 9a1a30e..a73a27a 100644
--- a/src/compiler/codegen/arm/Assemble.cc
+++ b/src/compiler/codegen/arm/Assemble.cc
@@ -974,12 +974,12 @@
  */
 #define PADDING_MOV_R5_R5               0x1C2D
 
-STATIC void pushWord(std::vector<short>&buf, int data) {
+STATIC void pushWord(std::vector<uint16_t>&buf, int data) {
     buf.push_back( data & 0xffff);
     buf.push_back( (data >> 16) & 0xffff);
 }
 
-void alignBuffer(std::vector<short>&buf, size_t offset) {
+void alignBuffer(std::vector<uint16_t>&buf, size_t offset) {
     while (buf.size() < (offset/2))
         buf.push_back(0);
 }
diff --git a/src/dex_verifier.cc b/src/dex_verifier.cc
index 1172186..00b226d 100644
--- a/src/dex_verifier.cc
+++ b/src/dex_verifier.cc
@@ -5,6 +5,7 @@
 #include <iostream>
 
 #include "class_linker.h"
+#include "compiler.h"
 #include "dex_cache.h"
 #include "dex_file.h"
 #include "dex_instruction.h"
@@ -842,7 +843,7 @@
   return changed;
 }
 
-void RegisterLine::WriteReferenceBitMap(int8_t* data, size_t max_bytes) {
+void RegisterLine::WriteReferenceBitMap(std::vector<uint8_t>& data, size_t max_bytes) {
   for (size_t i = 0; i < num_regs_; i += 8) {
     uint8_t val = 0;
     for (size_t j = 0; j < 8 && (i + j) < num_regs_; j++) {
@@ -851,10 +852,12 @@
         val |= 1 << j;
       }
     }
-    if (val != 0) {
-      DCHECK_LT(i / 8, max_bytes);
-      data[i / 8] = val;
+    if ((i / 8) >= max_bytes) {
+      DCHECK_EQ(0, val);
+      continue;
     }
+    DCHECK_LT(i / 8, max_bytes) << "val=" << static_cast<uint32_t>(val);
+    data.push_back(val);
   }
 }
 
@@ -966,12 +969,18 @@
             << verifier.info_messages_.str() << Dumpable<DexVerifier>(verifier);
 }
 
-DexVerifier::DexVerifier(Method* method) : work_insn_idx_(-1), method_(method),
-                                           failure_(VERIFY_ERROR_NONE),
-
-                                           new_instance_count_(0), monitor_enter_count_(0) {
+DexVerifier::DexVerifier(Method* method)
+    : work_insn_idx_(-1),
+      method_(method),
+      failure_(VERIFY_ERROR_NONE),
+      new_instance_count_(0),
+      monitor_enter_count_(0) {
+  CHECK(method != NULL);
+  Runtime* runtime = Runtime::Current();
+  // We should only be running the verifier at compile time
+  CHECK(!runtime->IsStarted());
   const DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  ClassLinker* class_linker = runtime->GetClassLinker();
   dex_file_ = &class_linker->FindDexFile(dex_cache);
   code_item_ = dex_file_->GetCodeItem(method->GetCodeItemOffset());
 }
@@ -1063,7 +1072,7 @@
       insn_flags_[dex_pc].SetInTry();
     }
   }
-  /* Iterate over each of the handlers to verify target addresses. */
+  // Iterate over each of the handlers to verify target addresses.
   const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item_, 0);
   uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
   ClassLinker* linker = Runtime::Current()->GetClassLinker();
@@ -1517,13 +1526,14 @@
   }
 
   /* Generate a register map and add it to the method. */
-  ByteArray* map = GenerateGcMap();
+  const std::vector<uint8_t>* map = GenerateGcMap();
   if (map == NULL) {
     return false;  // Not a real failure, but a failure to encode
   }
-  method_->SetGcMap(map);
+  Compiler::MethodReference ref(dex_file_, method_->GetDexMethodIndex());
+  verifier::DexVerifier::SetGcMap(ref, *map);
 #ifndef NDEBUG
-  VerifyGcMap();
+  VerifyGcMap(*map);
 #endif
   return true;
 }
@@ -3712,7 +3722,7 @@
   *log2_max_gc_pc = i;
 }
 
-ByteArray* DexVerifier::GenerateGcMap() {
+const std::vector<uint8_t>* DexVerifier::GenerateGcMap() {
   size_t num_entries, ref_bitmap_bits, pc_bits;
   ComputeGcMapSizes(&num_entries, &ref_bitmap_bits, &pc_bits);
   // There's a single byte to encode the size of each bitmap
@@ -3745,39 +3755,35 @@
     return NULL;
   }
   size_t table_size = ((pc_bytes + ref_bitmap_bytes) * num_entries ) + 4;
-  ByteArray* table = ByteArray::Alloc(table_size);
+  std::vector<uint8_t>* table = new std::vector<uint8_t>;
   if (table == NULL) {
     Fail(VERIFY_ERROR_GENERIC) << "Failed to encode GC map (size=" << table_size << ")";
     return NULL;
   }
   // Write table header
-  table->Set(0, format);
-  table->Set(1, ref_bitmap_bytes);
-  table->Set(2, num_entries & 0xFF);
-  table->Set(3, (num_entries >> 8) & 0xFF);
+  table->push_back(format);
+  table->push_back(ref_bitmap_bytes);
+  table->push_back(num_entries & 0xFF);
+  table->push_back((num_entries >> 8) & 0xFF);
   // Write table data
-  size_t offset = 4;
   for (size_t i = 0; i < code_item_->insns_size_in_code_units_; i++) {
     if (insn_flags_[i].IsGcPoint()) {
-      table->Set(offset, i & 0xFF);
-      offset++;
+      table->push_back(i & 0xFF);
       if (pc_bytes == 2) {
-        table->Set(offset, (i >> 8) & 0xFF);
-        offset++;
+        table->push_back((i >> 8) & 0xFF);
       }
       RegisterLine* line = reg_table_.GetLine(i);
-      line->WriteReferenceBitMap(table->GetData() + offset, ref_bitmap_bytes);
-      offset += ref_bitmap_bytes;
+      line->WriteReferenceBitMap(*table, ref_bitmap_bytes);
     }
   }
-  DCHECK(offset == table_size);
+  DCHECK_EQ(table->size(), table_size);
   return table;
 }
 
-void DexVerifier::VerifyGcMap() {
+void DexVerifier::VerifyGcMap(const std::vector<uint8_t>& data) {
   // Check that for every GC point there is a map entry, there aren't entries for non-GC points,
   // that the table data is well formed and all references are marked (or not) in the bitmap
-  PcToReferenceMap map(method_);
+  PcToReferenceMap map(&data[0], data.size());
   size_t map_index = 0;
   for(size_t i = 0; i < code_item_->insns_size_in_code_units_; i++) {
     const uint8_t* reg_bitmap = map.FindBitMap(i, false);
@@ -3834,5 +3840,26 @@
   return NULL;
 }
 
+DexVerifier::GcMapTable DexVerifier::gc_maps_;
+
+void DexVerifier::SetGcMap(Compiler::MethodReference ref, const std::vector<uint8_t>& gc_map) {
+  CHECK(GetGcMap(ref) == NULL);
+  gc_maps_[ref] = &gc_map;
+  CHECK(GetGcMap(ref) != NULL);
+}
+
+const std::vector<uint8_t>* DexVerifier::GetGcMap(Compiler::MethodReference ref) {
+  GcMapTable::const_iterator it = gc_maps_.find(ref);
+  if (it == gc_maps_.end()) {
+    return NULL;
+  }
+  CHECK(it->second != NULL);
+  return it->second;
+}
+
+void DexVerifier::DeleteGcMaps() {
+  STLDeleteValues(&gc_maps_);
+}
+
 }  // namespace verifier
 }  // namespace art
diff --git a/src/dex_verifier.h b/src/dex_verifier.h
index a0819e6..263dcae 100644
--- a/src/dex_verifier.h
+++ b/src/dex_verifier.h
@@ -4,11 +4,13 @@
 #define ART_SRC_DEX_VERIFY_H_
 
 #include "casts.h"
+#include "compiler.h"
 #include "dex_file.h"
 #include "dex_instruction.h"
 #include "macros.h"
 #include "object.h"
 #include "stl_util.h"
+#include "unordered_map.h"
 #include "UniquePtr.h"
 
 #include <deque>
@@ -17,6 +19,7 @@
 #include <vector>
 
 namespace art {
+
 namespace verifier {
 
 class DexVerifier;
@@ -702,7 +705,7 @@
   }
 
   // Write a bit at each register location that holds a reference
-  void WriteReferenceBitMap(int8_t* data, size_t max_bytes);
+  void WriteReferenceBitMap(std::vector<uint8_t>& data, size_t max_bytes);
  private:
 
   void CopyRegToLockDepth(size_t dst, size_t src) {
@@ -864,6 +867,9 @@
   // information
   void Dump(std::ostream& os);
 
+  static const std::vector<uint8_t>* GetGcMap(Compiler::MethodReference ref);
+  static void DeleteGcMaps();
+
  private:
 
   explicit DexVerifier(Method* method);
@@ -1173,10 +1179,10 @@
    * encode it in some clever fashion.
    * Returns a pointer to a newly-allocated RegisterMap, or NULL on failure.
    */
-  ByteArray* GenerateGcMap();
+  const std::vector<uint8_t>* GenerateGcMap();
 
   // Verify that the GC map associated with method_ is well formed
-  void VerifyGcMap();
+  void VerifyGcMap(const std::vector<uint8_t>& data);
 
   // Compute sizes for GC map data
   void ComputeGcMapSizes(size_t* gc_points, size_t* ref_bitmap_bits, size_t* log2_max_gc_pc);
@@ -1185,6 +1191,13 @@
     return insn_flags_[work_insn_idx_];
   }
 
+  typedef std::tr1::unordered_map<const Compiler::MethodReference,
+                                  const std::vector<uint8_t>*,
+                                  Compiler::MethodReferenceHash> GcMapTable;
+  // All the GC maps that the verifier has created
+  static GcMapTable gc_maps_;
+  static void SetGcMap(Compiler::MethodReference ref, const std::vector<uint8_t>& gc_map);
+
   RegTypeCache reg_types_;
 
   PcToRegisterLineTable reg_table_;
@@ -1220,11 +1233,11 @@
 // Lightweight wrapper for PC to reference bit maps.
 class PcToReferenceMap {
  public:
-  PcToReferenceMap(Method* m) {
-    data_ = down_cast<ByteArray*>(m->GetGcMap());
-    CHECK(data_ != NULL) << PrettyMethod(m);
+  PcToReferenceMap(const uint8_t* data, size_t data_length) {
+    data_ = data;
+    CHECK(data_ != NULL);
     // Check the size of the table agrees with the number of entries
-    size_t data_size = data_->GetLength() - 4;
+    size_t data_size = data_length - 4;
     DCHECK_EQ(EntryWidth() * NumEntries(), data_size);
   }
 
@@ -1288,9 +1301,9 @@
   }
 
   const uint8_t* GetData() const {
-    return reinterpret_cast<uint8_t*>(data_->GetData());
+    return data_;
   }
-  ByteArray* data_;  // The header and table data
+  const uint8_t* data_;  // The header and table data
 };
 
 }  // namespace verifier
diff --git a/src/image_writer.cc b/src/image_writer.cc
index f6d144e..861a878 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -398,6 +398,10 @@
     uint32_t vmap_table_offset = orig->GetOatVmapTableOffset();
     const byte* vmap_table = GetOatAddress(vmap_table_offset);
     copy->vmap_table_ = reinterpret_cast<const uint16_t*>(vmap_table);
+
+    uint32_t gc_map_offset = orig->GetOatGcMapOffset();
+    const byte* gc_map = GetOatAddress(gc_map_offset);
+    copy->gc_map_ = reinterpret_cast<const uint8_t*>(gc_map);
   }
 }
 
diff --git a/src/oat.cc b/src/oat.cc
index 0089410..c458ea3 100644
--- a/src/oat.cc
+++ b/src/oat.cc
@@ -72,6 +72,7 @@
     fp_spill_mask_(0),
     mapping_table_offset_(0),
     vmap_table_offset_(0),
+    gc_map_offset_(0),
     invoke_stub_offset_(0) {}
 
 OatMethodOffsets::OatMethodOffsets(uint32_t code_offset,
@@ -80,6 +81,7 @@
                                    uint32_t fp_spill_mask,
                                    uint32_t mapping_table_offset,
                                    uint32_t vmap_table_offset,
+                                   uint32_t gc_map_offset,
                                    uint32_t invoke_stub_offset)
   : code_offset_(code_offset),
     frame_size_in_bytes_(frame_size_in_bytes),
@@ -87,6 +89,7 @@
     fp_spill_mask_(fp_spill_mask),
     mapping_table_offset_(mapping_table_offset),
     vmap_table_offset_(vmap_table_offset),
+    gc_map_offset_(gc_map_offset),
     invoke_stub_offset_(invoke_stub_offset) {}
 
 OatMethodOffsets::~OatMethodOffsets() {}
diff --git a/src/oat.h b/src/oat.h
index 0ffc80f..4023aed 100644
--- a/src/oat.h
+++ b/src/oat.h
@@ -45,6 +45,7 @@
                    uint32_t fp_spill_mask,
                    uint32_t mapping_table_offset,
                    uint32_t vmap_table_offset,
+                   uint32_t gc_map_offset,
                    uint32_t invoke_stub_offset);
   ~OatMethodOffsets();
 
@@ -54,6 +55,7 @@
   uint32_t fp_spill_mask_;
   uint32_t mapping_table_offset_;
   uint32_t vmap_table_offset_;
+  uint32_t gc_map_offset_;
   uint32_t invoke_stub_offset_;
 };
 
diff --git a/src/oat_file.cc b/src/oat_file.cc
index a4bbc5f..6ffcb52 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -216,6 +216,7 @@
       oat_method_offsets.fp_spill_mask_,
       oat_method_offsets.mapping_table_offset_,
       oat_method_offsets.vmap_table_offset_,
+      oat_method_offsets.gc_map_offset_,
       oat_method_offsets.invoke_stub_offset_);
 }
 
@@ -226,6 +227,7 @@
                               const uint32_t fp_spill_mask,
                               const uint32_t mapping_table_offset,
                               const uint32_t vmap_table_offset,
+                              const uint32_t gc_map_offset,
                               const uint32_t invoke_stub_offset)
   : base_(base),
     code_offset_(code_offset),
@@ -234,6 +236,7 @@
     fp_spill_mask_(fp_spill_mask),
     mapping_table_offset_(mapping_table_offset),
     vmap_table_offset_(vmap_table_offset),
+    gc_map_offset_(gc_map_offset),
     invoke_stub_offset_(invoke_stub_offset) {
 
 #ifndef NDEBUG
@@ -260,6 +263,7 @@
   method->SetFpSpillMask(fp_spill_mask_);
   method->SetMappingTable(GetMappingTable());
   method->SetVmapTable(GetVmapTable());
+  method->SetGcMap(GetGcMap());
   method->SetInvokeStub(GetInvokeStub());
 }
 
@@ -271,6 +275,7 @@
   method->SetFpSpillMask(GetFpSpillMask());
   method->SetOatMappingTableOffset(GetMappingTableOffset());
   method->SetOatVmapTableOffset(GetVmapTableOffset());
+  method->SetOatGcMapOffset(GetGcMapOffset());
   method->SetOatInvokeStubOffset(GetInvokeStubOffset());
 }
 
diff --git a/src/oat_file.h b/src/oat_file.h
index 33a0e28..07e235b 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -61,6 +61,9 @@
     uint32_t GetVmapTableOffset() const {
       return vmap_table_offset_;
     }
+    uint32_t GetGcMapOffset() const {
+      return gc_map_offset_;
+    }
     uint32_t GetInvokeStubOffset() const {
       return invoke_stub_offset_;
     }
@@ -74,6 +77,9 @@
     const uint16_t* GetVmapTable() const {
       return GetOatPointer<const uint16_t*>(vmap_table_offset_);
     }
+    const uint8_t* GetGcMap() const {
+      return GetOatPointer<const uint8_t*>(gc_map_offset_);
+    }
     const Method::InvokeStub* GetInvokeStub() const {
       return GetOatPointer<const Method::InvokeStub*>(invoke_stub_offset_);
     }
@@ -88,6 +94,7 @@
               const uint32_t fp_spill_mask,
               const uint32_t mapping_table_offset,
               const uint32_t vmap_table_offset,
+              const uint32_t gc_map_offset,
               const uint32_t invoke_stub_offset);
 
    private:
@@ -107,6 +114,7 @@
     uint32_t fp_spill_mask_;
     uint32_t mapping_table_offset_;
     uint32_t vmap_table_offset_;
+    uint32_t gc_map_offset_;
     uint32_t invoke_stub_offset_;
 
     friend class OatClass;
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 806ac71..9690142 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -193,6 +193,7 @@
   uint32_t fp_spill_mask = 0;
   uint32_t mapping_table_offset = 0;
   uint32_t vmap_table_offset = 0;
+  uint32_t gc_map_offset = 0;
   // derived from CompiledInvokeStub if available
   uint32_t invoke_stub_offset = 0;
 
@@ -258,6 +259,20 @@
       offset += vmap_table_size;
       oat_header_->UpdateChecksum(&vmap_table[0], vmap_table_size);
     }
+
+    const std::vector<uint8_t>& gc_map = compiled_method->GetGcMap();
+    size_t gc_map_size = gc_map.size() * sizeof(gc_map[0]);
+    gc_map_offset = (gc_map_size == 0) ? 0 : offset;
+
+    // Deduplicate GC maps
+    std::map<const std::vector<uint8_t>*, uint32_t>::iterator gc_map_iter = gc_map_offsets_.find(&gc_map);
+    if (gc_map_iter != gc_map_offsets_.end()) {
+      gc_map_offset = gc_map_iter->second;
+    } else {
+      gc_map_offsets_.insert(std::pair<const std::vector<uint8_t>*, uint32_t>(&gc_map, gc_map_offset));
+      offset += gc_map_size;
+      oat_header_->UpdateChecksum(&gc_map[0], gc_map_size);
+    }
   }
 
   const char* shorty = dex_file->GetMethodShorty(dex_file->GetMethodId(method_idx));
@@ -287,6 +302,7 @@
                          fp_spill_mask,
                          mapping_table_offset,
                          vmap_table_offset,
+                         gc_map_offset,
                          invoke_stub_offset);
 
   if (compiler_->IsImage()) {
@@ -301,6 +317,7 @@
     method->SetOatMappingTableOffset(mapping_table_offset);
     method->SetOatCodeOffset(code_offset);
     method->SetOatVmapTableOffset(vmap_table_offset);
+    method->SetOatGcMapOffset(gc_map_offset);
     method->SetOatInvokeStubOffset(invoke_stub_offset);
   }
   return offset;
@@ -567,6 +584,29 @@
       code_offset += vmap_table_size;
     }
     DCHECK_CODE_OFFSET();
+
+    const std::vector<uint8_t>& gc_map = compiled_method->GetGcMap();
+    size_t gc_map_size = gc_map.size() * sizeof(gc_map[0]);
+
+    // Deduplicate GC maps
+    std::map<const std::vector<uint8_t>*, uint32_t>::iterator gc_map_iter =
+        gc_map_offsets_.find(&gc_map);
+    if (gc_map_iter != gc_map_offsets_.end() &&
+        code_offset != method_offsets.gc_map_offset_) {
+      DCHECK((gc_map_size == 0 && method_offsets.gc_map_offset_ == 0)
+          || gc_map_iter->second == method_offsets.gc_map_offset_)
+          << PrettyMethod(method_idx, dex_file);
+    } else {
+      DCHECK((gc_map_size == 0 && method_offsets.gc_map_offset_ == 0)
+          || code_offset == method_offsets.gc_map_offset_)
+          << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&gc_map[0], gc_map_size)) {
+        ReportWriteFailure("GC map", method_idx, dex_file, file);
+        return false;
+      }
+      code_offset += gc_map_size;
+    }
+    DCHECK_CODE_OFFSET();
   }
   const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
   const CompiledInvokeStub* compiled_invoke_stub = compiler_->FindInvokeStub(is_static, shorty);
diff --git a/src/oat_writer.h b/src/oat_writer.h
index 6ae0f4e..d1983a5 100644
--- a/src/oat_writer.h
+++ b/src/oat_writer.h
@@ -147,6 +147,7 @@
   std::map<const std::vector<uint8_t>*, uint32_t, MapCompare<std::vector<uint8_t> > > code_offsets_;
   std::map<const std::vector<uint16_t>*, uint32_t, MapCompare<std::vector<uint16_t> > > vmap_table_offsets_;
   std::map<const std::vector<uint32_t>*, uint32_t, MapCompare<std::vector<uint32_t> > > mapping_table_offsets_;
+  std::map<const std::vector<uint8_t>*, uint32_t, MapCompare<std::vector<uint8_t> > > gc_map_offsets_;
 
   DISALLOW_COPY_AND_ASSIGN(OatWriter);
 };
diff --git a/src/oatdump.cc b/src/oatdump.cc
index dd46896..91f4091 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -122,9 +122,10 @@
     for (size_t class_def_index = 0; class_def_index < dex_file->NumClassDefs(); class_def_index++) {
       const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
       const char* descriptor = dex_file->GetClassDescriptor(class_def);
-      os << StringPrintf("%d: %s (type_idx=%d)\n", class_def_index, descriptor, class_def.class_idx_);
       UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file.GetOatClass(class_def_index));
       CHECK(oat_class.get() != NULL);
+      os << StringPrintf("%d: %s (type_idx=%d) (", class_def_index, descriptor, class_def.class_idx_)
+         << oat_class->GetStatus() << ")\n";
       DumpOatClass(os, oat_file, *oat_class.get(), *dex_file, class_def);
     }
 
@@ -189,6 +190,8 @@
                        oat_method.GetMappingTable(), oat_method.GetMappingTableOffset());
     os << StringPrintf("\t\tvmap_table: %p (offset=%08x)\n",
                        oat_method.GetVmapTable(), oat_method.GetVmapTableOffset());
+    os << StringPrintf("\t\tgc_map: %p (offset=%08x)\n",
+                       oat_method.GetGcMap(), oat_method.GetGcMapOffset());
     os << StringPrintf("\t\tinvoke_stub: %p (offset=%08x)\n",
                        oat_method.GetInvokeStub(), oat_method.GetInvokeStubOffset());
   }
@@ -342,29 +345,36 @@
           StringAppendF(&summary, "\tNATIVE UNREGISTERED\n");
         }
         DCHECK(method->GetGcMap() == NULL) << PrettyMethod(method);
+        DCHECK_EQ(0U, method->GetGcMapLength()) << PrettyMethod(method);
         DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
       } else if (method->IsAbstract()) {
         StringAppendF(&summary, "\tABSTRACT\n");
         DCHECK(method->GetGcMap() == NULL) << PrettyMethod(method);
+        DCHECK_EQ(0U, method->GetGcMapLength()) << PrettyMethod(method);
         DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
       } else if (method->IsCalleeSaveMethod()) {
         StringAppendF(&summary, "\tCALLEE SAVE METHOD\n");
         DCHECK(method->GetGcMap() == NULL) << PrettyMethod(method);
+        DCHECK_EQ(0U, method->GetGcMapLength()) << PrettyMethod(method);
         DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
       } else {
-        if (method->GetGcMap() != NULL) {
-          size_t register_map_bytes = method->GetGcMap()->SizeOf();
-          state->stats_.register_map_bytes += register_map_bytes;
-        }
+        DCHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
+        DCHECK_NE(0U, method->GetGcMapLength()) << PrettyMethod(method);
 
-        if (method->GetMappingTable() != NULL) {
-          size_t pc_mapping_table_bytes = method->GetMappingTableLength();
-          state->stats_.pc_mapping_table_bytes += pc_mapping_table_bytes;
-        }
+        size_t register_map_bytes = method->GetGcMapLength();
+        state->stats_.register_map_bytes += register_map_bytes;
+        StringAppendF(&summary, "GC=%d ", register_map_bytes);
+
+        size_t pc_mapping_table_bytes = method->GetMappingTableLength();
+        state->stats_.pc_mapping_table_bytes += pc_mapping_table_bytes;
+        StringAppendF(&summary, "Mapping=%d ", pc_mapping_table_bytes);
 
         const DexFile::CodeItem* code_item = MethodHelper(method).GetCodeItem();
         size_t dex_instruction_bytes = code_item->insns_size_in_code_units_ * 2;
         state->stats_.dex_instruction_bytes += dex_instruction_bytes;
+
+        StringAppendF(&summary, "\tSIZE Code=%d GC=%d Mapping=%d",
+                      dex_instruction_bytes, register_map_bytes, pc_mapping_table_bytes);
       }
     }
     state->os_ << summary << std::flush;
diff --git a/src/object.h b/src/object.h
index 5977977..7730974 100644
--- a/src/object.h
+++ b/src/object.h
@@ -701,12 +701,39 @@
     SetVmapTable(reinterpret_cast<uint16_t*>(vmap_table_offset));
   }
 
-  Object* GetGcMap() const {
-    return GetFieldObject<Object*>(OFFSET_OF_OBJECT_MEMBER(Method, gc_map_), false);
+  const uint8_t* GetGcMap() const {
+    const uint8_t* gc_map_raw = GetGcMapRaw();
+    if (gc_map_raw == NULL) {
+      return gc_map_raw;
+    }
+    return gc_map_raw + sizeof(uint32_t);
   }
 
-  void SetGcMap(Object* data) {
-    SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, gc_map_), data, false);
+  uint32_t GetGcMapLength() const {
+    const uint8_t* gc_map_raw = GetGcMapRaw();
+    if (gc_map_raw == NULL) {
+      return 0;
+    }
+    return static_cast<uint32_t>((gc_map_raw[0] << 24) |
+                                 (gc_map_raw[1] << 16) |
+                                 (gc_map_raw[2] << 8) |
+                                 (gc_map_raw[3] << 0));
+  }
+
+  const uint8_t* GetGcMapRaw() const {
+    return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(Method, gc_map_), false);
+  }
+  void SetGcMap(const uint8_t* data) {
+    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(Method, gc_map_), data, false);
+  }
+
+  uint32_t GetOatGcMapOffset() const {
+    DCHECK(!Runtime::Current()->IsStarted());
+    return reinterpret_cast<uint32_t>(GetGcMapRaw());
+  }
+  void SetOatGcMapOffset(uint32_t gc_map_offset) {
+    DCHECK(!Runtime::Current()->IsStarted());
+    SetGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
   }
 
   size_t GetFrameSizeInBytes() const {
@@ -859,9 +886,6 @@
   // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
   ObjectArray<String>* dex_cache_strings_;
 
-  // Garbage collection map
-  Object* gc_map_;
-
   // Access flags; low 16 bits are defined by spec.
   uint32_t access_flags_;
 
@@ -881,6 +905,9 @@
   // Total size in bytes of the frame
   size_t frame_size_in_bytes_;
 
+  // Garbage collection map
+  const uint8_t* gc_map_;
+
   // Native invocation stub entry point for calling from native to managed code.
   const InvokeStub* invoke_stub_;
 
diff --git a/src/thread.cc b/src/thread.cc
index a1df41b..6bee2c8 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -1495,7 +1495,9 @@
     }
     // Process register map (which native and callee save methods don't have)
     if (!m->IsNative() && !m->IsCalleeSaveMethod() && !m->IsProxyMethod()) {
-      verifier::PcToReferenceMap map(m);
+      CHECK(m->GetGcMap() != NULL) << PrettyMethod(m);
+      CHECK_NE(0U, m->GetGcMapLength()) << PrettyMethod(m);
+      verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
       const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
       CHECK(reg_bitmap != NULL);
       const VmapTable vmap_table(m->GetVmapTableRaw());