diff --git a/Android.mk b/Android.mk
index 904a5f1..6eb90bd 100644
--- a/Android.mk
+++ b/Android.mk
@@ -204,6 +204,7 @@
 	adb shell rm $(DEXPREOPT_BOOT_JAR_DIR)/*.oat
 	adb shell rm $(DEXPREOPT_BOOT_JAR_DIR)/*.art
 	adb shell rm system/app/*.oat
+	adb shell rm data/run-test/*.oat
 
 ########################################################################
 # cpplint target
diff --git a/src/exception_test.cc b/src/exception_test.cc
index eebba9d..120f16a 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -38,8 +38,13 @@
 
     dex_ = &Runtime::Current()->GetClassLinker()->FindDexFile(my_klass_->GetDexCache());
 
-    for (size_t i = 0 ; i < 12; i++) {
-      fake_code_.push_back(0x70000000 | i);
+    uint32_t code_size = 12;
+    fake_code_.push_back((code_size >> 24) & 0xFF);
+    fake_code_.push_back((code_size >> 16) & 0xFF);
+    fake_code_.push_back((code_size >>  8) & 0xFF);
+    fake_code_.push_back((code_size >>  0) & 0xFF);
+    for (size_t i = 0 ; i < code_size; i++) {
+      fake_code_.push_back(0x70 | i);
     }
 
     fake_mapping_data_.push_back(2);  // first element is count of remaining elements
@@ -49,13 +54,13 @@
     method_f_ = my_klass_->FindVirtualMethod("f", "()I");
     ASSERT_TRUE(method_f_ != NULL);
     method_f_->SetFrameSizeInBytes(kStackAlignment);
-    method_f_->SetCode(CompiledMethod::CodePointer(&fake_code_[0], kThumb2));
+    method_f_->SetCode(CompiledMethod::CodePointer(&fake_code_[sizeof(code_size)], kThumb2));
     method_f_->SetMappingTable(&fake_mapping_data_[0]);
 
     method_g_ = my_klass_->FindVirtualMethod("g", "(I)V");
     ASSERT_TRUE(method_g_ != NULL);
     method_g_->SetFrameSizeInBytes(kStackAlignment);
-    method_g_->SetCode(CompiledMethod::CodePointer(&fake_code_[0], kThumb2));
+    method_g_->SetCode(CompiledMethod::CodePointer(&fake_code_[sizeof(code_size)], kThumb2));
     method_g_->SetMappingTable(&fake_mapping_data_[0]);
   }
 
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 22dc92c..f0c004d 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -82,7 +82,7 @@
     return false;
   }
   CHECK(requested_base == 0 || requested_base == map->Begin())
-          << GetLocation() << " " << reinterpret_cast<void*>(map->Begin());
+      << GetLocation() << " " << reinterpret_cast<void*>(map->Begin());
   DCHECK_EQ(0, memcmp(&oat_header, map->Begin(), sizeof(OatHeader))) << GetLocation();
 
   off_t code_offset = oat_header.GetExecutableOffset();
diff --git a/src/oat_file.h b/src/oat_file.h
index 831934a..9fcba2f 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -90,6 +90,15 @@
     const void* GetCode() const {
       return GetOatPointer<const void*>(code_offset_);
     }
+    uint32_t GetCodeSize() const {
+      uintptr_t code = reinterpret_cast<uint32_t>(GetCode());
+      if (code == 0) {
+        return 0;
+      }
+      // TODO: make this Thumb2 specific
+      code &= ~0x1;
+      return reinterpret_cast<uint32_t*>(code)[-1];
+    }
     const uint32_t* GetMappingTable() const {
       return GetOatPointer<const uint32_t*>(mapping_table_offset_);
     }
@@ -102,6 +111,13 @@
     const Method::InvokeStub* GetInvokeStub() const {
       return GetOatPointer<const Method::InvokeStub*>(invoke_stub_offset_);
     }
+    uint32_t GetInvokeStubSize() const {
+      uintptr_t code = reinterpret_cast<uint32_t>(GetInvokeStub());
+      if (code == 0) {
+        return 0;
+      }
+      return reinterpret_cast<uint32_t*>(code)[-1];
+    }
 
     ~OatMethod();
 
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index dcdff9a..1ac247e 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -220,9 +220,10 @@
     offset = compiled_method->AlignCode(offset);
     DCHECK_ALIGNED(offset, kArmAlignment);
     const std::vector<uint8_t>& code = compiled_method->GetCode();
-    size_t code_size = code.size() * sizeof(code[0]);
+    uint32_t code_size = code.size() * sizeof(code[0]);
+    CHECK_NE(code_size, 0U);
     uint32_t thumb_offset = compiled_method->CodeDelta();
-    code_offset = (code_size == 0) ? 0 : offset + thumb_offset;
+    code_offset = offset + sizeof(code_size) + thumb_offset;
 
     // Deduplicate code arrays
     std::map<const std::vector<uint8_t>*, uint32_t>::iterator code_iter = code_offsets_.find(&code);
@@ -230,10 +231,10 @@
       code_offset = code_iter->second;
     } else {
       code_offsets_.insert(std::pair<const std::vector<uint8_t>*, uint32_t>(&code, code_offset));
+      offset += sizeof(code_size);  // code size is prepended before code
       offset += code_size;
       oat_header_->UpdateChecksum(&code[0], code_size);
     }
-
     frame_size_in_bytes = compiled_method->GetFrameSizeInBytes();
     core_spill_mask = compiled_method->GetCoreSpillMask();
     fp_spill_mask = compiled_method->GetFpSpillMask();
@@ -297,8 +298,9 @@
     offset = CompiledMethod::AlignCode(offset, compiler_->GetInstructionSet());
     DCHECK_ALIGNED(offset, kArmAlignment);
     const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
-    size_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
-    invoke_stub_offset = (invoke_stub_size == 0) ? 0 : offset;
+    uint32_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+    CHECK_NE(invoke_stub_size, 0U);
+    invoke_stub_offset = offset + sizeof(invoke_stub_size);
 
     // Deduplicate invoke stubs
     std::map<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter = code_offsets_.find(&invoke_stub);
@@ -306,6 +308,7 @@
       invoke_stub_offset = stub_iter->second;
     } else {
       code_offsets_.insert(std::pair<const std::vector<uint8_t>*, uint32_t>(&invoke_stub, invoke_stub_offset));
+      offset += sizeof(invoke_stub_size);  // invoke stub size is prepended before code
       offset += invoke_stub_size;
       oat_header_->UpdateChecksum(&invoke_stub[0], invoke_stub_size);
     }
@@ -522,19 +525,22 @@
     }
     DCHECK_ALIGNED(code_offset, kArmAlignment);
     const std::vector<uint8_t>& code = compiled_method->GetCode();
-    size_t code_size = code.size() * sizeof(code[0]);
+    uint32_t code_size = code.size() * sizeof(code[0]);
+    CHECK_NE(code_size, 0U);
 
     // Deduplicate code arrays
-    size_t offset = code_offset + compiled_method->CodeDelta();
+    size_t offset = code_offset + sizeof(code_size) + compiled_method->CodeDelta();
     std::map<const std::vector<uint8_t>*, uint32_t>::iterator code_iter = code_offsets_.find(&code);
     if (code_iter != code_offsets_.end() && offset != method_offsets.code_offset_) {
-      DCHECK((code_size == 0 && method_offsets.code_offset_ == 0)
-             || code_iter->second == method_offsets.code_offset_)
-             << PrettyMethod(method_idx, dex_file);
+      DCHECK(code_iter->second == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
     } else {
-      DCHECK((code_size == 0 && method_offsets.code_offset_ == 0)
-             || offset == method_offsets.code_offset_)
-             << PrettyMethod(method_idx, dex_file);
+      DCHECK(offset == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&code_size, sizeof(code_size))) {
+        ReportWriteFailure("method code size", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += sizeof(code_size);
+      DCHECK_CODE_OFFSET();
       if (!file->WriteFully(&code[0], code_size)) {
         ReportWriteFailure("method code", method_idx, dex_file, file);
         return 0;
@@ -633,20 +639,23 @@
     }
     DCHECK_ALIGNED(code_offset, kArmAlignment);
     const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
-    size_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+    uint32_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+    CHECK_NE(invoke_stub_size, 0U);
 
     // Deduplicate invoke stubs
+    size_t offset = code_offset + sizeof(invoke_stub_size);
     std::map<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter =
         code_offsets_.find(&invoke_stub);
-    if (stub_iter != code_offsets_.end() &&
-        code_offset != method_offsets.invoke_stub_offset_) {
-      DCHECK((invoke_stub_size == 0 && method_offsets.invoke_stub_offset_ == 0)
-          || stub_iter->second == method_offsets.invoke_stub_offset_)
-          << PrettyMethod(method_idx, dex_file);
+    if (stub_iter != code_offsets_.end() && offset != method_offsets.invoke_stub_offset_) {
+      DCHECK(stub_iter->second == method_offsets.invoke_stub_offset_) << PrettyMethod(method_idx, dex_file);
     } else {
-      DCHECK((invoke_stub_size == 0 && method_offsets.invoke_stub_offset_ == 0)
-          || code_offset == method_offsets.invoke_stub_offset_)
-          << PrettyMethod(method_idx, dex_file);
+      DCHECK(offset == method_offsets.invoke_stub_offset_) << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&invoke_stub_size, sizeof(invoke_stub_size))) {
+        ReportWriteFailure("invoke stub code size", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += sizeof(invoke_stub_size);
+      DCHECK_CODE_OFFSET();
       if (!file->WriteFully(&invoke_stub[0], invoke_stub_size)) {
         ReportWriteFailure("invoke stub code", method_idx, dex_file, file);
         return 0;
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 5574bb7..96af3b0 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -138,6 +138,10 @@
     return end_offset - begin_offset;
   }
 
+  InstructionSet GetInstructionSet() {
+    return oat_file_.GetOatHeader().GetInstructionSet();
+  }
+
   const void* GetOatCode(Method* m) {
     MethodHelper mh(m);
     for (size_t i = 0; i < oat_dex_files_.size(); i++) {
@@ -299,9 +303,9 @@
     DumpGcMap(os, oat_method.GetGcMap());
     os << StringPrintf("\t\tinvoke_stub: %p (offset=0x%08x)\n",
                        oat_method.GetInvokeStub(), oat_method.GetInvokeStubOffset());
-    os << "\t\tCODE:\n";
+    os << "\t\tCODE: (size=" << oat_method.GetCodeSize() << ")\n";
     DumpCode(os, oat_method.GetCode(), oat_method.GetMappingTable(), dex_file, code_item);
-    os << "\t\tINVOKE STUB:\n";
+    os << "\t\tINVOKE STUB: (size=" << oat_method.GetInvokeStubSize() << ")\n";
     DumpCode(os, reinterpret_cast<const void*>(oat_method.GetInvokeStub()), NULL, dex_file, NULL);
   }
 
@@ -620,17 +624,36 @@
 
   bool InDumpSpace(const Object* object) {
     return image_space_.Contains(object);
- }
+  }
 
-  const void* GetOatCode(Method* m) {
+  const void* GetOatCodeBegin(Method* m) {
     Runtime* runtime = Runtime::Current();
     const void* code = m->GetCode();
     if (code == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
       code = oat_dumper_->GetOatCode(m);
     }
+    if (oat_dumper_->GetInstructionSet() == kThumb2) {
+      code = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(code) & ~0x1);
+    }
     return code;
   }
 
+  uint32_t GetOatCodeSize(Method* m) {
+    const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetOatCodeBegin(m));
+    if (oat_code_begin == NULL) {
+      return 0;
+    }
+    return oat_code_begin[-1];
+  }
+
+  const void* GetOatCodeEnd(Method* m) {
+    const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetOatCodeBegin(m));
+    if (oat_code_begin == NULL) {
+      return NULL;
+    }
+    return oat_code_begin + GetOatCodeSize(m);
+  }
+
   static void Callback(Object* obj, void* arg) {
     DCHECK(obj != NULL);
     DCHECK(arg != NULL);
@@ -712,7 +735,7 @@
         if (first_occurrence) {
           state->stats_.managed_to_native_code_bytes += invoke_stub_size;
         }
-        const void* oat_code = state->GetOatCode(method);
+        const void* oat_code = state->GetOatCodeBegin(method);
         size_t code_size = state->ComputeOatSize(oat_code, &first_occurrence);
         if (first_occurrence) {
           state->stats_.native_to_managed_code_bytes += code_size;
@@ -756,16 +779,17 @@
         if (first_occurance) {
           state->stats_.native_to_managed_code_bytes += invoke_stub_size;
         }
-        const void* oat_code = state->GetOatCode(method);
-        size_t code_size = state->ComputeOatSize(oat_code, &first_occurance);
+        const void* oat_code_begin = state->GetOatCodeBegin(method);
+        const void* oat_code_end = state->GetOatCodeEnd(method);
+        // TODO: use oat_code_size and remove code_size based on offsets
+        // uint32_t oat_code_size = state->GetOatCodeSize(method);
+        size_t code_size = state->ComputeOatSize(oat_code_begin, &first_occurance);
         if (first_occurance) {
           state->stats_.managed_code_bytes += code_size;
         }
         state->stats_.managed_code_bytes_ignoring_deduplication += code_size;
 
-        if (oat_code != method->GetCode()) {
-          StringAppendF(&summary, "\t\tOAT CODE: %p\n", oat_code);
-        }
+        StringAppendF(&summary, "\t\tOAT CODE: %p-%p\n", oat_code_begin, oat_code_end);
         StringAppendF(&summary, "\t\tSIZE: Dex Instructions=%zd GC=%zd Mapping=%zd\n",
                       dex_instruction_bytes, gc_map_bytes, pc_mapping_table_bytes);
 
diff --git a/src/object.h b/src/object.h
index b3a4805..3a7efa2 100644
--- a/src/object.h
+++ b/src/object.h
@@ -633,6 +633,27 @@
     SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), code, false);
   }
 
+  uint32_t GetCodeSize() const {
+    DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
+    uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
+    if (code == 0) {
+      return 0;
+    }
+    // TODO: make this Thumb2 specific
+    code &= ~0x1;
+    return reinterpret_cast<uint32_t*>(code)[-1];
+  }
+
+  bool IsWithinCode(uintptr_t pc) const {
+    uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
+    if (code == 0) {
+      return pc == 0;
+    }
+    return (code <= pc && pc < code + GetCodeSize());
+  }
+
+  void AssertPcIsWithinCode(uintptr_t pc) const;
+
   uint32_t GetOatCodeOffset() const {
     DCHECK(!Runtime::Current()->IsStarted());
     return reinterpret_cast<uint32_t>(GetCode());
@@ -781,7 +802,7 @@
   }
 
   // Native to managed invocation stub entry point
-  InvokeStub* GetInvokeStub() const {
+  const InvokeStub* GetInvokeStub() const {
     InvokeStub* result = GetFieldPtr<InvokeStub*>(
         OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_), false);
     // TODO: DCHECK(result != NULL);  should be ahead of time compiled
@@ -793,6 +814,14 @@
                                    invoke_stub, false);
   }
 
+  uint32_t GetInvokeStubSize() const {
+    const uint32_t* invoke_stub = reinterpret_cast<const uint32_t*>(GetInvokeStub());
+    if (invoke_stub == NULL) {
+      return 0;
+    }
+    return invoke_stub[-1];
+  }
+
   uint32_t GetOatInvokeStubOffset() const {
     DCHECK(!Runtime::Current()->IsStarted());
     return reinterpret_cast<uint32_t>(GetInvokeStub());
@@ -2303,6 +2332,23 @@
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_dex_index_), false);
 }
 
+inline void Method::AssertPcIsWithinCode(uintptr_t pc) const {
+#ifndef NDEBUG
+  if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
+    return;
+  }
+  Runtime* runtime = Runtime::Current();
+  if (GetCode() == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
+      return;
+  }
+  DCHECK(IsWithinCode(pc))
+      << PrettyMethod(this)
+      << " pc=" << std::hex << pc
+      << " code=" << GetCode()
+      << " size=" << GetCodeSize();
+#endif
+}
+
 inline String* Class::GetName() const {
   return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, name_), false);
 }
diff --git a/src/thread.cc b/src/thread.cc
index b511aa7..629cb0f 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -1205,7 +1205,7 @@
 
   while (frame.GetSP() != NULL) {
     for ( ; frame.GetMethod() != NULL; frame.Next()) {
-      // DCHECK(frame.GetMethod()->IsWithinCode(pc));  // TODO: restore IsWithinCode
+      frame.GetMethod()->AssertPcIsWithinCode(pc);
       bool should_continue = visitor->VisitFrame(frame, pc);
       if (!should_continue) {
         return;