diff --git a/src/check_jni.cc b/src/check_jni.cc
index 659dcb8..037edfc 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -21,6 +21,7 @@
 
 #include "class_linker.h"
 #include "logging.h"
+#include "object_utils.h"
 #include "scoped_jni_thread_state.h"
 #include "thread.h"
 #include "runtime.h"
@@ -112,7 +113,7 @@
   // such as NewByteArray.
   // If -verbose:third-party-jni is on, we want to log any JNI function calls
   // made by a third-party native method.
-  std::string classNameStr(method->GetDeclaringClass()->GetDescriptor()->ToModifiedUtf8());
+  std::string classNameStr(MethodHelper(method).GetDeclaringClassDescriptor());
   if (!vm->trace.empty() && classNameStr.find(vm->trace) != std::string::npos) {
     return true;
   }
@@ -180,7 +181,7 @@
     if (f == NULL) {
       return;
     }
-    Class* field_type = f->GetType();
+    Class* field_type = FieldHelper(f).GetType();
     if (!field_type->IsPrimitive()) {
       if (java_object != NULL) {
         Object* obj = Decode<Object*>(ts, java_object);
@@ -237,10 +238,9 @@
     if (f == NULL) {
       return;
     }
-    // check invariant that all jfieldIDs have resolved types
-    DCHECK(f->GetType() != NULL);
     Class* c = o->GetClass();
-    if (c->FindInstanceField(f->GetName()->ToModifiedUtf8(), f->GetTypeDescriptor()) == NULL) {
+    FieldHelper fh(f);
+    if (c->FindInstanceField(fh.GetName(), fh.GetTypeDescriptor()) == NULL) {
       LOG(ERROR) << "JNI ERROR: jfieldID " << PrettyField(f)
                  << " not valid for an object of class " << PrettyTypeOf(o);
       JniAbort();
@@ -263,11 +263,11 @@
    */
   void CheckSig(jmethodID mid, const char* expectedType, bool isStatic) {
     ScopedJniThreadState ts(env_);
-    const Method* m = CheckMethodID(mid);
+    Method* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
     }
-    if (*expectedType != m->GetShorty()->CharAt(0)) {
+    if (*expectedType != MethodHelper(m).GetShorty()[0]) {
       LOG(ERROR) << "JNI ERROR: the return type of " << function_name_ << " does not match "
                  << PrettyMethod(m);
       JniAbort();
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 9e4a76d..6555070 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -19,6 +19,7 @@
 #include "monitor.h"
 #include "oat_file.h"
 #include "object.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "runtime_support.h"
 #include "ScopedLocalRef.h"
@@ -59,13 +60,14 @@
 
 void ThrowNoSuchMethodError(const char* kind,
     Class* c, const StringPiece& name, const StringPiece& signature) {
-  DexCache* dex_cache = c->GetDexCache();
+  ClassHelper kh(c);
   std::ostringstream msg;
   msg << "no " << kind << " method " << name << "." << signature
-      << " in class " << c->GetDescriptor()->ToModifiedUtf8()
+      << " in class " << kh.GetDescriptor()
       << " or its superclasses";
-  if (dex_cache) {
-    msg << " (defined in " << dex_cache->GetLocation()->ToModifiedUtf8() << ")";
+  std::string location(kh.GetLocation());
+  if (!location.empty()) {
+    msg << " (defined in " << location << ")";
   }
   Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
 }
@@ -81,11 +83,11 @@
 
   if (c->GetVerifyErrorClass() != NULL) {
     // TODO: change the verifier to store an _instance_, with a useful detail message?
-    std::string error_descriptor(c->GetVerifyErrorClass()->GetDescriptor()->ToModifiedUtf8());
-    Thread::Current()->ThrowNewException(error_descriptor.c_str(),
-        PrettyDescriptor(c->GetDescriptor()).c_str());
+    ClassHelper ve_ch(c->GetVerifyErrorClass());
+    std::string error_descriptor(ve_ch.GetDescriptor());
+    Thread::Current()->ThrowNewException(error_descriptor.c_str(), PrettyDescriptor(c).c_str());
   } else {
-    ThrowNoClassDefFoundError("%s", PrettyDescriptor(c->GetDescriptor()).c_str());
+    ThrowNoClassDefFoundError("%s", PrettyDescriptor(c).c_str());
   }
 }
 
@@ -204,7 +206,6 @@
       dex_lock_("ClassLinker dex lock"),
       classes_lock_("ClassLinker classes lock"),
       class_roots_(NULL),
-      array_interfaces_(NULL),
       array_iftable_(NULL),
       init_done_(false),
       intern_table_(intern_table) {
@@ -269,14 +270,6 @@
   java_lang_String->SetObjectSize(sizeof(String));
   java_lang_String->SetStatus(Class::kStatusResolved);
 
-  // Backfill Class descriptors missing until this point
-  java_lang_Class->SetDescriptor(intern_table_->InternStrong("Ljava/lang/Class;"));
-  java_lang_Object->SetDescriptor(intern_table_->InternStrong("Ljava/lang/Object;"));
-  class_array_class->SetDescriptor(intern_table_->InternStrong("[Ljava/lang/Class;"));
-  object_array_class->SetDescriptor(intern_table_->InternStrong("[Ljava/lang/Object;"));
-  java_lang_String->SetDescriptor(intern_table_->InternStrong("Ljava/lang/String;"));
-  char_array_class->SetDescriptor(intern_table_->InternStrong("[C"));
-
   // Create storage for root classes, save away our work so far (requires
   // descriptors)
   class_roots_ = ObjectArray<Class>::Alloc(object_array_class.get(), kClassRootsMax);
@@ -299,12 +292,10 @@
   SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass("V", Primitive::kPrimVoid));
 
   // Create array interface entries to populate once we can load system classes
-  array_interfaces_ = AllocClassArray(2);
   array_iftable_ = AllocObjectArray<InterfaceEntry>(2);
 
   // Create int array type for AllocDexCache (done in AppendToBootClassPath)
   SirtRef<Class> int_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
-  int_array_class->SetDescriptor(intern_table_->InternStrong("[I"));
   int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
   IntArray::SetArrayClass(int_array_class.get());
   SetClassRoot(kIntArrayClass, int_array_class.get());
@@ -324,7 +315,6 @@
 
   // Constructor, Field, and Method are necessary so that FindClass can link members
   SirtRef<Class> java_lang_reflect_Constructor(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
-  java_lang_reflect_Constructor->SetDescriptor(intern_table_->InternStrong("Ljava/lang/reflect/Constructor;"));
   CHECK(java_lang_reflect_Constructor.get() != NULL);
   java_lang_reflect_Constructor->SetObjectSize(sizeof(Method));
   SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
@@ -332,14 +322,12 @@
 
   SirtRef<Class> java_lang_reflect_Field(AllocClass(java_lang_Class.get(), sizeof(FieldClass)));
   CHECK(java_lang_reflect_Field.get() != NULL);
-  java_lang_reflect_Field->SetDescriptor(intern_table_->InternStrong("Ljava/lang/reflect/Field;"));
   java_lang_reflect_Field->SetObjectSize(sizeof(Field));
   SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
   java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
   Field::SetClass(java_lang_reflect_Field.get());
 
   SirtRef<Class> java_lang_reflect_Method(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
-  java_lang_reflect_Method->SetDescriptor(intern_table_->InternStrong("Ljava/lang/reflect/Method;"));
   CHECK(java_lang_reflect_Method.get() != NULL);
   java_lang_reflect_Method->SetObjectSize(sizeof(Method));
   SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
@@ -398,21 +386,19 @@
   CHECK(java_lang_Cloneable != NULL);
   Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
   CHECK(java_io_Serializable != NULL);
-  CHECK(array_interfaces_ != NULL);
-  array_interfaces_->Set(0, java_lang_Cloneable);
-  array_interfaces_->Set(1, java_io_Serializable);
   // We assume that Cloneable/Serializable don't have superinterfaces --
   // normally we'd have to crawl up and explicitly list all of the
   // supers as well.
-  array_iftable_->Set(0, AllocInterfaceEntry(array_interfaces_->Get(0)));
-  array_iftable_->Set(1, AllocInterfaceEntry(array_interfaces_->Get(1)));
+  array_iftable_->Set(0, AllocInterfaceEntry(java_lang_Cloneable));
+  array_iftable_->Set(1, AllocInterfaceEntry(java_io_Serializable));
 
   // Sanity check Class[] and Object[]'s interfaces
-  CHECK_EQ(java_lang_Cloneable, class_array_class->GetInterface(0));
-  CHECK_EQ(java_io_Serializable, class_array_class->GetInterface(1));
-  CHECK_EQ(java_lang_Cloneable, object_array_class->GetInterface(0));
-  CHECK_EQ(java_io_Serializable, object_array_class->GetInterface(1));
-
+  ClassHelper kh(class_array_class.get(), this);
+  CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
+  CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
+  kh.ChangeClass(object_array_class.get());
+  CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
+  CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
   // run Class, Constructor, Field, and Method through FindSystemClass.
   // this initializes their dex_cache_ fields and register them in classes_.
   Class* Class_class = FindSystemClass("Ljava/lang/Class;");
@@ -497,25 +483,37 @@
 
   Heap::SetWellKnownClasses(java_lang_ref_FinalizerReference, java_lang_ref_ReferenceQueue);
 
+  const DexFile& java_lang_dex = FindDexFile(java_lang_ref_Reference->GetDexCache());
+
   Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
-  CHECK(pendingNext->GetName()->Equals("pendingNext"));
-  CHECK_EQ(ResolveType(pendingNext->GetTypeIdx(), pendingNext), java_lang_ref_Reference);
+  FieldHelper fh(pendingNext, this);
+  CHECK_STREQ(fh.GetName(), "pendingNext");
+  CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
+           java_lang_ref_Reference->GetDexTypeIndex());
 
   Field* queue = java_lang_ref_Reference->GetInstanceField(1);
-  CHECK(queue->GetName()->Equals("queue"));
-  CHECK_EQ(ResolveType(queue->GetTypeIdx(), queue), java_lang_ref_ReferenceQueue);
+  fh.ChangeField(queue);
+  CHECK_STREQ(fh.GetName(), "queue");
+  CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
+           java_lang_ref_ReferenceQueue->GetDexTypeIndex());
 
   Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
-  CHECK(queueNext->GetName()->Equals("queueNext"));
-  CHECK_EQ(ResolveType(queueNext->GetTypeIdx(), queueNext), java_lang_ref_Reference);
+  fh.ChangeField(queueNext);
+  CHECK_STREQ(fh.GetName(), "queueNext");
+  CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
+           java_lang_ref_Reference->GetDexTypeIndex());
 
   Field* referent = java_lang_ref_Reference->GetInstanceField(3);
-  CHECK(referent->GetName()->Equals("referent"));
-  CHECK_EQ(ResolveType(referent->GetTypeIdx(), referent), GetClassRoot(kJavaLangObject));
+  fh.ChangeField(referent);
+  CHECK_STREQ(fh.GetName(), "referent");
+  CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
+           GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
 
   Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
-  CHECK(zombie->GetName()->Equals("zombie"));
-  CHECK_EQ(ResolveType(zombie->GetTypeIdx(), zombie), GetClassRoot(kJavaLangObject));
+  fh.ChangeField(zombie);
+  CHECK_STREQ(fh.GetName(), "zombie");
+  CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
+           GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
 
   Heap::SetReferenceOffsets(referent->GetOffset(),
                             queue->GetOffset(),
@@ -534,7 +532,6 @@
   }
 
   CHECK(array_iftable_ != NULL);
-  CHECK(array_interfaces_ != NULL);
 
   // disable the slow paths in FindClass and CreatePrimitiveClass now
   // that Object, Class, and Object[] are setup
@@ -611,7 +608,9 @@
     LOG(INFO) << "ClassLinker::OpenOat entering";
   }
   const ImageHeader& image_header = space->GetImageHeader();
-  String* oat_location = image_header.GetImageRoot(ImageHeader::kOatLocation)->AsString();
+  // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
+  // check the down cast
+  String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
   std::string oat_filename;
   oat_filename += runtime->GetHostPrefix();
   oat_filename += oat_location->ToModifiedUtf8();
@@ -734,6 +733,14 @@
       Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
       ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
 
+      if (i == 0) {
+        // Special case of setting up the String class early so that we can test arbitrary objects
+        // as being Strings or not
+        Class* java_lang_String = spaces[0]->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)
+            ->AsObjectArray<Class>()->Get(kJavaLangString);
+        String::SetClass(java_lang_String);
+      }
+
       CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
                static_cast<uint32_t>(dex_caches->GetLength()));
       for (int i = 0; i < dex_caches->GetLength(); i++) {
@@ -767,13 +774,10 @@
   Object* class_roots_object = spaces[0]->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots);
   class_roots_ = class_roots_object->AsObjectArray<Class>();
 
-  // reinit array_interfaces_ and array_iftable_ from any array class instance, they should all be ==
-  array_interfaces_ = GetClassRoot(kObjectArrayClass)->GetInterfaces();
-  DCHECK(array_interfaces_ == GetClassRoot(kBooleanArrayClass)->GetInterfaces());
+  // reinit array_iftable_ from any array class instance, they should be ==
   array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
   DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
-
-  String::SetClass(GetClassRoot(kJavaLangString));
+  // String class root was set above
   Field::SetClass(GetClassRoot(kJavaLangReflectField));
   Method::SetClasses(GetClassRoot(kJavaLangReflectConstructor), GetClassRoot(kJavaLangReflectMethod));
   BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
@@ -806,7 +810,7 @@
   if (obj->IsClass()) {
     // restore class to ClassLinker::classes_ table
     Class* klass = obj->AsClass();
-    std::string descriptor = klass->GetDescriptor()->ToModifiedUtf8();
+    std::string descriptor(ClassHelper(klass, class_linker).GetDescriptor());
     bool success = class_linker->InsertClass(descriptor, klass, true);
     DCHECK(success);
     return;
@@ -832,7 +836,6 @@
     // Note. we deliberately ignore the class roots in the image (held in image_classes_)
   }
 
-  visitor(array_interfaces_, arg);
   visitor(array_iftable_, arg);
 }
 
@@ -960,7 +963,7 @@
     // Check for circular dependencies between classes.
     if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
       self->ThrowNewException("Ljava/lang/ClassCircularityError;",
-          PrettyDescriptor(klass->GetDescriptor()).c_str());
+          PrettyDescriptor(klass).c_str());
       return NULL;
     }
     // Wait for the pending initialization to complete.
@@ -985,15 +988,16 @@
   Thread* self = Thread::Current();
   DCHECK(self != NULL);
   CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+  if (descriptor.size() == 1) {
+    // only the descriptors of primitive types should be 1 character long, also avoid class lookup
+    // for primitive classes that aren't backed by dex files.
+    return FindPrimitiveClass(descriptor[0]);
+  }
   // Find the class in the loaded classes table.
   Class* klass = LookupClass(descriptor, class_loader);
   if (klass != NULL) {
     return EnsureResolved(klass);
   }
-  if (descriptor.size() == 1) {
-    // only the descriptors of primitive types should be 1 character long
-    return FindPrimitiveClass(descriptor[0]);
-  }
   // Class is not yet loaded.
   if (descriptor[0] == '[') {
     return CreateArrayClass(descriptor, class_loader);
@@ -1179,14 +1183,6 @@
   CHECK(descriptor != NULL);
 
   klass->SetClass(GetClassRoot(kJavaLangClass));
-  if (klass->GetDescriptor() != NULL) {
-    DCHECK(klass->GetDescriptor()->Equals(descriptor));
-  } else {
-    klass->SetDescriptor(intern_table_->InternStrong(descriptor));
-    if (klass->GetDescriptor() == NULL) {
-      return;
-    }
-  }
   uint32_t access_flags = dex_class_def.access_flags_;
   // Make sure that none of our runtime-only flags are set.
   CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
@@ -1195,21 +1191,7 @@
   DCHECK(klass->GetPrimitiveType() == Primitive::kPrimNot);
   klass->SetStatus(Class::kStatusIdx);
 
-  klass->SetTypeIdx(dex_class_def.class_idx_);
-  klass->SetSuperClassTypeIdx(dex_class_def.superclass_idx_);
-  klass->SetAnnotationsOffset(dex_class_def.annotations_off_);
-
-  const char* source_file = dex_file.GetSourceFile(dex_class_def);
-  if (source_file != NULL) {
-    String* source_file_string = intern_table_->InternStrong(source_file);
-    if (source_file_string == NULL) {
-      return;
-    }
-    klass->SetSourceFile(source_file_string);
-  }
-
-  // Load class interfaces.
-  LoadInterfaces(dex_file, dex_class_def, klass);
+  klass->SetDexTypeIndex(dex_class_def.class_idx_);
 
   // Load fields fields.
   const byte* class_data = dex_file.GetClassData(dex_class_def);
@@ -1279,88 +1261,59 @@
   DCHECK(!it.HasNext());
 }
 
-void ClassLinker::LoadInterfaces(const DexFile& dex_file,
-                                 const DexFile::ClassDef& dex_class_def,
-                                 SirtRef<Class>& klass) {
-  const DexFile::TypeList* list = dex_file.GetInterfacesList(dex_class_def);
-  if (list != NULL) {
-    klass->SetInterfaces(AllocClassArray(list->Size()));
-    IntArray* interfaces_idx = IntArray::Alloc(list->Size());
-    klass->SetInterfacesTypeIdx(interfaces_idx);
-    for (size_t i = 0; i < list->Size(); ++i) {
-      const DexFile::TypeItem& type_item = list->GetTypeItem(i);
-      interfaces_idx->Set(i, type_item.type_idx_);
-    }
-  }
-}
-
 void ClassLinker::LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
                             SirtRef<Class>& klass, SirtRef<Field>& dst) {
-  const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
+  uint32_t field_idx = it.GetMemberIndex();
+  dst->SetDexFieldIndex(field_idx);
   dst->SetDeclaringClass(klass.get());
-  dst->SetName(ResolveString(dex_file, field_id.name_idx_, klass->GetDexCache()));
-  dst->SetTypeIdx(field_id.type_idx_);
   dst->SetAccessFlags(it.GetMemberAccessFlags());
-
-  // In order to access primitive types using GetTypeDuringLinking we need to
-  // ensure they are resolved into the dex cache
-  const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
-  if (descriptor[1] == '\0') {
-    // only the descriptors of primitive types should be 1 character long
-    Class* resolved = ResolveType(dex_file, field_id.type_idx_, klass.get());
-    DCHECK(resolved->IsPrimitive());
-  }
 }
 
 void ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
                              SirtRef<Class>& klass, SirtRef<Method>& dst) {
-  const DexFile::MethodId& method_id = dex_file.GetMethodId(it.GetMemberIndex());
+  uint32_t method_idx = it.GetMemberIndex();
+  dst->SetDexMethodIndex(method_idx);
+  const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
   dst->SetDeclaringClass(klass.get());
 
-  String* method_name = ResolveString(dex_file, method_id.name_idx_, klass->GetDexCache());
-  if (method_name == NULL) {
-    return;
-  }
-  dst->SetName(method_name);
-  if (method_name->Equals("<init>")) {
+
+  StringPiece method_name(dex_file.GetMethodName(method_id));
+  if (method_name == "<init>") {
     dst->SetClass(GetClassRoot(kJavaLangReflectConstructor));
   }
 
-  int32_t utf16_length;
-  std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, &utf16_length));
-  String* signature_string = intern_table_->InternStrong(utf16_length, signature.c_str());
-  if (signature_string == NULL) {
-    return;
-  }
-  dst->SetSignature(signature_string);
-
-  if (method_name->Equals("finalize") && signature == "()V") {
-    /*
-     * The Enum class declares a "final" finalize() method to prevent subclasses from introducing
-     * a finalizer. We don't want to set the finalizable flag for Enum or its subclasses, so we
-     * exclude it here.
-     *
-     * We also want to avoid setting the flag on Object, where we know that finalize() is empty.
-     */
-    if (klass->GetClassLoader() != NULL ||
-        (!klass->GetDescriptor()->Equals("Ljava/lang/Object;") &&
-            !klass->GetDescriptor()->Equals("Ljava/lang/Enum;"))) {
-      klass->SetFinalizable();
+  if (method_name == "finalize") {
+    // Create the prototype for a signature of "()V"
+    const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
+    if (void_string_id != NULL) {
+      const DexFile::TypeId* void_type_id =
+          dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
+      if (void_type_id != NULL) {
+        std::vector<uint16_t> no_args;
+        const DexFile::ProtoId* finalizer_proto =
+            dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
+        if (finalizer_proto != NULL) {
+          // We have the prototype in the dex file
+          if (klass->GetClassLoader() != NULL) {  // All non-boot finalizer methods are flagged
+            klass->SetFinalizable();
+          } else {
+            StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
+            // The Enum class declares a "final" finalize() method to prevent subclasses from
+            // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
+            // subclasses, so we exclude it here.
+            // We also want to avoid setting the flag on Object, where we know that finalize() is
+            // empty.
+            if (klass_descriptor != "Ljava/lang/Object;" &&
+                klass_descriptor != "Ljava/lang/Enum;") {
+              klass->SetFinalizable();
+            }
+          }
+        }
+      }
     }
   }
-
-  dst->SetProtoIdx(method_id.proto_idx_);
   dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
-  const char* shorty = dex_file.GetShorty(method_id.proto_idx_);
-  String* shorty_string = intern_table_->InternStrong(shorty);
-  dst->SetShorty(shorty_string);
-  if (shorty_string == NULL) {
-    return;
-  }
   dst->SetAccessFlags(it.GetMemberAccessFlags());
-  uint32_t return_type_idx = dex_file.GetProtoId(method_id.proto_idx_).return_type_idx_;
-  DCHECK_LT(return_type_idx, dex_file.NumTypeIds());
-  dst->SetReturnTypeIdx(return_type_idx);
 
   dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
   dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
@@ -1370,20 +1323,6 @@
   dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
 
   // TODO: check for finalize method
-
-  const DexFile::CodeItem* code_item = it.GetMethodCodeItem();
-  if (code_item != NULL) {
-    dst->SetNumRegisters(code_item->registers_size_);
-    dst->SetNumIns(code_item->ins_size_);
-    dst->SetNumOuts(code_item->outs_size_);
-  } else {
-    uint16_t num_args = Method::NumArgRegisters(shorty);
-    if ((it.GetMemberAccessFlags() & kAccStatic) == 0) {
-      ++num_args;
-    }
-    dst->SetNumRegisters(num_args);
-    // TODO: native methods
-  }
 }
 
 void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
@@ -1474,8 +1413,6 @@
   // TODO: deduce one argument from the other
   CHECK(primitive_class != NULL);
   primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
-  primitive_class->SetDescriptor(intern_table_->InternStrong(descriptor));
-  CHECK(primitive_class->GetDescriptor() != NULL);
   primitive_class->SetPrimitiveType(type);
   primitive_class->SetStatus(Class::kStatusInitialized);
   bool success = InsertClass(descriptor, primitive_class, false);
@@ -1561,14 +1498,6 @@
     new_class->SetComponentType(component_type);
   }
   DCHECK(new_class->GetComponentType() != NULL);
-  if (new_class->GetDescriptor() != NULL) {
-    DCHECK(new_class->GetDescriptor()->Equals(descriptor));
-  } else {
-    new_class->SetDescriptor(intern_table_->InternStrong(descriptor.c_str()));
-    if (new_class->GetDescriptor() == NULL) {
-      return NULL;
-    }
-  }
   Class* java_lang_Object = GetClassRoot(kJavaLangObject);
   new_class->SetSuperClass(java_lang_Object);
   new_class->SetVTable(java_lang_Object->GetVTable());
@@ -1591,9 +1520,7 @@
 
   // Use the single, global copies of "interfaces" and "iftable"
   // (remember not to free them for arrays).
-  CHECK(array_interfaces_ != NULL);
   CHECK(array_iftable_ != NULL);
-  new_class->SetInterfaces(array_interfaces_);
   new_class->SetIfTable(array_iftable_);
 
   // Inherit access flags from the component type.  Arrays can't be
@@ -1677,16 +1604,19 @@
   MutexLock mu(classes_lock_);
   typedef Table::const_iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
+  ClassHelper kh;
   for (It it = classes_.find(hash), end = classes_.end(); it != end; ++it) {
     Class* klass = it->second;
-    if (klass->GetDescriptor()->Equals(descriptor) && klass->GetClassLoader() == class_loader) {
+    kh.ChangeClass(klass);
+    if (kh.GetDescriptor() == descriptor && klass->GetClassLoader() == class_loader) {
       classes_.erase(it);
       return true;
     }
   }
   for (It it = image_classes_.find(hash), end = image_classes_.end(); it != end; ++it) {
     Class* klass = it->second;
-    if (klass->GetDescriptor()->Equals(descriptor) && klass->GetClassLoader() == class_loader) {
+    kh.ChangeClass(klass);
+    if (kh.GetDescriptor() == descriptor && klass->GetClassLoader() == class_loader) {
       image_classes_.erase(it);
       return true;
     }
@@ -1699,15 +1629,18 @@
   MutexLock mu(classes_lock_);
   typedef Table::const_iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
+  ClassHelper kh(NULL, this);
   for (It it = classes_.find(hash), end = classes_.end(); it != end; ++it) {
     Class* klass = it->second;
-    if (klass->GetDescriptor()->Equals(descriptor) && klass->GetClassLoader() == class_loader) {
+    kh.ChangeClass(klass);
+    if (descriptor == kh.GetDescriptor() && klass->GetClassLoader() == class_loader) {
       return klass;
     }
   }
   for (It it = image_classes_.find(hash), end = image_classes_.end(); it != end; ++it) {
     Class* klass = it->second;
-    if (klass->GetDescriptor()->Equals(descriptor) && klass->GetClassLoader() == class_loader) {
+    kh.ChangeClass(klass);
+    if (descriptor == kh.GetDescriptor() && klass->GetClassLoader() == class_loader) {
       return klass;
     }
   }
@@ -1720,16 +1653,19 @@
   MutexLock mu(classes_lock_);
   typedef Table::const_iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
+  ClassHelper kh(NULL, this);
   for (It it = classes_.find(hash), end = classes_.end(); it != end; ++it) {
-    Class* c = it->second;
-    if (c->GetDescriptor()->Equals(descriptor)) {
-      classes.push_back(c);
+    Class* klass = it->second;
+    kh.ChangeClass(klass);
+    if (descriptor == kh.GetDescriptor()) {
+      classes.push_back(klass);
     }
   }
   for (It it = image_classes_.find(hash), end = image_classes_.end(); it != end; ++it) {
-    Class* c = it->second;
-    if (c->GetDescriptor()->Equals(descriptor)) {
-      classes.push_back(c);
+    Class* klass = it->second;
+    kh.ChangeClass(klass);
+    if (descriptor == kh.GetDescriptor()) {
+      classes.push_back(klass);
     }
   }
 }
@@ -1749,48 +1685,56 @@
     Thread* self = Thread::Current();
     CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
     self->ThrowNewExceptionF("Ljava/lang/VerifyError;", "Verification of %s failed",
-        PrettyDescriptor(klass->GetDescriptor()).c_str());
+        PrettyDescriptor(klass).c_str());
     CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying);
     klass->SetStatus(Class::kStatusError);
   }
 }
 
 Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
-    ClassLoader* loader, ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws) {
+                                     ClassLoader* loader, ObjectArray<Method>* methods,
+                                     ObjectArray<ObjectArray<Class> >* throws) {
   SirtRef<Class> klass(AllocClass(GetClassRoot(kJavaLangClass), sizeof(ProxyClass)));
   CHECK(klass.get() != NULL);
   klass->SetObjectSize(sizeof(Proxy));
-  const char* descriptor = DotToDescriptor(name->ToModifiedUtf8().c_str()).c_str();;
-  klass->SetDescriptor(intern_table_->InternStrong(descriptor));
-  klass->SetAccessFlags(kAccPublic | kAccFinal);
+  klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
   klass->SetClassLoader(loader);
-  klass->SetStatus(Class::kStatusInitialized);  // no loading or initializing necessary
+  klass->SetName(name);
   Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
+  klass->SetDexCache(proxy_class->GetDexCache());
+  klass->SetDexTypeIndex(-1);
   klass->SetSuperClass(proxy_class);  // The super class is java.lang.reflect.Proxy
-  klass->SetInterfaces(interfaces);  // The interfaces are the array of interfaces specified
+  klass->SetStatus(Class::kStatusInitialized);  // no loading or initializing necessary
 
   // Proxies have 1 direct method, the constructor
   klass->SetDirectMethods(AllocObjectArray<Method>(1));
-  klass->SetDirectMethod(0, CreateProxyConstructor(klass));
+  klass->SetDirectMethod(0, CreateProxyConstructor(klass, proxy_class));
 
   // Create virtual method using specified prototypes
   size_t num_virtual_methods = methods->GetLength();
   klass->SetVirtualMethods(AllocObjectArray<Method>(num_virtual_methods));
   for (size_t i = 0; i < num_virtual_methods; ++i) {
     SirtRef<Method> prototype(methods->Get(i));
-    klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype, throws->Get(i)));
+    klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype));
   }
   // Link the virtual methods, creating vtable and iftables
-  if (!LinkMethods(klass)) {
+  if (!LinkMethods(klass, interfaces)) {
     DCHECK(Thread::Current()->IsExceptionPending());
     return NULL;
   }
   return klass.get();
 }
 
-Method* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass) {
+std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
+  DCHECK(proxy_class->IsProxyClass());
+  String* name = proxy_class->GetName();
+  DCHECK(name != NULL);
+  return DotToDescriptor(name->ToModifiedUtf8().c_str());
+}
+
+
+Method* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
   // Create constructor for Proxy that must initialize h
-  Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
   ObjectArray<Method>* proxy_direct_methods = proxy_class->GetDirectMethods();
   CHECK_EQ(proxy_direct_methods->GetLength(), 15);
   Method* proxy_constructor = proxy_direct_methods->Get(2);
@@ -1802,15 +1746,18 @@
   constructor->SetDeclaringClass(klass.get());
   // Sanity checks
   CHECK(constructor->IsConstructor());
-  CHECK(constructor->GetName()->Equals("<init>"));
-  CHECK(constructor->GetSignature()->Equals("(Ljava/lang/reflect/InvocationHandler;)V"));
+  MethodHelper mh(constructor);
+  CHECK_STREQ(mh.GetName(), "<init>");
+  CHECK(mh.GetSignature() == "(Ljava/lang/reflect/InvocationHandler;)V");
   DCHECK(constructor->IsPublic());
   return constructor;
 }
 
-Method* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype,
-                                       ObjectArray<Class>* throws) {
-  // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialise
+Method* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype) {
+  // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
+  // prototype method
+  prototype->GetDexCacheResolvedMethods()->Set(prototype->GetDexMethodIndex(), prototype.get());
+  // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
   // as necessary
   Method* method = down_cast<Method*>(prototype->Clone());
 
@@ -1818,7 +1765,6 @@
   // the intersection of throw exceptions as defined in Proxy
   method->SetDeclaringClass(klass.get());
   method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
-  method->SetExceptionTypes(throws);
 
   // At runtime the method looks like a reference and argument saving method, clone the code
   // related parameters from this method.
@@ -1829,12 +1775,21 @@
   method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
 
   // Basic sanity
-  DCHECK(method->GetName()->Equals(prototype->GetName()));
-  DCHECK(method->GetSignature()->Equals(prototype->GetSignature()));
-  DCHECK(method->GetShorty()->Equals(prototype->GetShorty()));
+  CHECK(!prototype->IsFinal());
+  CHECK(method->IsFinal());
+  CHECK(!method->IsAbstract());
+  MethodHelper mh(method);
+  const char* method_name = mh.GetName();
+  const char* method_shorty = mh.GetShorty();
+  Class* method_return = mh.GetReturnType();
+
+  mh.ChangeMethod(prototype.get());
+
+  CHECK_STREQ(mh.GetName(), method_name);
+  CHECK_STREQ(mh.GetShorty(), method_shorty);
 
   // More complex sanity - via dex cache
-  CHECK_EQ(method->GetReturnType(), prototype->GetReturnType());
+  CHECK_EQ(mh.GetReturnType(), method_return);
 
   return method;
 }
@@ -1928,8 +1883,8 @@
       thread_stats->class_init_time_ns += (t1 - t0);
       klass->SetStatus(Class::kStatusInitialized);
       if (verbose_) {
-        LOG(INFO) << "Initialized class " << klass->GetDescriptor()->ToModifiedUtf8()
-                  << " from " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
+        ClassHelper kh(klass);
+        LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
       }
     }
     lock.NotifyAll();
@@ -1959,7 +1914,7 @@
       // The caller wants an exception, but it was thrown in a
       // different thread.  Synthesize one here.
       ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
-                                PrettyDescriptor(klass->GetDescriptor()).c_str());
+                                PrettyDescriptor(klass).c_str());
       return false;
     }
     if (klass->IsInitialized()) {
@@ -1984,7 +1939,9 @@
           !HasSameMethodDescriptorClasses(method, super, klass)) {
         klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
 
-        ThrowLinkageError("Class %s method %s resolves differently in superclass %s", PrettyDescriptor(klass->GetDescriptor()).c_str(), PrettyMethod(method).c_str(), PrettyDescriptor(super->GetDescriptor()).c_str());
+        ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
+                          PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
+                          PrettyDescriptor(super).c_str());
         return false;
       }
     }
@@ -1999,7 +1956,10 @@
                                             method->GetDeclaringClass())) {
           klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
 
-          ThrowLinkageError("Class %s method %s resolves differently in interface %s", PrettyDescriptor(method->GetDeclaringClass()->GetDescriptor()).c_str(), PrettyMethod(method).c_str(), PrettyDescriptor(interface->GetDescriptor()).c_str());
+          ThrowLinkageError("Class %s method %s resolves differently in interface %s",
+                            PrettyDescriptor(method->GetDeclaringClass()).c_str(),
+                            PrettyMethod(method).c_str(),
+                            PrettyDescriptor(interface).c_str());
           return false;
         }
       }
@@ -2015,7 +1975,8 @@
     return true;
   }
   const DexFile& dex_file = FindDexFile(method->GetDeclaringClass()->GetDexCache());
-  const DexFile::ProtoId& proto_id = dex_file.GetProtoId(method->GetProtoIdx());
+  const DexFile::ProtoId& proto_id =
+      dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
   for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
     const char* descriptor = it.GetDescriptor();
     if (descriptor == NULL) {
@@ -2121,10 +2082,10 @@
   if (dex_cache == NULL) {
     return;
   }
-  const DexFile& dex_file = FindDexFile(dex_cache);
-  const std::string descriptor(klass->GetDescriptor()->ToModifiedUtf8());
-  const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
+  ClassHelper kh(klass);
+  const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
   CHECK(dex_class_def != NULL);
+  const DexFile& dex_file = kh.GetDexFile();
   EncodedStaticFieldValueIterator it(dex_file, dex_cache, this, *dex_class_def);
 
   if (it.HasNext()) {
@@ -2142,7 +2103,7 @@
   if (!LinkSuperClass(klass)) {
     return false;
   }
-  if (!LinkMethods(klass)) {
+  if (!LinkMethods(klass, NULL)) {
     return false;
   }
   if (!LinkInstanceFields(klass)) {
@@ -2160,30 +2121,38 @@
 
 bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
   CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
-  if (klass->GetSuperClassTypeIdx() != DexFile::kDexNoIndex16) {
-    Class* super_class = ResolveType(dex_file, klass->GetSuperClassTypeIdx(), klass.get());
+  StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
+  const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
+  if (class_def == NULL) {
+    return false;
+  }
+  uint16_t super_class_idx = class_def->superclass_idx_;
+  if (super_class_idx != DexFile::kDexNoIndex16) {
+    Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
     if (super_class == NULL) {
       DCHECK(Thread::Current()->IsExceptionPending());
       return false;
     }
     klass->SetSuperClass(super_class);
   }
-  for (size_t i = 0; i < klass->NumInterfaces(); ++i) {
-    uint32_t idx = klass->GetInterfacesTypeIdx()->Get(i);
-    Class* interface = ResolveType(dex_file, idx, klass.get());
-    klass->SetInterface(i, interface);
-    if (interface == NULL) {
-      DCHECK(Thread::Current()->IsExceptionPending());
-      return false;
-    }
-    // Verify
-    if (!klass->CanAccess(interface)) {
-      // TODO: the RI seemed to ignore this in my testing.
-      Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-          "Interface %s implemented by class %s is inaccessible",
-          PrettyDescriptor(interface->GetDescriptor()).c_str(),
-          PrettyDescriptor(klass->GetDescriptor()).c_str());
-      return false;
+  const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
+  if (interfaces != NULL) {
+    for (size_t i = 0; i < interfaces->Size(); i++) {
+      uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
+      Class* interface = ResolveType(dex_file, idx, klass.get());
+      if (interface == NULL) {
+        DCHECK(Thread::Current()->IsExceptionPending());
+        return false;
+      }
+      // Verify
+      if (!klass->CanAccess(interface)) {
+        // TODO: the RI seemed to ignore this in my testing.
+        Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
+            "Interface %s implemented by class %s is inaccessible",
+            PrettyDescriptor(interface).c_str(),
+            PrettyDescriptor(klass.get()).c_str());
+        return false;
+      }
     }
   }
   // Mark the class as loaded.
@@ -2194,7 +2163,7 @@
 bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
   CHECK(!klass->IsPrimitive());
   Class* super = klass->GetSuperClass();
-  if (klass->GetDescriptor()->Equals("Ljava/lang/Object;")) {
+  if (klass.get() == GetClassRoot(kJavaLangObject)) {
     if (super != NULL) {
       Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
           "java.lang.Object must not have a superclass");
@@ -2203,24 +2172,23 @@
     return true;
   }
   if (super == NULL) {
-    ThrowLinkageError("No superclass defined for class %s",
-        PrettyDescriptor(klass->GetDescriptor()).c_str());
+    ThrowLinkageError("No superclass defined for class %s", PrettyDescriptor(klass.get()).c_str());
     return false;
   }
   // Verify
   if (super->IsFinal() || super->IsInterface()) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
         "Superclass %s of %s is %s",
-        PrettyDescriptor(super->GetDescriptor()).c_str(),
-        PrettyDescriptor(klass->GetDescriptor()).c_str(),
+        PrettyDescriptor(super).c_str(),
+        PrettyDescriptor(klass.get()).c_str(),
         super->IsFinal() ? "declared final" : "an interface");
     return false;
   }
   if (!klass->CanAccess(super)) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
         "Superclass %s is inaccessible by %s",
-        PrettyDescriptor(super->GetDescriptor()).c_str(),
-        PrettyDescriptor(klass->GetDescriptor()).c_str());
+        PrettyDescriptor(super).c_str(),
+        PrettyDescriptor(klass.get()).c_str());
     return false;
   }
 
@@ -2237,7 +2205,7 @@
   // Disallow custom direct subclasses of java.lang.ref.Reference.
   if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
     ThrowLinkageError("Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
-        PrettyDescriptor(klass->GetDescriptor()).c_str());
+        PrettyDescriptor(klass.get()).c_str());
     return false;
   }
 
@@ -2252,7 +2220,7 @@
 }
 
 // Populate the class vtable and itable. Compute return type indices.
-bool ClassLinker::LinkMethods(SirtRef<Class>& klass) {
+bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
   if (klass->IsInterface()) {
     // No vtable.
     size_t count = klass->NumVirtualMethods();
@@ -2264,10 +2232,10 @@
       klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
     }
     // Link interface method tables
-    return LinkInterfaceMethods(klass);
+    return LinkInterfaceMethods(klass, interfaces);
   } else {
     // Link virtual and interface method tables
-    return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass);
+    return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
   }
   return true;
 }
@@ -2280,18 +2248,22 @@
     // TODO: do not assign to the vtable field until it is fully constructed.
     ObjectArray<Method>* vtable = klass->GetSuperClass()->GetVTable()->CopyOf(max_count);
     // See if any of our virtual methods override the superclass.
+    MethodHelper local_mh(NULL, this);
+    MethodHelper super_mh(NULL, this);
     for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
       Method* local_method = klass->GetVirtualMethodDuringLinking(i);
+      local_mh.ChangeMethod(local_method);
       size_t j = 0;
       for (; j < actual_count; ++j) {
         Method* super_method = vtable->Get(j);
-        if (local_method->HasSameNameAndSignature(super_method)) {
+        super_mh.ChangeMethod(super_method);
+        if (local_mh.HasSameNameAndSignature(&super_mh)) {
           // Verify
           if (super_method->IsFinal()) {
+            MethodHelper mh(local_method);
             ThrowLinkageError("Method %s.%s overrides final method in class %s",
-                PrettyDescriptor(klass->GetDescriptor()).c_str(),
-                local_method->GetName()->ToModifiedUtf8().c_str(),
-                PrettyDescriptor(super_method->GetDeclaringClass()->GetDescriptor()).c_str());
+                PrettyDescriptor(klass.get()).c_str(),
+                mh.GetName(), mh.GetDeclaringClassDescriptor());
             return false;
           }
           vtable->Set(j, local_method);
@@ -2317,7 +2289,7 @@
     }
     klass->SetVTable(vtable);
   } else {
-    CHECK(klass->GetDescriptor()->Equals("Ljava/lang/Object;"));
+    CHECK(klass.get() == GetClassRoot(kJavaLangObject));
     uint32_t num_virtual_methods = klass->NumVirtualMethods();
     if (!IsUint(16, num_virtual_methods)) {
       ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
@@ -2334,7 +2306,7 @@
   return true;
 }
 
-bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass) {
+bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
   size_t super_ifcount;
   if (klass->HasSuperClass()) {
     super_ifcount = klass->GetSuperClass()->GetIfTableCount();
@@ -2342,9 +2314,12 @@
     super_ifcount = 0;
   }
   size_t ifcount = super_ifcount;
-  ifcount += klass->NumInterfaces();
-  for (size_t i = 0; i < klass->NumInterfaces(); i++) {
-    ifcount += klass->GetInterface(i)->GetIfTableCount();
+  ClassHelper kh(klass.get(), this);
+  uint32_t num_interfaces = interfaces == NULL ? kh.NumInterfaces() : interfaces->GetLength();
+  ifcount += num_interfaces;
+  for (size_t i = 0; i < num_interfaces; i++) {
+    Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
+    ifcount += interface->GetIfTableCount();
   }
   if (ifcount == 0) {
     // TODO: enable these asserts with klass status validation
@@ -2361,14 +2336,15 @@
   }
   // Flatten the interface inheritance hierarchy.
   size_t idx = super_ifcount;
-  for (size_t i = 0; i < klass->NumInterfaces(); i++) {
-    Class* interface = klass->GetInterface(i);
+  for (size_t i = 0; i < num_interfaces; i++) {
+    Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
     DCHECK(interface != NULL);
     if (!interface->IsInterface()) {
+      ClassHelper ih(interface);
       Thread::Current()->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
           "Class %s implements non-interface class %s",
-          PrettyDescriptor(klass->GetDescriptor()).c_str(),
-          PrettyDescriptor(interface->GetDescriptor()).c_str());
+          PrettyDescriptor(klass.get()).c_str(),
+          PrettyDescriptor(ih.GetDescriptor()).c_str());
       return false;
     }
     // Add this interface.
@@ -2386,6 +2362,8 @@
     return true;
   }
   std::vector<Method*> miranda_list;
+  MethodHelper vtable_mh(NULL, this);
+  MethodHelper interface_mh(NULL, this);
   for (size_t i = 0; i < ifcount; ++i) {
     InterfaceEntry* interface_entry = iftable->Get(i);
     Class* interface = interface_entry->GetInterface();
@@ -2394,6 +2372,7 @@
     ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
     for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
       Method* interface_method = interface->GetVirtualMethod(j);
+      interface_mh.ChangeMethod(interface_method);
       int32_t k;
       // For each method listed in the interface's method list, find the
       // matching method in our class's method list.  We want to favor the
@@ -2405,7 +2384,8 @@
       // matter which direction we go.  We walk it backward anyway.)
       for (k = vtable->GetLength() - 1; k >= 0; --k) {
         Method* vtable_method = vtable->Get(k);
-        if (interface_method->HasSameNameAndSignature(vtable_method)) {
+        vtable_mh.ChangeMethod(vtable_method);
+        if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
           if (!vtable_method->IsPublic()) {
             Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
                 "Implementation not public: %s", PrettyMethod(vtable_method).c_str());
@@ -2418,7 +2398,9 @@
       if (k < 0) {
         SirtRef<Method> miranda_method(NULL);
         for (size_t mir = 0; mir < miranda_list.size(); mir++) {
-          if (miranda_list[mir]->HasSameNameAndSignature(interface_method)) {
+          Method* mir_method = miranda_list[mir];
+          vtable_mh.ChangeMethod(mir_method);
+          if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
             miranda_method.reset(miranda_list[mir]);
             break;
           }
@@ -2481,10 +2463,13 @@
 }
 
 struct LinkFieldsComparator {
+  LinkFieldsComparator(FieldHelper* fh) : fh_(fh) {}
   bool operator()(const Field* field1, const Field* field2) {
     // First come reference fields, then 64-bit, and finally 32-bit
-    Primitive::Type type1 = field1->GetPrimitiveType();
-    Primitive::Type type2 = field2->GetPrimitiveType();
+    fh_->ChangeField(field1);
+    Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
+    fh_->ChangeField(field2);
+    Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
     bool isPrimitive1 = type1 != Primitive::kPrimNot;
     bool isPrimitive2 = type2 != Primitive::kPrimNot;
     bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
@@ -2496,10 +2481,14 @@
     }
 
     // same basic group? then sort by string.
-    std::string name1 = field1->GetName()->ToModifiedUtf8();
-    std::string name2 = field2->GetName()->ToModifiedUtf8();
+    fh_->ChangeField(field1);
+    StringPiece name1(fh_->GetName());
+    fh_->ChangeField(field2);
+    StringPiece name2(fh_->GetName());
     return name1 < name2;
   }
+
+  FieldHelper* fh_;
 };
 
 bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
@@ -2532,16 +2521,18 @@
   for (size_t i = 0; i < num_fields; i++) {
     grouped_and_sorted_fields.push_back(fields->Get(i));
   }
+  FieldHelper fh(NULL, this);
   std::sort(grouped_and_sorted_fields.begin(),
             grouped_and_sorted_fields.end(),
-            LinkFieldsComparator());
+            LinkFieldsComparator(&fh));
 
   // References should be at the front.
   size_t current_field = 0;
   size_t num_reference_fields = 0;
   for (; current_field < num_fields; current_field++) {
     Field* field = grouped_and_sorted_fields.front();
-    Primitive::Type type = field->GetPrimitiveType();
+    fh.ChangeField(field);
+    Primitive::Type type = fh.GetTypeAsPrimitiveType();
     bool isPrimitive = type != Primitive::kPrimNot;
     if (isPrimitive) {
       break; // past last reference, move on to the next phase
@@ -2559,7 +2550,8 @@
   if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
     for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
       Field* field = grouped_and_sorted_fields[i];
-      Primitive::Type type = field->GetPrimitiveType();
+      fh.ChangeField(field);
+      Primitive::Type type = fh.GetTypeAsPrimitiveType();
       CHECK(type != Primitive::kPrimNot);  // should only be working on primitive types
       if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
         continue;
@@ -2580,7 +2572,8 @@
   while (!grouped_and_sorted_fields.empty()) {
     Field* field = grouped_and_sorted_fields.front();
     grouped_and_sorted_fields.pop_front();
-    Primitive::Type type = field->GetPrimitiveType();
+    fh.ChangeField(field);
+    Primitive::Type type = fh.GetTypeAsPrimitiveType();
     CHECK(type != Primitive::kPrimNot);  // should only be working on primitive types
     fields->Set(current_field, field);
     field->SetOffset(field_offset);
@@ -2592,11 +2585,14 @@
   }
 
   // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
-  if (!is_static && klass->GetDescriptor()->Equals("Ljava/lang/ref/Reference;")) {
+  std::string descriptor(ClassHelper(klass.get(), this).GetDescriptor());
+  if (!is_static &&  descriptor == "Ljava/lang/ref/Reference;") {
     // We know there are no non-reference fields in the Reference classes, and we know
     // that 'referent' is alphabetically last, so this is easy...
     CHECK_EQ(num_reference_fields, num_fields);
-    CHECK(fields->Get(num_fields - 1)->GetName()->Equals("referent"));
+    fh.ChangeField(fields->Get(num_fields - 1));
+    StringPiece name(fh.GetName());
+    CHECK(name == "referent");
     --num_reference_fields;
   }
 
@@ -2612,9 +2608,10 @@
                 << " field=" << PrettyField(field)
                 << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
     }
-    Primitive::Type type = field->GetPrimitiveType();
+    fh.ChangeField(field);
+    Primitive::Type type = fh.GetTypeAsPrimitiveType();
     bool is_primitive = type != Primitive::kPrimNot;
-    if (klass->GetDescriptor()->Equals("Ljava/lang/ref/Reference;") && field->GetName()->Equals("referent")) {
+    if (descriptor == "Ljava/lang/ref/Reference;" && StringPiece(fh.GetName()) == "referent") {
       is_primitive = true; // We lied above, so we have to expect a lie here.
     }
     if (is_primitive) {
@@ -2711,7 +2708,7 @@
 }
 
 Class* ClassLinker::ResolveType(const DexFile& dex_file,
-                                uint32_t type_idx,
+                                uint16_t type_idx,
                                 DexCache* dex_cache,
                                 const ClassLoader* class_loader) {
   Class* resolved = dex_cache->GetResolvedType(type_idx);
@@ -2842,4 +2839,15 @@
   return dex_lock_.GetOwner();
 }
 
+void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
+  DCHECK(!init_done_);
+
+  DCHECK(klass != NULL);
+  DCHECK(klass->GetClassLoader() == NULL);
+
+  DCHECK(class_roots_ != NULL);
+  DCHECK(class_roots_->Get(class_root) == NULL);
+  class_roots_->Set(class_root, klass);
+}
+
 }  // namespace art
diff --git a/src/class_linker.h b/src/class_linker.h
index e408dbb..089040f 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -18,6 +18,7 @@
 #define ART_SRC_CLASS_LINKER_H_
 
 #include <map>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -105,7 +106,7 @@
   // result in the DexCache. The referrer is used to identity the
   // target DexCache and ClassLoader to use for resolution.
   Class* ResolveType(const DexFile& dex_file,
-                     uint32_t type_idx,
+                     uint16_t type_idx,
                      const Class* referrer) {
     return ResolveType(dex_file,
                        type_idx,
@@ -116,7 +117,7 @@
   // Resolve a Type with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  Class* ResolveType(uint32_t type_idx, const Method* referrer) {
+  Class* ResolveType(uint16_t type_idx, const Method* referrer) {
     Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
     if (UNLIKELY(resolved_type == NULL)) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -128,7 +129,7 @@
     return resolved_type;
   }
 
-  Class* ResolveType(uint32_t type_idx, const Field* referrer) {
+  Class* ResolveType(uint16_t type_idx, const Field* referrer) {
     Class* declaring_class = referrer->GetDeclaringClass();
     DexCache* dex_cache = declaring_class->GetDexCache();
     Class* resolved_type = dex_cache->GetResolvedType(type_idx);
@@ -145,7 +146,7 @@
   // type, since it may be referenced from but not contained within
   // the given DexFile.
   Class* ResolveType(const DexFile& dex_file,
-                     uint32_t type_idx,
+                     uint16_t type_idx,
                      DexCache* dex_cache,
                      const ClassLoader* class_loader);
 
@@ -244,7 +245,8 @@
   void VerifyClass(Class* klass);
 
   Class* CreateProxyClass(String* name, ObjectArray<Class>* interfaces, ClassLoader* loader,
-      ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws);
+                          ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws);
+  std::string GetDescriptorForProxy(const Class* proxy_class);
 
   pid_t GetClassesLockOwner(); // For SignalCatcher.
   pid_t GetDexLockOwner(); // For SignalCatcher.
@@ -303,10 +305,6 @@
                  SirtRef<Class>& klass,
                  const ClassLoader* class_loader);
 
-  void LoadInterfaces(const DexFile& dex_file,
-                      const DexFile::ClassDef& dex_class_def,
-                      SirtRef<Class>& klass);
-
   void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, SirtRef<Class>& klass,
                  SirtRef<Field>& dst);
 
@@ -340,11 +338,11 @@
 
   bool LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file);
 
-  bool LinkMethods(SirtRef<Class>& klass);
+  bool LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
 
   bool LinkVirtualMethods(SirtRef<Class>& klass);
 
-  bool LinkInterfaceMethods(SirtRef<Class>& klass);
+  bool LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
 
   bool LinkStaticFields(SirtRef<Class>& klass);
   bool LinkInstanceFields(SirtRef<Class>& klass);
@@ -364,8 +362,8 @@
   const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file);
   const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location);
 
-  Method* CreateProxyConstructor(SirtRef<Class>& klass);
-  Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype, ObjectArray<Class>* throws);
+  Method* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class);
+  Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype);
 
   const bool verbose_;
 
@@ -433,18 +431,7 @@
     return klass;
   }
 
-  void SetClassRoot(ClassRoot class_root, Class* klass) {
-    DCHECK(!init_done_);
-
-    DCHECK(klass != NULL);
-    DCHECK(klass->GetClassLoader() == NULL);
-    DCHECK(klass->GetDescriptor() != NULL);
-    DCHECK(klass->GetDescriptor()->Equals(GetClassRootDescriptor(class_root)));
-
-    DCHECK(class_roots_ != NULL);
-    DCHECK(class_roots_->Get(class_root) == NULL);
-    class_roots_->Set(class_root, klass);
-  }
+  void SetClassRoot(ClassRoot class_root, Class* klass);
 
   ObjectArray<Class>* GetClassRoots() {
     DCHECK(class_roots_ != NULL);
@@ -459,7 +446,6 @@
     return descriptor;
   }
 
-  ObjectArray<Class>* array_interfaces_;
   ObjectArray<InterfaceEntry>* array_iftable_;
 
   bool init_done_;
@@ -469,6 +455,7 @@
   friend class CommonTest;
   friend class ImageWriter;  // for GetClassRoots
   friend class ObjectTest;
+  FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
   FRIEND_TEST(DexCacheTest, Open);
   FRIEND_TEST(ExceptionTest, FindExceptionHandler);
   FRIEND_TEST(ObjectTest, AllocObjectArray);
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index b51822f..c335ba9 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -30,11 +30,12 @@
   }
 
   void AssertPrimitiveClass(const std::string& descriptor, const Class* primitive) {
+    ClassHelper primitive_ch(primitive);
     ASSERT_TRUE(primitive != NULL);
     ASSERT_TRUE(primitive->GetClass() != NULL);
     ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
     EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != NULL);
-    ASSERT_TRUE(primitive->GetDescriptor()->Equals(descriptor));
+    ASSERT_STREQ(descriptor.c_str(), primitive_ch.GetDescriptor().c_str());
     EXPECT_TRUE(primitive->GetSuperClass() == NULL);
     EXPECT_FALSE(primitive->HasSuperClass());
     EXPECT_TRUE(primitive->GetClassLoader() == NULL);
@@ -56,7 +57,7 @@
     EXPECT_EQ(0U, primitive->NumVirtualMethods());
     EXPECT_EQ(0U, primitive->NumInstanceFields());
     EXPECT_EQ(0U, primitive->NumStaticFields());
-    EXPECT_EQ(0U, primitive->NumInterfaces());
+    EXPECT_EQ(0U, primitive_ch.NumInterfaces());
     EXPECT_TRUE(primitive->GetVTable() == NULL);
     EXPECT_EQ(0, primitive->GetIfTableCount());
     EXPECT_TRUE(primitive->GetIfTable() == NULL);
@@ -66,22 +67,25 @@
                         const std::string& component_type,
                         const ClassLoader* class_loader) {
     Class* array = class_linker_->FindClass(array_descriptor, class_loader);
-    EXPECT_TRUE(array->GetComponentType()->GetDescriptor()->Equals(component_type));
+    ClassHelper array_component_ch(array->GetComponentType());
+    EXPECT_STREQ(component_type.c_str(), array_component_ch.GetDescriptor().c_str());
     EXPECT_EQ(class_loader, array->GetClassLoader());
     AssertArrayClass(array_descriptor, array);
   }
 
   void AssertArrayClass(const std::string& array_descriptor, Class* array) {
+    ClassHelper kh(array);
     ASSERT_TRUE(array != NULL);
     ASSERT_TRUE(array->GetClass() != NULL);
     ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
     EXPECT_TRUE(array->GetClass()->GetSuperClass() != NULL);
-    ASSERT_TRUE(array->GetDescriptor()->Equals(array_descriptor));
+    ASSERT_STREQ(array_descriptor.c_str(), kh.GetDescriptor().c_str());
     EXPECT_TRUE(array->GetSuperClass() != NULL);
     EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Object;"), array->GetSuperClass());
     EXPECT_TRUE(array->HasSuperClass());
     ASSERT_TRUE(array->GetComponentType() != NULL);
-    ASSERT_TRUE(array->GetComponentType()->GetDescriptor() != NULL);
+    kh.ChangeClass(array->GetComponentType());
+    ASSERT_TRUE(kh.GetDescriptor() != NULL);
     EXPECT_EQ(Class::kStatusInitialized, array->GetStatus());
     EXPECT_FALSE(array->IsErroneous());
     EXPECT_TRUE(array->IsLoaded());
@@ -99,20 +103,25 @@
     EXPECT_EQ(0U, array->NumVirtualMethods());
     EXPECT_EQ(0U, array->NumInstanceFields());
     EXPECT_EQ(0U, array->NumStaticFields());
-    EXPECT_EQ(2U, array->NumInterfaces());
+    kh.ChangeClass(array);
+    EXPECT_EQ(2U, kh.NumInterfaces());
     EXPECT_TRUE(array->GetVTable() != NULL);
     EXPECT_EQ(2, array->GetIfTableCount());
     ObjectArray<InterfaceEntry>* iftable = array->GetIfTable();
     ASSERT_TRUE(iftable != NULL);
-    EXPECT_TRUE(iftable->Get(0)->GetInterface()->GetDescriptor()->Equals("Ljava/lang/Cloneable;"));
-    EXPECT_TRUE(iftable->Get(1)->GetInterface()->GetDescriptor()->Equals("Ljava/io/Serializable;"));
+    kh.ChangeClass(kh.GetInterface(0));
+    EXPECT_STREQ(kh.GetDescriptor().c_str(), "Ljava/lang/Cloneable;");
+    kh.ChangeClass(array);
+    kh.ChangeClass(kh.GetInterface(1));
+    EXPECT_STREQ(kh.GetDescriptor().c_str(), "Ljava/io/Serializable;");
   }
 
   void AssertMethod(Class* klass, Method* method) {
+    MethodHelper mh(method);
     EXPECT_TRUE(method != NULL);
     EXPECT_TRUE(method->GetClass() != NULL);
-    EXPECT_TRUE(method->GetName() != NULL);
-    EXPECT_TRUE(method->GetSignature() != NULL);
+    EXPECT_TRUE(mh.GetName() != NULL);
+    EXPECT_TRUE(mh.GetSignature() != NULL);
 
     EXPECT_TRUE(method->GetDexCacheStrings() != NULL);
     EXPECT_TRUE(method->GetDexCacheResolvedTypes() != NULL);
@@ -135,17 +144,18 @@
   }
 
   void AssertField(Class* klass, Field* field) {
+    FieldHelper fh(field);
     EXPECT_TRUE(field != NULL);
     EXPECT_TRUE(field->GetClass() != NULL);
     EXPECT_EQ(klass, field->GetDeclaringClass());
-    EXPECT_TRUE(field->GetName() != NULL);
-    EXPECT_TRUE(field->GetType() != NULL);
+    EXPECT_TRUE(fh.GetName() != NULL);
+    EXPECT_TRUE(fh.GetType() != NULL);
   }
 
   void AssertClass(const std::string& descriptor, Class* klass) {
-    EXPECT_TRUE(klass->GetDescriptor()->Equals(descriptor));
-    SirtRef<String> Object_descriptor(String::AllocFromModifiedUtf8("Ljava/lang/Object;"));
-    if (klass->GetDescriptor()->Equals(Object_descriptor.get())) {
+    ClassHelper kh(klass);
+    EXPECT_STREQ(descriptor.c_str(), kh.GetDescriptor().c_str());
+    if (descriptor == "Ljava/lang/Object;") {
       EXPECT_FALSE(klass->HasSuperClass());
     } else {
       EXPECT_TRUE(klass->HasSuperClass());
@@ -160,11 +170,12 @@
     EXPECT_FALSE(klass->IsArrayClass());
     EXPECT_TRUE(klass->GetComponentType() == NULL);
     EXPECT_TRUE(klass->IsInSamePackage(klass));
-    EXPECT_TRUE(Class::IsInSamePackage(klass->GetDescriptor(), klass->GetDescriptor()));
+    EXPECT_TRUE(Class::IsInSamePackage(kh.GetDescriptor(), kh.GetDescriptor()));
     if (klass->IsInterface()) {
       EXPECT_TRUE(klass->IsAbstract());
       if (klass->NumDirectMethods() == 1) {
-        EXPECT_TRUE(klass->GetDirectMethod(0)->IsClassInitializer());
+        MethodHelper mh(klass->GetDirectMethod(0));
+        EXPECT_TRUE(mh.IsClassInitializer());
         EXPECT_TRUE(klass->GetDirectMethod(0)->IsDirect());
       } else {
         EXPECT_EQ(0U, klass->NumDirectMethods());
@@ -233,18 +244,21 @@
 
     // Confirm that all instances fields are packed together at the start
     EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
+    FieldHelper fh;
     for (size_t i = 0; i < klass->NumReferenceInstanceFields(); i++) {
       Field* field = klass->GetInstanceField(i);
-      ASSERT_TRUE(!field->IsPrimitiveType());
-      Class* field_type = field->GetType();
+      fh.ChangeField(field);
+      ASSERT_TRUE(!fh.IsPrimitiveType());
+      Class* field_type = fh.GetType();
       ASSERT_TRUE(field_type != NULL);
       ASSERT_TRUE(!field_type->IsPrimitive());
     }
     for (size_t i = klass->NumReferenceInstanceFields(); i < klass->NumInstanceFields(); i++) {
       Field* field = klass->GetInstanceField(i);
-      Class* field_type = field->GetType();
+      fh.ChangeField(field);
+      Class* field_type = fh.GetType();
       ASSERT_TRUE(field_type != NULL);
-      if (!field->IsPrimitiveType() || !field_type->IsPrimitive()) {
+      if (!fh.IsPrimitiveType() || !field_type->IsPrimitive()) {
         // While Reference.referent is not primitive, the ClassLinker
         // treats it as such so that the garbage collector won't scan it.
         EXPECT_EQ(PrettyField(field), "java.lang.Object java.lang.ref.Reference.referent");
@@ -265,7 +279,7 @@
     ASSERT_TRUE(descriptor != NULL);
     Class* klass = class_linker_->FindSystemClass(descriptor);
     ASSERT_TRUE(klass != NULL);
-    EXPECT_TRUE(klass->GetDescriptor()->Equals(descriptor));
+    EXPECT_STREQ(descriptor.c_str(), ClassHelper(klass).GetDescriptor().c_str());
     EXPECT_EQ(class_loader, klass->GetClassLoader());
     if (klass->IsPrimitive()) {
       AssertPrimitiveClass(descriptor, klass);
@@ -339,9 +353,12 @@
       error = true;
     }
 
+    FieldHelper fh;
     for (size_t i = 0; i < offsets.size(); i++) {
       Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
-      if (!field->GetName()->Equals(offsets[i].java_name)) {
+      fh.ChangeField(field);
+      StringPiece field_name(fh.GetName());
+      if (field_name != offsets[i].java_name) {
         error = true;
       }
     }
@@ -349,12 +366,14 @@
       for (size_t i = 0; i < offsets.size(); i++) {
         CheckOffset& offset = offsets[i];
         Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
-        if (!field->GetName()->Equals(offsets[i].java_name)) {
+        fh.ChangeField(field);
+        StringPiece field_name(fh.GetName());
+        if (field_name != offsets[i].java_name) {
           LG << "JAVA FIELD ORDER MISMATCH NEXT LINE:";
         }
         LG << "Java field order:"
            << " i=" << i << " class=" << class_descriptor
-           << " Java=" << field->GetName()->ToModifiedUtf8()
+           << " Java=" << field_name
            << " CheckOffsets=" << offset.java_name;
       }
     }
@@ -401,17 +420,12 @@
 struct FieldOffsets : public CheckOffsets<Field> {
   FieldOffsets() : CheckOffsets<Field>(false, "Ljava/lang/reflect/Field;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, declaring_class_),               "declaringClass"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, generic_type_),                  "genericType"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, name_),                          "name"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, type_),                          "type"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, declaring_class_), "declaringClass"));
 
     // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, generic_types_are_initialized_), "genericTypesAreInitialized"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, access_flags_),                  "shadow$_access_flags_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, offset_),                        "shadow$_offset_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, type_idx_),                      "shadow$_type_idx_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, slot_),                          "slot"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, access_flags_),    "accessFlags"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, field_dex_idx_),   "fieldDexIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, offset_),          "offset"));
   };
 };
 
@@ -419,43 +433,27 @@
   MethodOffsets() : CheckOffsets<Method>(false, "Ljava/lang/reflect/Method;") {
     // alphabetical references
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, declaring_class_),                      "declaringClass"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_exception_types_),                 "exceptionTypes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_formal_type_parameters_),          "formalTypeParameters"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_generic_exception_types_),         "genericExceptionTypes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_generic_parameter_types_),         "genericParameterTypes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_generic_return_type_),             "genericReturnType"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, name_),                                 "name"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_parameter_types_),                 "parameterTypes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_return_type_),                     "returnType"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_code_and_direct_methods_),    "shadow$_dex_cache_code_and_direct_methods_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_initialized_static_storage_), "shadow$_dex_cache_initialized_static_storage_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_fields_),            "shadow$_dex_cache_resolved_fields_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_methods_),           "shadow$_dex_cache_resolved_methods_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_types_),             "shadow$_dex_cache_resolved_types_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_strings_),                    "shadow$_dex_cache_strings_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, gc_map_),                               "shadow$_gc_map_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, shorty_),                               "shadow$_shorty_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, signature_),                            "shadow$_signature_"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_code_and_direct_methods_),    "dexCacheCodeAndDirectMethods"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_initialized_static_storage_), "dexCacheInitializedStaticStorage"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_fields_),            "dexCacheResolvedFields"));
+    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, java_generic_types_are_initialized_),   "genericTypesAreInitialized"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, access_flags_),                         "shadow$_access_flags_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_),                                 "shadow$_code_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_item_offset_),                     "shadow$_code_item_offset_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, core_spill_mask_),                      "shadow$_core_spill_mask_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, fp_spill_mask_),                        "shadow$_fp_spill_mask_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, frame_size_in_bytes_),                  "shadow$_frame_size_in_bytes_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, invoke_stub_),                          "shadow$_invoke_stub_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_return_type_idx_),                 "shadow$_java_return_type_idx_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, mapping_table_),                        "shadow$_mapping_table_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_index_),                         "shadow$_method_index_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, native_method_),                        "shadow$_native_method_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, num_ins_),                              "shadow$_num_ins_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, num_outs_),                             "shadow$_num_outs_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, num_registers_),                        "shadow$_num_registers_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, proto_idx_),                            "shadow$_proto_idx_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, vmap_table_),                           "shadow$_vmap_table_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_slot_),                            "slot"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, access_flags_),        "accessFlags"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_),                "code"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_item_offset_),    "codeItemOffset"));
+    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, invoke_stub_),         "invokeStub"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, mapping_table_),       "mappingTable"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_dex_index_),    "methodDexIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_index_),        "methodIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, native_method_),       "nativeMethod"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, vmap_table_),          "vmapTable"));
   };
 };
 
@@ -472,23 +470,19 @@
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, name_),                          "name"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, class_loader_),                  "shadow$_class_loader_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, component_type_),                "shadow$_component_type_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, descriptor_),                    "shadow$_descriptor_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, dex_cache_),                     "shadow$_dex_cache_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, direct_methods_),                "shadow$_direct_methods_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, ifields_),                       "shadow$_ifields_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, iftable_),                       "shadow$_iftable_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, interfaces_),                    "shadow$_interfaces_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, interfaces_type_idx_),           "shadow$_interfaces_type_idx_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, sfields_),                       "shadow$_sfields_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, source_file_),                   "shadow$_source_file_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, super_class_),                   "shadow$_super_class_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, verify_error_class_),            "shadow$_verify_error_class_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, virtual_methods_),               "shadow$_virtual_methods_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, vtable_),                        "shadow$_vtable_"));
 
     // alphabetical 32-bit
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, dex_type_idx_),                  "dexTypeIndex"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, access_flags_),                  "shadow$_access_flags_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, annotations_offset_),            "shadow$_annotations_offset_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, class_size_),                    "shadow$_class_size_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, clinit_thread_id_),              "shadow$_clinit_thread_id_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, num_reference_instance_fields_), "shadow$_num_reference_instance_fields_"));
@@ -498,8 +492,6 @@
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, reference_instance_offsets_),    "shadow$_reference_instance_offsets_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, reference_static_offsets_),      "shadow$_reference_static_offsets_"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, status_),                        "shadow$_status_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, super_class_type_idx_),          "shadow$_super_class_type_idx_"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, type_idx_),                      "shadow$_type_idx_"));
   };
 };
 
@@ -595,16 +587,6 @@
   FieldClassOffsets() : CheckOffsets<FieldClass>(true, "Ljava/lang/reflect/Field;") {
     // alphabetical references
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, ORDER_BY_NAME_AND_DECLARING_CLASS_), "ORDER_BY_NAME_AND_DECLARING_CLASS"));
-
-    // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_BOOLEAN_), "TYPE_BOOLEAN"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_BYTE_),    "TYPE_BYTE"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_CHAR_),    "TYPE_CHAR"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_DOUBLE_),  "TYPE_DOUBLE"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_FLOAT_),   "TYPE_FLOAT"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_INTEGER_), "TYPE_INTEGER"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_LONG_),    "TYPE_LONG"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, TYPE_SHORT_),   "TYPE_SHORT"));
   };
 };
 
@@ -683,11 +665,12 @@
 
 TEST_F(ClassLinkerTest, FindClass) {
   Class* JavaLangObject = class_linker_->FindSystemClass("Ljava/lang/Object;");
+  ClassHelper kh(JavaLangObject);
   ASSERT_TRUE(JavaLangObject != NULL);
   ASSERT_TRUE(JavaLangObject->GetClass() != NULL);
   ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
   EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
-  ASSERT_TRUE(JavaLangObject->GetDescriptor()->Equals("Ljava/lang/Object;"));
+  ASSERT_STREQ(kh.GetDescriptor().c_str(), "Ljava/lang/Object;");
   EXPECT_TRUE(JavaLangObject->GetSuperClass() == NULL);
   EXPECT_FALSE(JavaLangObject->HasSuperClass());
   EXPECT_TRUE(JavaLangObject->GetClassLoader() == NULL);
@@ -708,20 +691,23 @@
   EXPECT_EQ(2U, JavaLangObject->NumDirectMethods());
   EXPECT_EQ(11U, JavaLangObject->NumVirtualMethods());
   EXPECT_EQ(2U, JavaLangObject->NumInstanceFields());
-  EXPECT_TRUE(JavaLangObject->GetInstanceField(0)->GetName()->Equals("shadow$_klass_"));
-  EXPECT_TRUE(JavaLangObject->GetInstanceField(1)->GetName()->Equals("shadow$_monitor_"));
+  FieldHelper fh(JavaLangObject->GetInstanceField(0));
+  EXPECT_STREQ(fh.GetName(), "shadow$_klass_");
+  fh.ChangeField(JavaLangObject->GetInstanceField(1));
+  EXPECT_STREQ(fh.GetName(), "shadow$_monitor_");
 
   EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
-  EXPECT_EQ(0U, JavaLangObject->NumInterfaces());
+  EXPECT_EQ(0U, kh.NumInterfaces());
 
   SirtRef<ClassLoader> class_loader(LoadDex("MyClass"));
   AssertNonExistentClass("LMyClass;");
   Class* MyClass = class_linker_->FindClass("LMyClass;", class_loader.get());
+  kh.ChangeClass(MyClass);
   ASSERT_TRUE(MyClass != NULL);
   ASSERT_TRUE(MyClass->GetClass() != NULL);
   ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
   EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
-  ASSERT_TRUE(MyClass->GetDescriptor()->Equals("LMyClass;"));
+  ASSERT_STREQ(kh.GetDescriptor().c_str(), "LMyClass;");
   EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
   EXPECT_TRUE(MyClass->HasSuperClass());
   EXPECT_EQ(class_loader.get(), MyClass->GetClassLoader());
@@ -743,7 +729,7 @@
   EXPECT_EQ(0U, MyClass->NumVirtualMethods());
   EXPECT_EQ(0U, MyClass->NumInstanceFields());
   EXPECT_EQ(0U, MyClass->NumStaticFields());
-  EXPECT_EQ(0U, MyClass->NumInterfaces());
+  EXPECT_EQ(0U, kh.NumInterfaces());
 
   EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
 
@@ -785,21 +771,29 @@
   // This lets UnboxPrimitive avoid searching for the field by name at runtime.
   Class* c;
   c = class_linker_->FindClass("Ljava/lang/Boolean;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  FieldHelper fh(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Byte;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Character;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Double;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Float;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Integer;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Long;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
   c = class_linker_->FindClass("Ljava/lang/Short;", NULL);
-  EXPECT_EQ("value", c->GetIFields()->Get(0)->GetName()->ToModifiedUtf8());
+  fh.ChangeField(c->GetIFields()->Get(0));
+  EXPECT_STREQ("value", fh.GetName());
 }
 
 TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
@@ -826,48 +820,57 @@
   EXPECT_EQ(9U, statics->NumStaticFields());
 
   Field* s0 = statics->FindStaticField("s0", "Z");
-  EXPECT_TRUE(s0->GetClass()->GetDescriptor()->Equals("Ljava/lang/reflect/Field;"));
-  EXPECT_TRUE(s0->GetPrimitiveType() == Primitive::kPrimBoolean);
+  FieldHelper fh(s0);
+  EXPECT_STREQ(ClassHelper(s0->GetClass()).GetDescriptor().c_str(), "Ljava/lang/reflect/Field;");
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimBoolean);
   EXPECT_EQ(true, s0->GetBoolean(NULL));
   s0->SetBoolean(NULL, false);
 
   Field* s1 = statics->FindStaticField("s1", "B");
-  EXPECT_TRUE(s1->GetPrimitiveType() == Primitive::kPrimByte);
+  fh.ChangeField(s1);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimByte);
   EXPECT_EQ(5, s1->GetByte(NULL));
   s1->SetByte(NULL, 6);
 
   Field* s2 = statics->FindStaticField("s2", "C");
-  EXPECT_TRUE(s2->GetPrimitiveType() == Primitive::kPrimChar);
+  fh.ChangeField(s2);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimChar);
   EXPECT_EQ('a', s2->GetChar(NULL));
   s2->SetChar(NULL, 'b');
 
   Field* s3 = statics->FindStaticField("s3", "S");
-  EXPECT_TRUE(s3->GetPrimitiveType() == Primitive::kPrimShort);
+  fh.ChangeField(s3);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimShort);
   EXPECT_EQ(-536, s3->GetShort(NULL));
   s3->SetShort(NULL, -535);
 
   Field* s4 = statics->FindStaticField("s4", "I");
-  EXPECT_TRUE(s4->GetPrimitiveType() == Primitive::kPrimInt);
+  fh.ChangeField(s4);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimInt);
   EXPECT_EQ(2000000000, s4->GetInt(NULL));
   s4->SetInt(NULL, 2000000001);
 
   Field* s5 = statics->FindStaticField("s5", "J");
-  EXPECT_TRUE(s5->GetPrimitiveType() == Primitive::kPrimLong);
+  fh.ChangeField(s5);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimLong);
   EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong(NULL));
   s5->SetLong(NULL, 0x34567890abcdef12LL);
 
   Field* s6 = statics->FindStaticField("s6", "F");
-  EXPECT_TRUE(s6->GetPrimitiveType() == Primitive::kPrimFloat);
+  fh.ChangeField(s6);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimFloat);
   EXPECT_EQ(0.5, s6->GetFloat(NULL));
   s6->SetFloat(NULL, 0.75);
 
   Field* s7 = statics->FindStaticField("s7", "D");
-  EXPECT_TRUE(s7->GetPrimitiveType() == Primitive::kPrimDouble);
+  fh.ChangeField(s7);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimDouble);
   EXPECT_EQ(16777217, s7->GetDouble(NULL));
   s7->SetDouble(NULL, 16777219);
 
   Field* s8 = statics->FindStaticField("s8", "Ljava/lang/String;");
-  EXPECT_TRUE(s8->GetPrimitiveType() == Primitive::kPrimNot);
+  fh.ChangeField(s8);
+  EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimNot);
   EXPECT_TRUE(s8->GetObject(NULL)->AsString()->Equals("android"));
   s8->SetObject(NULL, String::AllocFromModifiedUtf8("robot"));
 
@@ -986,4 +989,15 @@
   EXPECT_TRUE(c->IsFinalizable());
 }
 
+TEST_F(ClassLinkerTest, ClassRootDescriptors) {
+  ClassHelper kh;
+  for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
+    Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
+    kh.ChangeClass(klass);
+    EXPECT_TRUE(kh.GetDescriptor() != NULL);
+    EXPECT_STREQ(kh.GetDescriptor().c_str(),
+                 class_linker_->GetClassRootDescriptor(ClassLinker::ClassRoot(i))) << " i = " << i;
+  }
+}
+
 }  // namespace art
diff --git a/src/common_test.h b/src/common_test.h
index d140d40..48a9c39 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -17,6 +17,7 @@
 #include "gtest/gtest.h"
 #include "heap.h"
 #include "oat_file.h"
+#include "object_utils.h"
 #include "os.h"
 #include "runtime.h"
 #include "stl_util.h"
@@ -118,9 +119,9 @@
   void MakeExecutable(Method* method) {
     CHECK(method != NULL);
 
+    MethodHelper mh(method);
     const CompiledInvokeStub* compiled_invoke_stub =
-        compiler_->FindInvokeStub(method->IsStatic(),
-                                  method->GetShorty()->ToModifiedUtf8().c_str());
+        compiler_->FindInvokeStub(mh.IsStatic(), mh.GetShorty());
     CHECK(compiled_invoke_stub != NULL) << PrettyMethod(method);
     const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
     MakeExecutable(invoke_stub);
diff --git a/src/compiler.cc b/src/compiler.cc
index fba767d..e437062 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -11,6 +11,7 @@
 #include "jni_compiler.h"
 #include "jni_internal.h"
 #include "oat_file.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "stl_util.h"
 
@@ -145,6 +146,18 @@
   return image_classes_->find(descriptor) != image_classes_->end();
 }
 
+bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache,
+                                                uint32_t type_idx) const {
+  if (!IsImage()) {
+    return false;
+  }
+  Class* resolved_class = dex_cache->GetResolvedTypes()->Get(type_idx);
+  if (resolved_class == NULL) {
+    return false;
+  }
+  return IsImageClass(ClassHelper(resolved_class).GetDescriptor());
+}
+
 // Return true if the class should be skipped during compilation. We
 // never skip classes in the boot class loader. However, if we have a
 // non-boot class loader and we can resolve the class in the boot
diff --git a/src/compiler.h b/src/compiler.h
index 5203ffb..4e1be1d 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -70,16 +70,7 @@
   const CompiledInvokeStub* FindInvokeStub(bool is_static, const char* shorty) const;
 
   // Callbacks from OAT/ART compiler to see what runtime checks must be generated
-  bool CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache, uint32_t type_idx) const {
-    if (!IsImage()) {
-      return false;
-    }
-    Class* resolved_class = dex_cache->GetResolvedTypes()->Get(type_idx);
-    if (resolved_class == NULL) {
-      return false;
-    }
-    return IsImageClass(resolved_class->GetDescriptor()->ToModifiedUtf8());
-  }
+  bool CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache, uint32_t type_idx) const;
   bool CanAssumeStringIsPresentInDexCache(const DexCache* dex_cache, uint32_t string_idx) const {
     // TODO: Add support for loading strings referenced by image_classes_
     // See also Compiler::ResolveDexFile
diff --git a/src/compiler/codegen/arm/ArmRallocUtil.cc b/src/compiler/codegen/arm/ArmRallocUtil.cc
index 5d2c4e6..60a5f38 100644
--- a/src/compiler/codegen/arm/ArmRallocUtil.cc
+++ b/src/compiler/codegen/arm/ArmRallocUtil.cc
@@ -263,17 +263,19 @@
 
 
 /* Return sp-relative offset in bytes using Method* */
-extern int oatVRegOffsetFromMethod(Method* method, int reg)
+extern int oatVRegOffset(const art::DexFile::CodeItem* code_item,
+                         uint32_t core_spills, uint32_t fp_spills,
+                         size_t frame_size, int reg)
 {
-    int numIns = method->NumIns();
-    int numRegs = method->NumRegisters() - numIns;
-    int numOuts = method->NumOuts();
-    int numSpills = __builtin_popcount(method->GetCoreSpillMask()) +
-                    __builtin_popcount(method->GetFpSpillMask());
+    int numIns = code_item->ins_size_;
+    int numRegs = code_item->registers_size_ - numIns;
+    int numOuts = code_item->outs_size_;
+    int numSpills = __builtin_popcount(core_spills) +
+                    __builtin_popcount(fp_spills);
     int numPadding = (STACK_ALIGN_WORDS -
         (numSpills + numRegs + numOuts + 2)) & (STACK_ALIGN_WORDS-1);
     int regsOffset = (numOuts + numPadding + 1) * 4;
-    int insOffset = method->GetFrameSizeInBytes() + 4;
+    int insOffset = frame_size + 4;
     return (reg < numRegs) ? regsOffset + (reg << 2) :
            insOffset + ((reg - numRegs) << 2);
 }
diff --git a/src/compiler/codegen/arm/MethodCodegenDriver.cc b/src/compiler/codegen/arm/MethodCodegenDriver.cc
index 15fd1ba..2c3ee0d 100644
--- a/src/compiler/codegen/arm/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/arm/MethodCodegenDriver.cc
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "object_utils.h"
+
 #define DISPLAY_MISSING_TARGETS (cUnit->enableDebug & \
     (1 << kDebugDisplayMissingTargets))
 
@@ -192,7 +194,7 @@
     // See if we can find a dex reference for the storage class.
     // we may not if the dex file never references the super class,
     // but usually it will.
-    std::string descriptor = field->GetDeclaringClass()->GetDescriptor()->ToModifiedUtf8();
+    std::string descriptor(art::FieldHelper(field).GetDeclaringClassDescriptor());
     const art::DexFile::StringId* string_id =
         cUnit->dex_file->FindStringId(descriptor);
     if (string_id == NULL) {
diff --git a/src/dalvik_system_VMRuntime.cc b/src/dalvik_system_VMRuntime.cc
index d4c1ed2..f8be881 100644
--- a/src/dalvik_system_VMRuntime.cc
+++ b/src/dalvik_system_VMRuntime.cc
@@ -18,6 +18,7 @@
 #include "debugger.h"
 #include "jni_internal.h"
 #include "object.h"
+#include "object_utils.h"
 #include "thread.h"
 
 #include "JniConstants.h" // Last to avoid problems with LOG redefinition.
@@ -65,7 +66,7 @@
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   std::string descriptor;
   descriptor += "[";
-  descriptor += element_class->GetDescriptor()->ToModifiedUtf8();
+  descriptor += ClassHelper(element_class).GetDescriptor();
   Class* array_class = class_linker->FindClass(descriptor, NULL);
   Array* result = Array::Alloc(array_class, length);
   if (result == NULL) {
diff --git a/src/debugger.cc b/src/debugger.cc
index 3a6c154..b2f9629 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -23,6 +23,7 @@
 #include "class_linker.h"
 #include "class_loader.h"
 #include "context.h"
+#include "object_utils.h"
 #include "ScopedLocalRef.h"
 #include "ScopedPrimitiveArray.h"
 #include "stack_indirect_reference_table.h"
@@ -87,15 +88,11 @@
 };
 
 struct AllocRecordStackTraceElement {
-  const Method* method;
+  Method* method;
   uintptr_t raw_pc;
 
   int32_t LineNumber() const {
-    ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-    Class* c = method->GetDeclaringClass();
-    DexCache* dex_cache = c->GetDexCache();
-    const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
-    return dex_file.GetLineNumFromPC(method, method->ToDexPC(raw_pc));
+    return MethodHelper(method).GetLineNumFromNativePC(raw_pc);
   }
 };
 
@@ -452,7 +449,7 @@
 
 std::string Dbg::GetClassDescriptor(JDWP::RefTypeId classId) {
   Class* c = gRegistry->Get<Class*>(classId);
-  return c->GetDescriptor()->ToModifiedUtf8();
+  return ClassHelper(c).GetDescriptor();
 }
 
 JDWP::ObjectId Dbg::GetClassObject(JDWP::RefTypeId id) {
@@ -527,7 +524,7 @@
   }
 
   if (pDescriptor != NULL) {
-    *pDescriptor = c->GetDescriptor()->ToModifiedUtf8();
+    *pDescriptor = ClassHelper(c).GetDescriptor();
   }
 }
 
@@ -560,19 +557,14 @@
 std::string Dbg::GetSignature(JDWP::RefTypeId refTypeId) {
   Class* c = gRegistry->Get<Class*>(refTypeId);
   CHECK(c != NULL);
-  return c->GetDescriptor()->ToModifiedUtf8();
+  return ClassHelper(c).GetDescriptor();
 }
 
 bool Dbg::GetSourceFile(JDWP::RefTypeId refTypeId, std::string& result) {
   Class* c = gRegistry->Get<Class*>(refTypeId);
   CHECK(c != NULL);
-
-  String* source_file = c->GetSourceFile();
-  if (source_file == NULL) {
-    return false;
-  }
-  result = source_file->ToModifiedUtf8();
-  return true;
+  result = ClassHelper(c).GetSourceFile();
+  return result == NULL;
 }
 
 uint8_t Dbg::GetObjectTag(JDWP::ObjectId objectId) {
@@ -619,7 +611,7 @@
 uint8_t Dbg::GetArrayElementTag(JDWP::ObjectId arrayId) {
   Object* o = gRegistry->Get<Object*>(arrayId);
   Array* a = o->AsArray();
-  std::string descriptor(a->GetClass()->GetDescriptor()->ToModifiedUtf8());
+  std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
   JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
   if (!IsPrimitiveTag(tag)) {
     tag = TagFromClass(a->GetClass()->GetComponentType());
@@ -635,8 +627,7 @@
     LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
     return false;
   }
-
-  std::string descriptor(a->GetClass()->GetDescriptor()->ToModifiedUtf8());
+  std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
   JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
 
   if (IsPrimitiveTag(tag)) {
@@ -676,8 +667,7 @@
     LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
     return false;
   }
-
-  std::string descriptor(a->GetClass()->GetDescriptor()->ToModifiedUtf8());
+  std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
   JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
 
   if (IsPrimitiveTag(tag)) {
@@ -763,7 +753,8 @@
 }
 
 std::string Dbg::GetMethodName(JDWP::RefTypeId refTypeId, JDWP::MethodId methodId) {
-  return FromMethodId(methodId)->GetName()->ToModifiedUtf8();
+  Method* m = FromMethodId(methodId);
+  return MethodHelper(m).GetName();
 }
 
 /*
@@ -808,8 +799,8 @@
   if (slot == kEclipseWorkaroundSlot) {
     return 0;
   } else if (slot == 0) {
-    Method* m = f.GetMethod();
-    return m->NumRegisters() - m->NumIns();
+    const DexFile::CodeItem* code_item = MethodHelper(f.GetMethod()).GetCodeItem();
+    return code_item->registers_size_ - code_item->ins_size_;
   }
   return slot;
 }
@@ -825,10 +816,10 @@
 
   for (size_t i = 0; i < instance_field_count + static_field_count; ++i) {
     Field* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
-
+    FieldHelper fh(f);
     expandBufAddFieldId(pReply, ToFieldId(f));
-    expandBufAddUtf8String(pReply, f->GetName()->ToModifiedUtf8().c_str());
-    expandBufAddUtf8String(pReply, f->GetTypeDescriptor());
+    expandBufAddUtf8String(pReply, fh.GetName());
+    expandBufAddUtf8String(pReply, fh.GetTypeDescriptor());
     if (with_generic) {
       static const char genericSignature[1] = "";
       expandBufAddUtf8String(pReply, genericSignature);
@@ -848,10 +839,10 @@
 
   for (size_t i = 0; i < direct_method_count + virtual_method_count; ++i) {
     Method* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
-
+    MethodHelper mh(m);
     expandBufAddMethodId(pReply, ToMethodId(m));
-    expandBufAddUtf8String(pReply, m->GetName()->ToModifiedUtf8().c_str());
-    expandBufAddUtf8String(pReply, m->GetSignature()->ToModifiedUtf8().c_str());
+    expandBufAddUtf8String(pReply, mh.GetName());
+    expandBufAddUtf8String(pReply, mh.GetSignature().c_str());
     if (with_generic) {
       static const char genericSignature[1] = "";
       expandBufAddUtf8String(pReply, genericSignature);
@@ -863,10 +854,11 @@
 void Dbg::OutputDeclaredInterfaces(JDWP::RefTypeId refTypeId, JDWP::ExpandBuf* pReply) {
   Class* c = gRegistry->Get<Class*>(refTypeId);
   CHECK(c != NULL);
-  size_t interface_count = c->NumInterfaces();
+  ClassHelper kh(c);
+  size_t interface_count = kh.NumInterfaces();
   expandBufAdd4BE(pReply, interface_count);
   for (size_t i = 0; i < interface_count; ++i) {
-    expandBufAddRefTypeId(pReply, gRegistry->Add(c->GetInterface(i)));
+    expandBufAddRefTypeId(pReply, gRegistry->Add(kh.GetInterface(i)));
   }
 }
 
@@ -885,17 +877,15 @@
   };
 
   Method* m = FromMethodId(methodId);
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(m->GetDeclaringClass()->GetDexCache());
-  const DexFile::CodeItem* code_item = dex_file.GetCodeItem(m->GetCodeItemOffset());
-
+  MethodHelper mh(m);
   uint64_t start, end;
   if (m->IsNative()) {
     start = -1;
     end = -1;
   } else {
     start = 0;
-    end = code_item->insns_size_in_code_units_; // TODO: what are the units supposed to be? *2?
+    // TODO: what are the units supposed to be? *2?
+    end = mh.GetCodeItem()->insns_size_in_code_units_;
   }
 
   expandBufAdd8BE(pReply, start);
@@ -909,7 +899,8 @@
   context.numItems = 0;
   context.pReply = pReply;
 
-  dex_file.DecodeDebugInfo(code_item, m, DebugCallbackContext::Callback, NULL, &context);
+  mh.GetDexFile().DecodeDebugInfo(mh.GetCodeItem(), m->IsStatic(), m->GetDexMethodIndex(),
+                                  DebugCallbackContext::Callback, NULL, &context);
 
   JDWP::Set4BE(expandBufGetBuffer(pReply) + numLinesOffset, context.numItems);
 }
@@ -941,13 +932,12 @@
   };
 
   Method* m = FromMethodId(methodId);
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(m->GetDeclaringClass()->GetDexCache());
-  const DexFile::CodeItem* code_item = dex_file.GetCodeItem(m->GetCodeItemOffset());
+  MethodHelper mh(m);
+  const DexFile::CodeItem* code_item = mh.GetCodeItem();
 
   // arg_count considers doubles and longs to take 2 units.
   // variable_count considers everything to take 1 unit.
-  std::string shorty(m->GetShorty()->ToModifiedUtf8());
+  std::string shorty(mh.GetShorty());
   expandBufAdd4BE(pReply, m->NumArgRegisters(shorty));
 
   // We don't know the total number of variables yet, so leave a blank and update it later.
@@ -959,24 +949,25 @@
   context.variable_count = 0;
   context.with_generic = with_generic;
 
-  dex_file.DecodeDebugInfo(code_item, m, NULL, DebugCallbackContext::Callback, &context);
+  mh.GetDexFile().DecodeDebugInfo(code_item, m->IsStatic(), m->GetDexMethodIndex(), NULL,
+                                  DebugCallbackContext::Callback, &context);
 
   JDWP::Set4BE(expandBufGetBuffer(pReply) + variable_count_offset, context.variable_count);
 }
 
 JDWP::JdwpTag Dbg::GetFieldBasicTag(JDWP::FieldId fieldId) {
-  return BasicTagFromDescriptor(FromFieldId(fieldId)->GetTypeDescriptor());
+  return BasicTagFromDescriptor(FieldHelper(FromFieldId(fieldId)).GetTypeDescriptor());
 }
 
 JDWP::JdwpTag Dbg::GetStaticFieldBasicTag(JDWP::FieldId fieldId) {
-  return BasicTagFromDescriptor(FromFieldId(fieldId)->GetTypeDescriptor());
+  return BasicTagFromDescriptor(FieldHelper(FromFieldId(fieldId)).GetTypeDescriptor());
 }
 
 void Dbg::GetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply) {
   Object* o = gRegistry->Get<Object*>(objectId);
   Field* f = FromFieldId(fieldId);
 
-  JDWP::JdwpTag tag = BasicTagFromDescriptor(f->GetTypeDescriptor());
+  JDWP::JdwpTag tag = BasicTagFromDescriptor(FieldHelper(f).GetTypeDescriptor());
 
   if (IsPrimitiveTag(tag)) {
     expandBufAdd1(pReply, tag);
@@ -1002,7 +993,7 @@
   Object* o = gRegistry->Get<Object*>(objectId);
   Field* f = FromFieldId(fieldId);
 
-  JDWP::JdwpTag tag = BasicTagFromDescriptor(f->GetTypeDescriptor());
+  JDWP::JdwpTag tag = BasicTagFromDescriptor(FieldHelper(f).GetTypeDescriptor());
 
   if (IsPrimitiveTag(tag)) {
     if (tag == JDWP::JT_DOUBLE || tag == JDWP::JT_LONG) {
@@ -2120,11 +2111,11 @@
   StringTable() {
   }
 
-  void Add(const String* s) {
+  void Add(const char* s) {
     table_.insert(s);
   }
 
-  size_t IndexOf(const String* s) {
+  size_t IndexOf(const char* s) {
     return std::distance(table_.begin(), table_.find(s));
   }
 
@@ -2133,15 +2124,18 @@
   }
 
   void WriteTo(std::vector<uint8_t>& bytes) {
-    typedef std::set<const String*>::const_iterator It; // TODO: C++0x auto
+    typedef std::set<const char*>::const_iterator It; // TODO: C++0x auto
     for (It it = table_.begin(); it != table_.end(); ++it) {
-      const String* s = *it;
-      JDWP::AppendUtf16BE(bytes, s->GetCharArray()->GetData(), s->GetLength());
+      const char* s = *it;
+      size_t s_len = CountModifiedUtf8Chars(s);
+      UniquePtr<uint16_t> s_utf16(new uint16_t[s_len]);
+      ConvertModifiedUtf8ToUtf16(s_utf16.get(), s);
+      JDWP::AppendUtf16BE(bytes, s_utf16.get(), s_len);
     }
   }
 
  private:
-  std::set<const String*> table_;
+  std::set<const char*> table_;
   DISALLOW_COPY_AND_ASSIGN(StringTable);
 };
 
@@ -2206,14 +2200,16 @@
   while (count--) {
     AllocRecord* record = &recent_allocation_records_[idx];
 
-    class_names.Add(record->type->GetDescriptor());
+    class_names.Add(ClassHelper(record->type).GetDescriptor().c_str());
 
+    MethodHelper mh;
     for (size_t i = 0; i < kMaxAllocRecordStackDepth; i++) {
-      const Method* m = record->stack[i].method;
+      Method* m = record->stack[i].method;
+      mh.ChangeMethod(m);
       if (m != NULL) {
-        class_names.Add(m->GetDeclaringClass()->GetDescriptor());
-        method_names.Add(m->GetName());
-        filenames.Add(m->GetDeclaringClass()->GetSourceFile());
+        class_names.Add(mh.GetDeclaringClassDescriptor());
+        method_names.Add(mh.GetName());
+        filenames.Add(mh.GetDeclaringClassSourceFile());
       }
     }
 
@@ -2251,6 +2247,7 @@
 
   count = gAllocRecordCount;
   idx = headIndex();
+  ClassHelper kh;
   while (count--) {
     // For each entry:
     // (4b) total allocation size
@@ -2261,19 +2258,21 @@
     size_t stack_depth = record->GetDepth();
     JDWP::Append4BE(bytes, record->byte_count);
     JDWP::Append2BE(bytes, record->thin_lock_id);
-    JDWP::Append2BE(bytes, class_names.IndexOf(record->type->GetDescriptor()));
+    kh.ChangeClass(record->type);
+    JDWP::Append2BE(bytes, class_names.IndexOf(kh.GetDescriptor().c_str()));
     JDWP::Append1BE(bytes, stack_depth);
 
+    MethodHelper mh;
     for (size_t stack_frame = 0; stack_frame < stack_depth; ++stack_frame) {
       // For each stack frame:
       // (2b) method's class name
       // (2b) method name
       // (2b) method source file
       // (2b) line number, clipped to 32767; -2 if native; -1 if no source
-      const Method* m = record->stack[stack_frame].method;
-      JDWP::Append2BE(bytes, class_names.IndexOf(m->GetDeclaringClass()->GetDescriptor()));
-      JDWP::Append2BE(bytes, method_names.IndexOf(m->GetName()));
-      JDWP::Append2BE(bytes, filenames.IndexOf(m->GetDeclaringClass()->GetSourceFile()));
+      mh.ChangeMethod(record->stack[stack_frame].method);
+      JDWP::Append2BE(bytes, class_names.IndexOf(mh.GetDeclaringClassDescriptor()));
+      JDWP::Append2BE(bytes, method_names.IndexOf(mh.GetName()));
+      JDWP::Append2BE(bytes, filenames.IndexOf(mh.GetDeclaringClassSourceFile()));
       JDWP::Append2BE(bytes, record->stack[stack_frame].LineNumber());
     }
 
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 0e4c224..1261bb9 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -15,6 +15,7 @@
 #include "file.h"
 #include "image_writer.h"
 #include "oat_writer.h"
+#include "object_utils.h"
 #include "os.h"
 #include "runtime.h"
 #include "stringpiece.h"
@@ -242,7 +243,7 @@
     if (klass->IsArrayClass() || klass->IsPrimitive()) {
       return true;
     }
-    image_classes->insert(klass->GetDescriptor()->ToModifiedUtf8());
+    image_classes->insert(ClassHelper(klass).GetDescriptor());
     return true;
   }
 
diff --git a/src/dex_file.cc b/src/dex_file.cc
index 5185ba8..01bb6d5 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -571,7 +571,7 @@
 }
 
 const DexFile::ProtoId* DexFile::FindProtoId(uint16_t return_type_idx,
-                                             const std::vector<uint16_t>& signature_type_ids) const {
+                                         const std::vector<uint16_t>& signature_type_idxs) const {
   uint32_t lo = 0;
   uint32_t hi = NumProtoIds() - 1;
   while (hi >= lo) {
@@ -581,15 +581,15 @@
     if (compare == 0) {
       DexFileParameterIterator it(*this, proto);
       size_t i = 0;
-      while (it.HasNext() && i < signature_type_ids.size() && compare == 0) {
-        compare = signature_type_ids[i] - it.GetTypeId();
+      while (it.HasNext() && i < signature_type_idxs.size() && compare == 0) {
+        compare = signature_type_idxs[i] - it.GetTypeIdx();
         it.Next();
         i++;
       }
       if (compare == 0) {
         if (it.HasNext()) {
           compare = -1;
-        } else if (i < signature_type_ids.size()) {
+        } else if (i < signature_type_idxs.size()) {
           compare = 1;
         }
       }
@@ -704,7 +704,8 @@
 
   // A method with no line number info should return -1
   LineNumFromPcContext context(rel_pc, -1);
-  DecodeDebugInfo(code_item, method, LineNumForPcCb, NULL, &context);
+  DecodeDebugInfo(code_item, method->IsStatic(), method->GetDexMethodIndex(), LineNumForPcCb,
+                  NULL, &context);
   return context.line_num_;
 }
 
@@ -733,7 +734,7 @@
   return -1;
 }
 
-void DexFile::DecodeDebugInfo0(const CodeItem* code_item, const Method* method,
+void DexFile::DecodeDebugInfo0(const CodeItem* code_item, bool is_static, uint32_t method_idx,
                                DexDebugNewPositionCb posCb, DexDebugNewLocalCb local_cb,
                                void* cnxt, const byte* stream, LocalInfo* local_in_reg) const {
   uint32_t line = DecodeUnsignedLeb128(&stream);
@@ -742,13 +743,11 @@
   uint32_t address = 0;
   bool need_locals = (local_cb != NULL);
 
-  if (!method->IsStatic()) {
+  if (!is_static) {
     if (need_locals) {
-      std::string descriptor = method->GetDeclaringClass()->GetDescriptor()->ToModifiedUtf8();
-      const ClassDef* class_def = FindClassDef(descriptor);
-      CHECK(class_def != NULL) << descriptor;
+      const char* descriptor = GetMethodDeclaringClassDescriptor(GetMethodId(method_idx));
       local_in_reg[arg_reg].name_ = "this";
-      local_in_reg[arg_reg].descriptor_ = GetClassDescriptor(*class_def);
+      local_in_reg[arg_reg].descriptor_ = descriptor;
       local_in_reg[arg_reg].signature_ = NULL;
       local_in_reg[arg_reg].start_address_ = 0;
       local_in_reg[arg_reg].is_live_ = true;
@@ -756,7 +755,7 @@
     arg_reg++;
   }
 
-  DexFileParameterIterator it(*this, GetProtoId(method->GetProtoIdx()));
+  DexFileParameterIterator it(*this, GetMethodPrototype(GetMethodId(method_idx)));
   for (uint32_t i = 0; i < parameters_size && it.HasNext(); ++i, it.Next()) {
     if (arg_reg >= code_item->registers_size_) {
       LOG(ERROR) << "invalid stream - arg reg >= reg size (" << arg_reg
@@ -897,14 +896,14 @@
   }
 }
 
-void DexFile::DecodeDebugInfo(const CodeItem* code_item, const art::Method* method,
+void DexFile::DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
                                  DexDebugNewPositionCb posCb, DexDebugNewLocalCb local_cb,
                                  void* cnxt) const {
   const byte* stream = GetDebugInfoStream(code_item);
   LocalInfo local_in_reg[code_item->registers_size_];
 
   if (stream != NULL) {
-    DecodeDebugInfo0(code_item, method, posCb, local_cb, cnxt, stream, local_in_reg);
+    DecodeDebugInfo0(code_item, is_static, method_idx, posCb, local_cb, cnxt, stream, local_in_reg);
   }
   for (int reg = 0; reg < code_item->registers_size_; reg++) {
     InvokeLocalCbIfLive(cnxt, reg, code_item->insns_size_in_code_units_, local_in_reg, local_cb);
diff --git a/src/dex_file.h b/src/dex_file.h
index a7026d6..7f0f975 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -376,7 +376,9 @@
   const char* GetMethodShorty(const MethodId& method_id) const {
     return StringDataByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_);
   }
-
+  const char* GetMethodShorty(const MethodId& method_id, int32_t* length) const {
+    return StringDataAndLengthByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_, length);
+  }
   // Returns the number of class definitions in the .dex file.
   size_t NumClassDefs() const {
     CHECK(header_ != NULL);
@@ -425,11 +427,11 @@
   }
 
   //
-  const CodeItem* GetCodeItem(const uint32_t code_off_) const {
-    if (code_off_ == 0) {
+  const CodeItem* GetCodeItem(const uint32_t code_off) const {
+    if (code_off == 0) {
       return NULL;  // native or abstract method
     } else {
-      const byte* addr = base_ + code_off_;
+      const byte* addr = base_ + code_off;
       return reinterpret_cast<const CodeItem*>(addr);
     }
   }
@@ -458,7 +460,7 @@
 
   // Looks up a proto id for a given return type and signature type list
   const ProtoId* FindProtoId(uint16_t return_type_id,
-                             const std::vector<uint16_t>& signature_type_ids_) const;
+                             const std::vector<uint16_t>& signature_type_idxs_) const;
 
   // Given a signature place the type ids into the given vector, returns true on success
   bool CreateTypeList(uint16_t* return_type_idx, std::vector<uint16_t>* param_type_idxs,
@@ -592,7 +594,7 @@
   // This is used by runtime; therefore use art::Method not art::DexFile::Method.
   int32_t GetLineNumFromPC(const Method* method, uint32_t rel_pc) const;
 
-  void DecodeDebugInfo(const CodeItem* code_item, const Method* method,
+  void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
                        DexDebugNewPositionCb posCb, DexDebugNewLocalCb local_cb,
                        void* cnxt) const;
 
@@ -657,14 +659,12 @@
   // Returns true if the header magic is of the expected value.
   bool IsMagicValid();
 
-  void DecodeDebugInfo0(const CodeItem* code_item, const Method* method,
+  void DecodeDebugInfo0(const CodeItem* code_item, bool is_static, uint32_t method_idx,
       DexDebugNewPositionCb posCb, DexDebugNewLocalCb local_cb,
       void* cnxt, const byte* stream, LocalInfo* local_in_reg) const;
 
 
-  // The index of descriptors to class definition indexes.
-  // TODO: given type_ids are sorted by string_id index, and string_ids are alphabetically, class
-  //   lookup can be done with a binary search. Is the index necessary?
+  // The index of descriptors to class definition indexes (as opposed to type id indexes)
   typedef std::map<const StringPiece, uint32_t> Index;
   Index index_;
 
@@ -721,11 +721,11 @@
   }
   bool HasNext() const { return pos_ < size_; }
   void Next() { ++pos_; }
-  uint16_t GetTypeId() {
+  uint16_t GetTypeIdx() {
     return type_list_->GetTypeItem(pos_).type_idx_;
   }
   const char* GetDescriptor() {
-    return dex_file_.StringByTypeIdx(GetTypeId());
+    return dex_file_.StringByTypeIdx(GetTypeIdx());
   }
  private:
   const DexFile& dex_file_;
diff --git a/src/dex_verifier.cc b/src/dex_verifier.cc
index d162aec..768880a 100644
--- a/src/dex_verifier.cc
+++ b/src/dex_verifier.cc
@@ -13,6 +13,7 @@
 #include "intern_table.h"
 #include "leb128.h"
 #include "logging.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "stringpiece.h"
 
@@ -69,7 +70,7 @@
       if (IsUnresolvedTypes()) {
         result += PrettyDescriptor(GetDescriptor());
       } else {
-        result += PrettyDescriptor(GetClass()->GetDescriptor());
+        result += PrettyDescriptor(GetClass());
       }
     }
   }
@@ -124,7 +125,8 @@
     Class* common_elem = ClassJoin(s_ct, t_ct);
     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
     const ClassLoader* class_loader = s->GetClassLoader();
-    std::string descriptor = "[" + common_elem->GetDescriptor()->ToModifiedUtf8();
+    std::string descriptor = "[";
+    descriptor += ClassHelper(common_elem).GetDescriptor();
     Class* array_class = class_linker->FindClass(descriptor.c_str(), class_loader);
     DCHECK(array_class != NULL);
     return array_class;
@@ -354,11 +356,15 @@
     return *entry;
   } else {
     DCHECK (type == RegType::kRegTypeReference);
+    ClassHelper kh;
     for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
       RegType* cur_entry = entries_[i];
       // check resolved and unresolved references, ignore uninitialized references
-      if (cur_entry->IsReference() && cur_entry->GetClass()->GetDescriptor()->Equals(descriptor)) {
-        return *cur_entry;
+      if (cur_entry->IsReference()) {
+        kh.ChangeClass(cur_entry->GetClass());
+        if (descriptor == kh.GetDescriptor()) {
+          return *cur_entry;
+        }
       } else if (cur_entry->IsUnresolvedReference() &&
                  cur_entry->GetDescriptor()->Equals(descriptor)) {
         return *cur_entry;
@@ -887,7 +893,7 @@
     return true;
   }
   Class* super = klass->GetSuperClass();
-  if (super == NULL && !klass->GetDescriptor()->Equals("Ljava/lang/Object;")) {
+  if (super == NULL && ClassHelper(klass).GetDescriptor() != "Ljava/lang/Object;") {
     LOG(ERROR) << "Verifier rejected class " << PrettyClass(klass) << " that has no super class";
     return false;
   }
@@ -1574,7 +1580,8 @@
     cur_arg++;
   }
 
-  const DexFile::ProtoId& proto_id = dex_file_->GetProtoId(method_->GetProtoIdx());
+  const DexFile::ProtoId& proto_id =
+      dex_file_->GetMethodPrototype(dex_file_->GetMethodId(method_->GetDexMethodIndex()));
   DexFileParameterIterator iterator(*dex_file_, proto_id);
 
   for (; iterator.HasNext(); iterator.Next()) {
@@ -2145,7 +2152,7 @@
           if (!res_class->IsArrayClass() || !component_type->IsPrimitive()  ||
               component_type->IsPrimitiveVoid()) {
             Fail(VERIFY_ERROR_GENERIC) << "invalid fill-array-data on "
-                                       << PrettyDescriptor(res_class->GetDescriptor());
+                                       << PrettyDescriptor(res_class);
           } else {
             const RegType& value_type = reg_types_.FromClass(component_type);
             DCHECK(!value_type.IsUnknown());
@@ -2366,7 +2373,7 @@
           uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
           descriptor =  dex_file_->StringByTypeIdx(return_type_idx);
         } else {
-          descriptor = called_method->GetReturnTypeDescriptor();
+          descriptor = MethodHelper(called_method).GetReturnTypeDescriptor();
         }
         const RegType& return_type =
             reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
@@ -2444,7 +2451,7 @@
           uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
           descriptor =  dex_file_->StringByTypeIdx(return_type_idx);
         } else {
-          descriptor = called_method->GetReturnTypeDescriptor();
+          descriptor = MethodHelper(called_method).GetReturnTypeDescriptor();
         }
         const RegType& return_type =
             reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
@@ -2465,7 +2472,7 @@
             uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
             descriptor =  dex_file_->StringByTypeIdx(return_type_idx);
           } else {
-            descriptor = called_method->GetReturnTypeDescriptor();
+            descriptor = MethodHelper(called_method).GetReturnTypeDescriptor();
           }
           const RegType& return_type =
               reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
@@ -2520,7 +2527,7 @@
           uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
           descriptor =  dex_file_->StringByTypeIdx(return_type_idx);
         } else {
-          descriptor = abs_method->GetReturnTypeDescriptor();
+          descriptor = MethodHelper(abs_method).GetReturnTypeDescriptor();
         }
         const RegType& return_type =
             reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
@@ -2965,7 +2972,7 @@
   // check at runtime if access is allowed and so pass here.
   if (!result.IsUnresolvedTypes() && !referrer->CanAccess(result.GetClass())) {
     Fail(VERIFY_ERROR_ACCESS_CLASS) << "illegal class access: '"
-                                    << PrettyDescriptor(referrer->GetDescriptor()) << "' -> '"
+                                    << PrettyDescriptor(referrer) << "' -> '"
                                     << result << "'";
     return reg_types_.Unknown();
   } else {
@@ -3038,7 +3045,7 @@
       dex_cache->SetResolvedMethod(method_idx, res_method);
     } else {
       Fail(VERIFY_ERROR_NO_METHOD) << "couldn't find method "
-                                   << PrettyDescriptor(klass->GetDescriptor()) << "." << name
+                                   << PrettyDescriptor(klass) << "." << name
                                    << " " << signature;
       return NULL;
     }
@@ -3046,7 +3053,7 @@
   /* Check if access is allowed. */
   if (!referrer->CanAccessMember(res_method->GetDeclaringClass(), res_method->GetAccessFlags())) {
     Fail(VERIFY_ERROR_ACCESS_METHOD) << "illegal method access (call " << PrettyMethod(res_method)
-                                  << " from " << PrettyDescriptor(referrer->GetDescriptor()) << ")";
+                                  << " from " << PrettyDescriptor(referrer) << ")";
     return NULL;
   }
   return res_method;
@@ -3088,11 +3095,11 @@
         Fail(VERIFY_ERROR_NO_METHOD) << "invalid invoke-super from " << PrettyMethod(method_)
                                      << " to super " << PrettyMethod(res_method);
       } else {
+        MethodHelper mh(res_method);
         Fail(VERIFY_ERROR_NO_METHOD) << "invalid invoke-super from " << PrettyMethod(method_)
-                                     << " to super " << PrettyDescriptor(super->GetDescriptor())
-                                     << "." << res_method->GetName()->ToModifiedUtf8()
-                                     << " " << res_method->GetSignature()->ToModifiedUtf8();
-
+                                     << " to super " << PrettyDescriptor(super)
+                                     << "." << mh.GetName()
+                                     << mh.GetSignature();
       }
       return NULL;
     }
@@ -3108,7 +3115,7 @@
         << ") exceeds outsSize (" << code_item_->outs_size_ << ")";
     return NULL;
   }
-  std::string sig = res_method->GetSignature()->ToModifiedUtf8();
+  std::string sig(MethodHelper(res_method).GetSignature());
   if (sig[0] != '(') {
     Fail(VERIFY_ERROR_GENERIC) << "rejecting call to " << res_method
         << " as descriptor doesn't start with '(': " << sig;
@@ -3194,6 +3201,11 @@
   }
 }
 
+const RegType& DexVerifier::GetMethodReturnType() {
+  return reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(),
+                                   MethodHelper(method_).GetReturnTypeDescriptor());
+}
+
 void DexVerifier::VerifyAGet(const Instruction::DecodedInstruction& dec_insn,
                              const RegType& insn_type, bool is_primitive) {
   const RegType& index_type = work_line_->GetRegisterType(dec_insn.vC_);
@@ -3218,20 +3230,20 @@
         const RegType& component_type = reg_types_.FromClass(component_class);
         if (!array_class->IsArrayClass()) {
           Fail(VERIFY_ERROR_GENERIC) << "not array type "
-              << PrettyDescriptor(array_class->GetDescriptor()) << " with aget";
+              << PrettyDescriptor(array_class) << " with aget";
         } else if (component_class->IsPrimitive() && !is_primitive) {
           Fail(VERIFY_ERROR_GENERIC) << "primitive array type "
-                                     << PrettyDescriptor(array_class->GetDescriptor())
+                                     << PrettyDescriptor(array_class)
                                      << " source for aget-object";
         } else if (!component_class->IsPrimitive() && is_primitive) {
           Fail(VERIFY_ERROR_GENERIC) << "reference array type "
-                                     << PrettyDescriptor(array_class->GetDescriptor())
+                                     << PrettyDescriptor(array_class)
                                      << " source for category 1 aget";
         } else if (is_primitive && !insn_type.Equals(component_type) &&
                    !((insn_type.IsInteger() && component_type.IsFloat()) ||
                      (insn_type.IsLong() && component_type.IsDouble()))) {
           Fail(VERIFY_ERROR_GENERIC) << "array type "
-              << PrettyDescriptor(array_class->GetDescriptor())
+              << PrettyDescriptor(array_class)
               << " incompatible with aget of type " << insn_type;
         } else {
           // Use knowledge of the field type which is stronger than the type inferred from the
@@ -3261,20 +3273,20 @@
         const RegType& component_type = reg_types_.FromClass(component_class);
         if (!array_class->IsArrayClass()) {
           Fail(VERIFY_ERROR_GENERIC) << "not array type "
-              << PrettyDescriptor(array_class->GetDescriptor()) << " with aput";
+              << PrettyDescriptor(array_class) << " with aput";
         } else if (component_class->IsPrimitive() && !is_primitive) {
           Fail(VERIFY_ERROR_GENERIC) << "primitive array type "
-                                     << PrettyDescriptor(array_class->GetDescriptor())
+                                     << PrettyDescriptor(array_class)
                                      << " source for aput-object";
         } else if (!component_class->IsPrimitive() && is_primitive) {
           Fail(VERIFY_ERROR_GENERIC) << "reference array type "
-                                     << PrettyDescriptor(array_class->GetDescriptor())
+                                     << PrettyDescriptor(array_class)
                                      << " source for category 1 aput";
         } else if (is_primitive && !insn_type.Equals(component_type) &&
                    !((insn_type.IsInteger() && component_type.IsFloat()) ||
                      (insn_type.IsLong() && component_type.IsDouble()))) {
           Fail(VERIFY_ERROR_GENERIC) << "array type "
-              << PrettyDescriptor(array_class->GetDescriptor())
+              << PrettyDescriptor(array_class)
               << " incompatible with aput of type " << insn_type;
         } else {
           // The instruction agrees with the type of array, confirm the value to be stored does too
@@ -3367,7 +3379,7 @@
     const char* descriptor;
     const ClassLoader* loader;
     if (field != NULL) {
-      descriptor = field->GetTypeDescriptor();
+      descriptor = FieldHelper(field).GetTypeDescriptor();
       loader = field->GetDeclaringClass()->GetClassLoader();
     } else {
       const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
@@ -3419,7 +3431,7 @@
     const char* descriptor;
     const ClassLoader* loader;
     if (field != NULL) {
-      descriptor = field->GetTypeDescriptor();
+      descriptor = FieldHelper(field).GetTypeDescriptor();
       loader = field->GetDeclaringClass()->GetClassLoader();
     } else {
       const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
diff --git a/src/dex_verifier.h b/src/dex_verifier.h
index 182c81a..201cd2b 100644
--- a/src/dex_verifier.h
+++ b/src/dex_verifier.h
@@ -1145,10 +1145,7 @@
    * DalvikJniReturnType, because if it's a reference type we need to do the class lookup.
    * Returned references are assumed to be initialized. Returns kRegTypeUnknown for "void".
    */
-  const RegType& GetMethodReturnType() {
-    return reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(),
-                                     method_->GetReturnTypeDescriptor());
-  }
+  const RegType& GetMethodReturnType();
 
   /*
    * Verify that the target instruction is not "move-exception". It's important that the only way
diff --git a/src/heap.cc b/src/heap.cc
index ac0c366..6b2ea71 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -10,6 +10,7 @@
 #include "image.h"
 #include "mark_sweep.h"
 #include "object.h"
+#include "object_utils.h"
 #include "space.h"
 #include "stl_util.h"
 #include "thread_list.h"
@@ -169,9 +170,9 @@
 Object* Heap::AllocObject(Class* klass, size_t byte_count) {
   {
     ScopedHeapLock lock;
-    DCHECK(klass == NULL || klass->GetDescriptor() == NULL ||
-        (klass->IsClassClass() && byte_count >= sizeof(Class)) ||
-        (klass->IsVariableSize() || klass->GetObjectSize() == byte_count));
+    DCHECK(klass == NULL || (klass->IsClassClass() && byte_count >= sizeof(Class)) ||
+           (klass->IsVariableSize() || klass->GetObjectSize() == byte_count) ||
+           ClassHelper(klass).GetDescriptor().empty());
     DCHECK_GE(byte_count, sizeof(Object));
     Object* obj = AllocateLocked(byte_count);
     if (obj != NULL) {
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index 3c5227f..d2134e0 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -23,13 +23,16 @@
  */
 
 #include "hprof.h"
-#include "heap.h"
+
+#include "class_linker.h"
 #include "debugger.h"
+#include "heap.h"
+#include "logging.h"
 #include "object.h"
+#include "object_utils.h"
 #include "stringprintf.h"
 #include "unordered_map.h"
 #include "unordered_set.h"
-#include "logging.h"
 
 #include <cutils/open_memstream.h>
 #include <sys/uio.h>
@@ -364,6 +367,8 @@
 
       rec->AddU2(0); // empty const pool
 
+      FieldHelper fh;
+
       // Static fields
       if (sFieldCount == 0) {
         rec->AddU2((uint16_t)0);
@@ -375,10 +380,11 @@
 
         for (size_t i = 0; i < sFieldCount; ++i) {
           Field* f = thisClass->GetStaticField(i);
+          fh.ChangeField(f);
 
           size_t size;
-          HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), &size);
-          rec->AddId(LookupStringId(f->GetName()));
+          HprofBasicType t = SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), &size);
+          rec->AddId(LookupStringId(fh.GetName()));
           rec->AddU1(t);
           if (size == 1) {
             rec->AddU1(static_cast<uint8_t>(f->Get32(NULL)));
@@ -399,8 +405,9 @@
       rec->AddU2((uint16_t)iFieldCount);
       for (int i = 0; i < iFieldCount; ++i) {
         Field* f = thisClass->GetInstanceField(i);
-        HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), NULL);
-        rec->AddId(LookupStringId(f->GetName()));
+        fh.ChangeField(f);
+        HprofBasicType t = SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), NULL);
+        rec->AddId(LookupStringId(fh.GetName()));
         rec->AddU1(t);
       }
     } else if (clazz->IsArrayClass()) {
@@ -463,12 +470,14 @@
       // Write the instance data;  fields for this class, followed by super class fields,
       // and so on. Don't write the klass or monitor fields of Object.class.
       const Class* sclass = clazz;
+      FieldHelper fh;
       while (!sclass->IsObjectClass()) {
         int ifieldCount = sclass->NumInstanceFields();
         for (int i = 0; i < ifieldCount; i++) {
           Field* f = sclass->GetInstanceField(i);
+          fh.ChangeField(f);
           size_t size;
-          SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), &size);
+          SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), &size);
           if (size == 1) {
             rec->AddU1(f->Get32(obj));
           } else if (size == 2) {
@@ -680,7 +689,7 @@
 }
 
 HprofStringId Hprof::LookupClassNameId(Class* clazz) {
-  return LookupStringId(PrettyDescriptor(clazz->GetDescriptor()));
+  return LookupStringId(PrettyDescriptor(clazz));
 }
 
 HprofClassObjectId Hprof::LookupClassId(Class* clazz) {
diff --git a/src/image_writer.cc b/src/image_writer.cc
index adc7b78..34ad955 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -18,6 +18,7 @@
 #include "intern_table.h"
 #include "logging.h"
 #include "object.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "space.h"
 #include "utils.h"
@@ -101,7 +102,7 @@
   if (klass->IsPrimitive()) { 
     return true;
   }
-  const std::string descriptor = klass->GetDescriptor()->ToModifiedUtf8();
+  const std::string descriptor(ClassHelper(klass).GetDescriptor());
   return image_classes_->find(descriptor) != image_classes_->end();
 }
 
@@ -160,7 +161,7 @@
 bool ImageWriter::NonImageClassesVisitor(Class* klass, void* arg) {
   NonImageClasses* context = reinterpret_cast<NonImageClasses*>(arg);
   if (!context->image_writer->IsImageClass(klass)) {
-    context->non_image_classes->insert(klass->GetDescriptor()->ToModifiedUtf8());
+    context->non_image_classes->insert(ClassHelper(klass).GetDescriptor());
   }
   return true;
 }
@@ -178,7 +179,7 @@
     return;
   }
   Class* klass = obj->AsClass();
-  CHECK(image_writer->IsImageClass(klass)) << klass->GetDescriptor()->ToModifiedUtf8();
+  CHECK(image_writer->IsImageClass(klass)) << PrettyDescriptor(klass);
 }
 
 void ImageWriter::CalculateNewObjectOffsetsCallback(Object* obj, void* arg) {
diff --git a/src/java_lang_Class.cc b/src/java_lang_Class.cc
index b85969e..92fb6fa 100644
--- a/src/java_lang_Class.cc
+++ b/src/java_lang_Class.cc
@@ -18,6 +18,7 @@
 #include "class_linker.h"
 #include "class_loader.h"
 #include "object.h"
+#include "object_utils.h"
 #include "ScopedLocalRef.h"
 #include "ScopedUtfChars.h"
 
@@ -63,6 +64,19 @@
   return AddLocalReference<jclass>(env, c);
 }
 
+jint Class_getAnnotationDirectoryOffset(JNIEnv* env, jclass javaClass) {
+  Class* c = Decode<Class*>(env, javaClass);
+  if (c->IsPrimitive() || c->IsArrayClass() || c->IsProxyClass()) {
+    return 0;  // primitive, array and proxy classes don't have class definitions
+  }
+  const DexFile::ClassDef* class_def = ClassHelper(c).GetClassDef();
+  if (class_def == NULL) {
+    return 0;  // not found
+  } else {
+    return class_def->annotations_off_;
+  }
+}
+
 template<typename T>
 jobjectArray ToArray(JNIEnv* env, const char* array_class_name, const std::vector<T*>& objects) {
   jclass array_class = env->FindClass(array_class_name);
@@ -81,14 +95,10 @@
   if (m->IsStatic()) {
     return false;
   }
-  if (m->GetName()->CharAt(0) != '<') {
-    return false;
-  }
-  m->InitJavaFields();
-  return true;
+  return m->IsConstructor();
 }
 
-jobjectArray Class_getDeclaredConstructors(JNIEnv* env, jclass, jclass javaClass, jboolean publicOnly) {
+jobjectArray Class_getDeclaredConstructors(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
   Class* c = Decode<Class*>(env, javaClass);
 
   std::vector<Method*> constructors;
@@ -106,11 +116,10 @@
   if (public_only && !f->IsPublic()) {
     return false;
   }
-  f->InitJavaFields();
   return true;
 }
 
-jobjectArray Class_getDeclaredFields(JNIEnv* env, jclass, jclass javaClass, jboolean publicOnly) {
+jobjectArray Class_getDeclaredFields(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
   Class* c = Decode<Class*>(env, javaClass);
 
   std::vector<Field*> fields;
@@ -140,14 +149,13 @@
   if (public_only && !m->IsPublic()) {
     return false;
   }
-  if (m->GetName()->CharAt(0) == '<') {
+  if (m->IsConstructor()) {
     return false;
   }
-  m->InitJavaFields();
   return true;
 }
 
-jobjectArray Class_getDeclaredMethods(JNIEnv* env, jclass, jclass javaClass, jboolean publicOnly) {
+jobjectArray Class_getDeclaredMethods(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
   Class* c = Decode<Class*>(env, javaClass);
 
   std::vector<Method*> methods;
@@ -188,44 +196,52 @@
   return Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache).GetDexObject(env);
 }
 
-jint Class_getNonInnerClassModifiers(JNIEnv* env, jclass, jclass javaClass) {
+jint Class_getNonInnerClassModifiers(JNIEnv* env, jclass javaClass) {
   Class* c = Decode<Class*>(env, javaClass);
   return c->GetAccessFlags() & kAccJavaFlagsMask;
 }
 
-jobject Class_getClassLoader(JNIEnv* env, jclass, jobject javaClass) {
+jobject Class_getClassLoaderNative(JNIEnv* env, jclass javaClass) {
   Class* c = Decode<Class*>(env, javaClass);
   Object* result = c->GetClassLoader();
   return AddLocalReference<jobject>(env, result);
 }
 
-jclass Class_getComponentType(JNIEnv* env, jobject javaThis) {
-  return AddLocalReference<jclass>(env, Decode<Class*>(env, javaThis)->GetComponentType());
+jclass Class_getComponentType(JNIEnv* env, jclass javaClass) {
+  return AddLocalReference<jclass>(env, Decode<Class*>(env, javaClass)->GetComponentType());
 }
 
-bool MethodMatches(Method* m, String* name, const std::string& signature) {
-  if (!m->GetName()->Equals(name)) {
+bool MethodMatches(MethodHelper* mh, const std::string& name, ObjectArray<Class>* arg_array) {
+  if (name != mh->GetName()) {
     return false;
   }
-  std::string method_signature = m->GetSignature()->ToModifiedUtf8();
-  if (!StringPiece(method_signature).starts_with(signature)) {
+  const DexFile::TypeList* m_type_list = mh->GetParameterTypeList();
+  uint32_t m_type_list_size = m_type_list == NULL ? 0 : m_type_list->Size();
+  uint32_t sig_length = arg_array->GetLength();
+
+  if (m_type_list_size != sig_length) {
     return false;
   }
-  if (m->IsMiranda()) {
-    return false;
+
+  for (uint32_t i = 0; i < sig_length; i++) {
+    if (mh->GetClassFromTypeIdx(m_type_list->GetTypeItem(i).type_idx_) != arg_array->Get(i)) {
+      return false;
+    }
   }
   return true;
 }
 
-Method* FindConstructorOrMethodInArray(ObjectArray<Method>* methods, String* name,
-    const std::string& signature) {
+Method* FindConstructorOrMethodInArray(ObjectArray<Method>* methods, const std::string& name,
+                                       ObjectArray<Class>* arg_array) {
   if (methods == NULL) {
     return NULL;
   }
   Method* result = NULL;
+  MethodHelper mh;
   for (int32_t i = 0; i < methods->GetLength(); ++i) {
     Method* method = methods->Get(i);
-    if (!MethodMatches(method, name, signature)) {
+    mh.ChangeMethod(method);
+    if (method->IsMiranda() || !MethodMatches(&mh, name, arg_array)) {
       continue;
     }
 
@@ -242,49 +258,42 @@
   return result;
 }
 
-jobject Class_getDeclaredConstructorOrMethod(JNIEnv* env, jclass,
-    jclass javaClass, jstring javaName, jobjectArray javaSignature) {
+jobject Class_getDeclaredConstructorOrMethod(JNIEnv* env, jclass javaClass, jstring javaName,
+                                             jobjectArray javaArgs) {
   Class* c = Decode<Class*>(env, javaClass);
-  String* name = Decode<String*>(env, javaName);
-  ObjectArray<Class>* signature_array = Decode<ObjectArray<Class>*>(env, javaSignature);
+  std::string name = Decode<String*>(env, javaName)->ToModifiedUtf8();
+  ObjectArray<Class>* arg_array = Decode<ObjectArray<Class>*>(env, javaArgs);
 
-  std::string signature;
-  signature += "(";
-  for (int i = 0; i < signature_array->GetLength(); i++) {
-    signature += signature_array->Get(i)->GetDescriptor()->ToModifiedUtf8();
-  }
-  signature += ")";
-
-  Method* m = FindConstructorOrMethodInArray(c->GetDirectMethods(), name, signature);
+  Method* m = FindConstructorOrMethodInArray(c->GetDirectMethods(), name, arg_array);
   if (m == NULL) {
-    m = FindConstructorOrMethodInArray(c->GetVirtualMethods(), name, signature);
+    m = FindConstructorOrMethodInArray(c->GetVirtualMethods(), name, arg_array);
   }
 
   if (m != NULL) {
-    m->InitJavaFields();
     return AddLocalReference<jobject>(env, m);
   } else {
     return NULL;
   }
 }
 
-jobject Class_getDeclaredField(JNIEnv* env, jclass, jclass jklass, jobject jname) {
+jobject Class_getDeclaredFieldNative(JNIEnv* env, jclass jklass, jobject jname) {
   Class* klass = Decode<Class*>(env, jklass);
   DCHECK(klass->IsClass());
   String* name = Decode<String*>(env, jname);
   DCHECK(name->GetClass()->IsStringClass());
 
+  FieldHelper fh;
   for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
     Field* f = klass->GetInstanceField(i);
-    if (f->GetName()->Equals(name)) {
-      f->InitJavaFields();
+    fh.ChangeField(f);
+    if (name->Equals(fh.GetName())) {
       return AddLocalReference<jclass>(env, f);
     }
   }
   for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
     Field* f = klass->GetStaticField(i);
-    if (f->GetName()->Equals(name)) {
-      f->InitJavaFields();
+    fh.ChangeField(f);
+    if (name->Equals(fh.GetName())) {
       return AddLocalReference<jclass>(env, f);
     }
   }
@@ -302,7 +311,7 @@
  */
 jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
   Class* c = Decode<Class*>(env, javaThis);
-  std::string descriptor(c->GetDescriptor()->ToModifiedUtf8());
+  std::string descriptor(ClassHelper(c).GetDescriptor());
   if ((descriptor[0] != 'L') && (descriptor[0] != '[')) {
     // The descriptor indicates that this is the class for
     // a primitive type; special-case the return value.
@@ -370,7 +379,7 @@
 }
 
 // Validate method/field access.
-bool CheckMemberAccess(const Class* access_from, const Class* access_to, uint32_t member_flags) {
+bool CheckMemberAccess(const Class* access_from, Class* access_to, uint32_t member_flags) {
   // quick accept for public access */
   if (member_flags & kAccPublic) {
     return true;
@@ -403,7 +412,7 @@
   Class* c = Decode<Class*>(env, javaThis);
   if (c->IsPrimitive() || c->IsInterface() || c->IsArrayClass() || c->IsAbstract()) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
-        "Class %s can not be instantiated", PrettyDescriptor(c->GetDescriptor()).c_str());
+        "Class %s can not be instantiated", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
     return NULL;
   }
 
@@ -414,7 +423,7 @@
   Method* init = c->FindDirectMethod("<init>", "()V");
   if (init == NULL) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
-        "Class %s has no default <init>()V constructor", PrettyDescriptor(c->GetDescriptor()).c_str());
+        "Class %s has no default <init>()V constructor", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
     return NULL;
   }
 
@@ -433,18 +442,19 @@
   Method* caller_caller = frame.GetMethod();
   Class* caller_class = caller_caller->GetDeclaringClass();
 
+  ClassHelper caller_ch(caller_class);
   if (!caller_class->CanAccess(c)) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
         "Class %s is not accessible from class %s",
-        PrettyDescriptor(c->GetDescriptor()).c_str(),
-        PrettyDescriptor(caller_class->GetDescriptor()).c_str());
+        PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str(),
+        PrettyDescriptor(caller_ch.GetDescriptor()).c_str());
     return NULL;
   }
   if (!CheckMemberAccess(caller_class, init->GetDeclaringClass(), init->GetAccessFlags())) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
         "%s is not accessible from class %s",
         PrettyMethod(init).c_str(),
-        PrettyDescriptor(caller_class->GetDescriptor()).c_str());
+        PrettyDescriptor(caller_ch.GetDescriptor()).c_str());
     return NULL;
   }
 
@@ -463,15 +473,16 @@
 static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Class, classForName, "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"),
   NATIVE_METHOD(Class, desiredAssertionStatus, "()Z"),
-  NATIVE_METHOD(Class, getClassLoader, "(Ljava/lang/Class;)Ljava/lang/ClassLoader;"),
+  NATIVE_METHOD(Class, getAnnotationDirectoryOffset, "()I"),
+  NATIVE_METHOD(Class, getClassLoaderNative, "()Ljava/lang/ClassLoader;"),
   NATIVE_METHOD(Class, getComponentType, "()Ljava/lang/Class;"),
-  NATIVE_METHOD(Class, getDeclaredConstructorOrMethod, "(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Member;"),
-  NATIVE_METHOD(Class, getDeclaredConstructors, "(Ljava/lang/Class;Z)[Ljava/lang/reflect/Constructor;"),
-  NATIVE_METHOD(Class, getDeclaredField, "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Field;"),
-  NATIVE_METHOD(Class, getDeclaredFields, "(Ljava/lang/Class;Z)[Ljava/lang/reflect/Field;"),
-  NATIVE_METHOD(Class, getDeclaredMethods, "(Ljava/lang/Class;Z)[Ljava/lang/reflect/Method;"),
+  NATIVE_METHOD(Class, getDeclaredConstructorOrMethod, "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Member;"),
+  NATIVE_METHOD(Class, getDeclaredConstructors, "(Z)[Ljava/lang/reflect/Constructor;"),
+  NATIVE_METHOD(Class, getDeclaredFieldNative, "(Ljava/lang/String;)Ljava/lang/reflect/Field;"),
+  NATIVE_METHOD(Class, getDeclaredFields, "(Z)[Ljava/lang/reflect/Field;"),
+  NATIVE_METHOD(Class, getDeclaredMethods, "(Z)[Ljava/lang/reflect/Method;"),
   NATIVE_METHOD(Class, getDex, "()Lcom/android/dex/Dex;"),
-  NATIVE_METHOD(Class, getNonInnerClassModifiers, "(Ljava/lang/Class;)I"),
+  NATIVE_METHOD(Class, getNonInnerClassModifiers, "()I"),
   NATIVE_METHOD(Class, getNameNative, "()Ljava/lang/String;"),
   NATIVE_METHOD(Class, getSuperclass, "()Ljava/lang/Class;"),
   NATIVE_METHOD(Class, isAssignableFrom, "(Ljava/lang/Class;)Z"),
diff --git a/src/java_lang_reflect_Array.cc b/src/java_lang_reflect_Array.cc
index 08960b1..50bfb83 100644
--- a/src/java_lang_reflect_Array.cc
+++ b/src/java_lang_reflect_Array.cc
@@ -17,6 +17,7 @@
 #include "jni_internal.h"
 #include "class_linker.h"
 #include "object.h"
+#include "object_utils.h"
 
 #include "JniConstants.h" // Last to avoid problems with LOG redefinition.
 
@@ -43,7 +44,7 @@
     // old code assumed this but if you recurse from "[Foo" to "Foo" to "oo",
     // you shouldn't assume there isn't a class "oo".
   }
-  std::string sub_array_descriptor(array_class->GetDescriptor()->ToModifiedUtf8(), 1);
+  std::string sub_array_descriptor(ClassHelper(array_class).GetDescriptor(), 1);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Class* sub_array_class = class_linker->FindClass(sub_array_descriptor,
                                                    array_class->GetClassLoader());
@@ -77,9 +78,9 @@
   Class* element_class = Decode<Class*>(env, javaElementClass);
   DCHECK(element_class->IsClass());
   DCHECK(javaDimArray != NULL);
-  Object* dimensions_obj = Decode<Class*>(env, javaDimArray);
+  Object* dimensions_obj = Decode<Object*>(env, javaDimArray);
   DCHECK(dimensions_obj->IsArrayInstance());
-  DCHECK(dimensions_obj->GetClass()->GetDescriptor()->Equals("[I"));
+  DCHECK_STREQ(ClassHelper(dimensions_obj->GetClass()).GetDescriptor().c_str(), "[I");
   IntArray* dimensions_array = down_cast<IntArray*>(dimensions_obj);
 
   // Verify dimensions.
@@ -101,7 +102,7 @@
 
   // Generate the full name of the array class.
   std::string descriptor(num_dimensions, '[');
-  descriptor += element_class->GetDescriptor()->ToModifiedUtf8();
+  descriptor += ClassHelper(element_class).GetDescriptor();
 
   // Find/generate the array class.
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -130,7 +131,7 @@
   }
   std::string descriptor;
   descriptor += '[';
-  descriptor += element_class->GetDescriptor()->ToModifiedUtf8();
+  descriptor += ClassHelper(element_class).GetDescriptor();
 
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Class* array_class = class_linker->FindClass(descriptor, element_class->GetClassLoader());
diff --git a/src/java_lang_reflect_Constructor.cc b/src/java_lang_reflect_Constructor.cc
index f730543..36481f7 100644
--- a/src/java_lang_reflect_Constructor.cc
+++ b/src/java_lang_reflect_Constructor.cc
@@ -17,6 +17,7 @@
 #include "jni_internal.h"
 #include "class_linker.h"
 #include "object.h"
+#include "object_utils.h"
 #include "reflection.h"
 
 #include "JniConstants.h" // Last to avoid problems with LOG redefinition.
@@ -32,12 +33,13 @@
  * check.  We can also safely assume the constructor isn't associated
  * with an interface, array, or primitive class.
  */
-jobject Constructor_constructNative(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs, jclass javaDeclaringClass, jobjectArray javaParams, jint, jboolean) {
+jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
-  Class* c = Decode<Class*>(env, javaDeclaringClass);
+  Method* m = Decode<Object*>(env, javaMethod)->AsMethod();
+  Class* c = m->GetDeclaringClass();
   if (c->IsAbstract()) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
-        "Can't instantiate abstract class %s", PrettyDescriptor(c->GetDescriptor()).c_str());
+        "Can't instantiate abstract class %s", PrettyDescriptor(c).c_str());
     return NULL;
   }
 
@@ -52,14 +54,14 @@
   }
 
   jobject javaReceiver = AddLocalReference<jobject>(env, receiver);
-  InvokeMethod(env, javaMethod, javaReceiver, javaArgs, javaParams);
+  InvokeMethod(env, javaMethod, javaReceiver, javaArgs);
 
   // Constructors are ()V methods, so we shouldn't touch the result of InvokeMethod.
   return javaReceiver;
 }
 
 static JNINativeMethod gMethods[] = {
-  NATIVE_METHOD(Constructor, constructNative, "([Ljava/lang/Object;Ljava/lang/Class;[Ljava/lang/Class;IZ)Ljava/lang/Object;"),
+  NATIVE_METHOD(Constructor, newInstance, "([Ljava/lang/Object;)Ljava/lang/Object;"),
 };
 
 }  // namespace
diff --git a/src/java_lang_reflect_Field.cc b/src/java_lang_reflect_Field.cc
index 7e66dd9..eb56edb 100644
--- a/src/java_lang_reflect_Field.cc
+++ b/src/java_lang_reflect_Field.cc
@@ -17,6 +17,7 @@
 #include "jni_internal.h"
 #include "class_linker.h"
 #include "object.h"
+#include "object_utils.h"
 #include "reflection.h"
 
 #include "JniConstants.h" // Last to avoid problems with LOG redefinition.
@@ -25,13 +26,9 @@
 
 namespace {
 
-jint Field_getFieldModifiers(JNIEnv* env, jobject jfield, jclass javaDeclaringClass, jint slot) {
-  return Decode<Object*>(env, jfield)->AsField()->GetAccessFlags() & kAccJavaFlagsMask;
-}
-
 bool GetFieldValue(Object* o, Field* f, JValue& value, bool allow_references) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
-  switch (f->GetPrimitiveType()) {
+  switch (FieldHelper(f).GetTypeAsPrimitiveType()) {
   case Primitive::kPrimBoolean:
     value.z = f->GetBoolean(o);
     return true;
@@ -72,24 +69,41 @@
   return false;
 }
 
-bool CheckReceiver(JNIEnv* env, jobject javaObj, jclass javaDeclaringClass, Field* f, Object*& o) {
+bool CheckReceiver(JNIEnv* env, jobject javaObj, Field* f, Object*& o) {
   if (f->IsStatic()) {
     o = NULL;
     return true;
   }
 
   o = Decode<Object*>(env, javaObj);
-  Class* declaringClass = Decode<Class*>(env, javaDeclaringClass);
+  Class* declaringClass = f->GetDeclaringClass();
   if (!VerifyObjectInClass(env, o, declaringClass)) {
     return false;
   }
   return true;
 }
 
-JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jchar dst_descriptor) {
+jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
-  if (!CheckReceiver(env, javaObj, javaDeclaringClass, f, o)) {
+  if (!CheckReceiver(env, javaObj, f, o)) {
+    return NULL;
+  }
+
+  // Get the field's value, boxing if necessary.
+  JValue value;
+  if (!GetFieldValue(o, f, value, true)) {
+    return NULL;
+  }
+  BoxPrimitive(env, FieldHelper(f).GetTypeAsPrimitiveType(), value);
+
+  return AddLocalReference<jobject>(env, value.l);
+}
+
+JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char dst_descriptor) {
+  Field* f = DecodeField(env->FromReflectedField(javaField));
+  Object* o = NULL;
+  if (!CheckReceiver(env, javaObj, f, o)) {
     return JValue();
   }
 
@@ -102,47 +116,47 @@
   // Widen it if necessary (and possible).
   JValue wide_value;
   Class* dst_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(dst_descriptor);
-  if (!ConvertPrimitiveValue(f->GetPrimitiveType(), dst_type->GetPrimitiveType(),
+  if (!ConvertPrimitiveValue(FieldHelper(f).GetTypeAsPrimitiveType(), dst_type->GetPrimitiveType(),
                              field_value, wide_value)) {
     return JValue();
   }
   return wide_value;
 }
 
-jbyte Field_getBField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).b;
+jboolean Field_getBoolean(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'Z').z;
 }
 
-jchar Field_getCField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).c;
+jbyte Field_getByte(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'B').b;
 }
 
-jdouble Field_getDField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).d;
+jchar Field_getChar(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'C').c;
 }
 
-jfloat Field_getFField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).f;
+jdouble Field_getDouble(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'D').d;
 }
 
-jint Field_getIField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).i;
+jfloat Field_getFloat(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'F').f;
 }
 
-jlong Field_getJField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).j;
+jint Field_getInt(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'I').i;
 }
 
-jshort Field_getSField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).s;
+jlong Field_getLong(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'J').j;
 }
 
-jboolean Field_getZField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).z;
+jshort Field_getShort(JNIEnv* env, jobject javaField, jobject javaObj) {
+  return GetPrimitiveField(env, javaField, javaObj, 'S').s;
 }
 
 void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references) {
-  switch (f->GetPrimitiveType()) {
+  switch (FieldHelper(f).GetTypeAsPrimitiveType()) {
   case Primitive::kPrimBoolean:
     f->SetBoolean(o, new_value.z);
     break;
@@ -187,14 +201,36 @@
   }
 }
 
-void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jchar src_descriptor, const JValue& new_value) {
+void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
+  ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+  Field* f = DecodeField(env->FromReflectedField(javaField));
+
+  // Unbox the value, if necessary.
+  Object* boxed_value = Decode<Object*>(env, javaValue);
+  JValue unboxed_value;
+  if (!UnboxPrimitive(env, boxed_value, FieldHelper(f).GetType(), unboxed_value)) {
+    return;
+  }
+
+  // Check that the receiver is non-null and an instance of the field's declaring class.
+  Object* o = NULL;
+  if (!CheckReceiver(env, javaObj, f, o)) {
+    return;
+  }
+
+  SetFieldValue(o, f, unboxed_value, true);
+}
+
+void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
+                       const JValue& new_value) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
-  if (!CheckReceiver(env, javaObj, javaDeclaringClass, f, o)) {
+  if (!CheckReceiver(env, javaObj, f, o)) {
     return;
   }
-  if (f->GetPrimitiveType() == Primitive::kPrimNot) {
+  FieldHelper fh(f);
+  if (!fh.IsPrimitiveType()) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
         "Not a primitive field: %s", PrettyField(f).c_str());
     return;
@@ -203,7 +239,7 @@
   // Widen the value if necessary (and possible).
   JValue wide_value;
   Class* src_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(src_descriptor);
-  if (!ConvertPrimitiveValue(src_type->GetPrimitiveType(), f->GetPrimitiveType(),
+  if (!ConvertPrimitiveValue(src_type->GetPrimitiveType(), fh.GetTypeAsPrimitiveType(),
                              new_value, wide_value)) {
     return;
   }
@@ -212,112 +248,73 @@
   SetFieldValue(o, f, wide_value, false);
 }
 
-void Field_setBField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jbyte value) {
-  JValue v = { 0 };
-  v.b = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setCField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jchar value) {
-  JValue v = { 0 };
-  v.c = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setDField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jdouble value) {
-  JValue v = { 0 };
-  v.d = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setFField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jfloat value) {
-  JValue v = { 0 };
-  v.f = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setIField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jint value) {
-  JValue v = { 0 };
-  v.i = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setJField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jlong value) {
-  JValue v = { 0 };
-  v.j = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setSField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jshort value) {
-  JValue v = { 0 };
-  v.s = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
-}
-
-void Field_setZField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jboolean value) {
+void Field_setBoolean(JNIEnv* env, jobject javaField, jobject javaObj, jboolean value) {
   JValue v = { 0 };
   v.z = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, 'Z', v);
 }
 
-void Field_setField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jobject javaValue) {
-  ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
-  Field* f = DecodeField(env->FromReflectedField(javaField));
-
-  // Unbox the value, if necessary.
-  Object* boxed_value = Decode<Object*>(env, javaValue);
-  JValue unboxed_value;
-  if (!UnboxPrimitive(env, boxed_value, f->GetType(), unboxed_value)) {
-    return;
-  }
-
-  // Check that the receiver is non-null and an instance of the field's declaring class.
-  Object* o = NULL;
-  if (!CheckReceiver(env, javaObj, javaDeclaringClass, f, o)) {
-    return;
-  }
-
-  SetFieldValue(o, f, unboxed_value, true);
+void Field_setByte(JNIEnv* env, jobject javaField, jobject javaObj, jbyte value) {
+  JValue v = { 0 };
+  v.b = value;
+  SetPrimitiveField(env, javaField, javaObj, 'B', v);
 }
 
-jobject Field_getField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean) {
-  Field* f = DecodeField(env->FromReflectedField(javaField));
-  Object* o = NULL;
-  if (!CheckReceiver(env, javaObj, javaDeclaringClass, f, o)) {
-    return NULL;
-  }
+void Field_setChar(JNIEnv* env, jobject javaField, jobject javaObj, jchar value) {
+  JValue v = { 0 };
+  v.c = value;
+  SetPrimitiveField(env, javaField, javaObj, 'C', v);
+}
 
-  // Get the field's value, boxing if necessary.
-  JValue value;
-  if (!GetFieldValue(o, f, value, true)) {
-    return NULL;
-  }
-  BoxPrimitive(env, f->GetPrimitiveType(), value);
+void Field_setDouble(JNIEnv* env, jobject javaField, jobject javaObj, jdouble value) {
+  JValue v = { 0 };
+  v.d = value;
+  SetPrimitiveField(env, javaField, javaObj, 'D', v);
+}
 
-  return AddLocalReference<jobject>(env, value.l);
+void Field_setFloat(JNIEnv* env, jobject javaField, jobject javaObj, jfloat value) {
+  JValue v = { 0 };
+  v.f = value;
+  SetPrimitiveField(env, javaField, javaObj, 'F', v);
+}
+
+void Field_setInt(JNIEnv* env, jobject javaField, jobject javaObj, jint value) {
+  JValue v = { 0 };
+  v.i = value;
+  SetPrimitiveField(env, javaField, javaObj, 'I', v);
+}
+
+void Field_setLong(JNIEnv* env, jobject javaField, jobject javaObj, jlong value) {
+  JValue v = { 0 };
+  v.j = value;
+  SetPrimitiveField(env, javaField, javaObj, 'J', v);
+}
+
+void Field_setShort(JNIEnv* env, jobject javaField, jobject javaObj, jshort value) {
+  JValue v = { 0 };
+  v.s = value;
+  SetPrimitiveField(env, javaField, javaObj, 'S', v);
 }
 
 static JNINativeMethod gMethods[] = {
-  NATIVE_METHOD(Field, getFieldModifiers, "(Ljava/lang/Class;I)I"),
-
-  NATIVE_METHOD(Field, getBField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)B"),
-  NATIVE_METHOD(Field, getCField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)C"),
-  NATIVE_METHOD(Field, getDField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)D"),
-  NATIVE_METHOD(Field, getFField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)F"),
-  NATIVE_METHOD(Field, getField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZ)Ljava/lang/Object;"),
-  NATIVE_METHOD(Field, getIField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)I"),
-  NATIVE_METHOD(Field, getJField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)J"),
-  NATIVE_METHOD(Field, getSField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)S"),
-  NATIVE_METHOD(Field, getZField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZC)Z"),
-  NATIVE_METHOD(Field, setBField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCB)V"),
-  NATIVE_METHOD(Field, setCField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCC)V"),
-  NATIVE_METHOD(Field, setDField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCD)V"),
-  NATIVE_METHOD(Field, setFField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCF)V"),
-  NATIVE_METHOD(Field, setField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZLjava/lang/Object;)V"),
-  NATIVE_METHOD(Field, setIField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCI)V"),
-  NATIVE_METHOD(Field, setJField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCJ)V"),
-  NATIVE_METHOD(Field, setSField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCS)V"),
-  NATIVE_METHOD(Field, setZField, "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZCZ)V"),
+  NATIVE_METHOD(Field, get,        "(Ljava/lang/Object;)Ljava/lang/Object;"),
+  NATIVE_METHOD(Field, getBoolean, "(Ljava/lang/Object;)Z"),
+  NATIVE_METHOD(Field, getByte,    "(Ljava/lang/Object;)B"),
+  NATIVE_METHOD(Field, getChar,    "(Ljava/lang/Object;)C"),
+  NATIVE_METHOD(Field, getDouble,  "(Ljava/lang/Object;)D"),
+  NATIVE_METHOD(Field, getFloat,   "(Ljava/lang/Object;)F"),
+  NATIVE_METHOD(Field, getInt,     "(Ljava/lang/Object;)I"),
+  NATIVE_METHOD(Field, getLong,    "(Ljava/lang/Object;)J"),
+  NATIVE_METHOD(Field, getShort,   "(Ljava/lang/Object;)S"),
+  NATIVE_METHOD(Field, set,        "(Ljava/lang/Object;Ljava/lang/Object;)V"),
+  NATIVE_METHOD(Field, setBoolean, "(Ljava/lang/Object;Z)V"),
+  NATIVE_METHOD(Field, setByte,    "(Ljava/lang/Object;B)V"),
+  NATIVE_METHOD(Field, setChar,    "(Ljava/lang/Object;C)V"),
+  NATIVE_METHOD(Field, setDouble,  "(Ljava/lang/Object;D)V"),
+  NATIVE_METHOD(Field, setFloat,   "(Ljava/lang/Object;F)V"),
+  NATIVE_METHOD(Field, setInt,     "(Ljava/lang/Object;I)V"),
+  NATIVE_METHOD(Field, setLong,    "(Ljava/lang/Object;J)V"),
+  NATIVE_METHOD(Field, setShort,   "(Ljava/lang/Object;S)V"),
 };
 
 }  // namespace
diff --git a/src/java_lang_reflect_Method.cc b/src/java_lang_reflect_Method.cc
index e36078f..90d718d 100644
--- a/src/java_lang_reflect_Method.cc
+++ b/src/java_lang_reflect_Method.cc
@@ -17,6 +17,7 @@
 #include "jni_internal.h"
 #include "class_linker.h"
 #include "object.h"
+#include "object_utils.h"
 #include "reflection.h"
 
 #include "JniConstants.h" // Last to avoid problems with LOG redefinition.
@@ -25,33 +26,19 @@
 
 namespace {
 
-jint Method_getMethodModifiers(JNIEnv* env, jclass, jclass javaDeclaringClass, jobject jmethod, jint slot) {
-  Method* m = Decode<Object*>(env, jmethod)->AsMethod();
-  jint access_flags = m->GetAccessFlags();
-  // We move the DECLARED_SYNCHRONIZED flag into the SYNCHRONIZED
-  // position, because the callers of this function are trying to convey
-  // the "traditional" meaning of the flags to their callers.
-  access_flags &= ~kAccSynchronized;
-  if ((access_flags & kAccDeclaredSynchronized) != 0) {
-    access_flags |= kAccSynchronized;
-  }
-
-  return access_flags & kAccJavaFlagsMask;
+jobject Method_invoke(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
+  return InvokeMethod(env, javaMethod, javaReceiver, javaArgs);
 }
 
-jint Method_getProtoIndex(JNIEnv* env, jclass, jclass javaDeclaringClass, jobject jmethod, jint slot) {
-  Method* m = Decode<Object*>(env, jmethod)->AsMethod();
-  return m->GetProtoIdx();
-}
-
-jobject Method_invokeNative(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs, jclass, jobject javaParams, jclass, jint, jboolean) {
-  return InvokeMethod(env, javaMethod, javaReceiver, javaArgs, javaParams);
+jobject Method_getReturnTypeNative(JNIEnv* env, jobject javaMethod) {
+  Method* m = Decode<Object*>(env, javaMethod)->AsMethod();
+  MethodHelper mh(m);
+  return AddLocalReference<jobject>(env, mh.GetReturnType());
 }
 
 static JNINativeMethod gMethods[] = {
-  NATIVE_METHOD(Method, getMethodModifiers, "(Ljava/lang/Class;Ljava/lang/reflect/AccessibleObject;I)I"),
-  NATIVE_METHOD(Method, getProtoIndex, "(Ljava/lang/Class;Ljava/lang/reflect/AccessibleObject;I)I"),
-  NATIVE_METHOD(Method, invokeNative, "(Ljava/lang/Object;[Ljava/lang/Object;Ljava/lang/Class;[Ljava/lang/Class;Ljava/lang/Class;IZ)Ljava/lang/Object;"),
+  NATIVE_METHOD(Method, invoke, "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"),
+  NATIVE_METHOD(Method, getReturnTypeNative, "()Ljava/lang/Class;")
 };
 
 }  // namespace
diff --git a/src/java_lang_reflect_Proxy.cc b/src/java_lang_reflect_Proxy.cc
index 55ecd08..28fe514 100644
--- a/src/java_lang_reflect_Proxy.cc
+++ b/src/java_lang_reflect_Proxy.cc
@@ -25,6 +25,8 @@
 namespace {
 
 static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName, jobjectArray javaInterfaces, jobject javaLoader, jobjectArray javaMethods, jobjectArray javaThrows) {
+  // Allocates Class so transition thread state to runnable
+  ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   String* name = Decode<String*>(env, javaName);
   ObjectArray<Class>* interfaces = Decode<ObjectArray<Class>*>(env, javaInterfaces);
   ClassLoader* loader = Decode<ClassLoader*>(env, javaLoader);
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 82c120c..718659f 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -18,6 +18,7 @@
 #include "jni.h"
 #include "logging.h"
 #include "object.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "scoped_jni_thread_state.h"
 #include "stl_util.h"
@@ -119,24 +120,6 @@
   return num_bytes;
 }
 
-static size_t NumArgArrayBytes(const String* shorty) {
-  size_t num_bytes = 0;
-  size_t end = shorty->GetLength();
-  for (size_t i = 1; i < end; ++i) {
-    char ch = shorty->CharAt(i);
-    if (ch == 'D' || ch == 'J') {
-      num_bytes += 8;
-    } else if (ch == 'L') {
-      // Argument is a reference or an array.  The shorty descriptor
-      // does not distinguish between these types.
-      num_bytes += sizeof(Object*);
-    } else {
-      num_bytes += 4;
-    }
-  }
-  return num_bytes;
-}
-
 // For external use.
 template<typename T>
 T Decode(JNIEnv* public_env, jobject obj) {
@@ -177,11 +160,12 @@
 
 static byte* CreateArgArray(JNIEnv* public_env, Method* method, va_list ap) {
   JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
-  const String* shorty = method->GetShorty();
+  const char* shorty = MethodHelper(method).GetShorty();
+  size_t shorty_len = strlen(shorty);
   size_t num_bytes = NumArgArrayBytes(shorty);
   UniquePtr<byte[]> arg_array(new byte[num_bytes]);
-  for (int i = 1, offset = 0; i < shorty->GetLength(); ++i) {
-    switch (shorty->CharAt(i)) {
+  for (size_t i = 1, offset = 0; i < shorty_len; ++i) {
+    switch (shorty[i]) {
       case 'Z':
       case 'B':
       case 'C':
@@ -215,11 +199,12 @@
 
 static byte* CreateArgArray(JNIEnv* public_env, Method* method, jvalue* args) {
   JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
-  size_t num_bytes = NumArgArrayBytes(method->GetShorty());
+  const char* shorty = MethodHelper(method).GetShorty();
+  size_t shorty_len = strlen(shorty);
+  size_t num_bytes = NumArgArrayBytes(shorty);
   UniquePtr<byte[]> arg_array(new byte[num_bytes]);
-  const String* shorty = method->GetShorty();
-  for (int i = 1, offset = 0; i < shorty->GetLength(); ++i) {
-    switch (shorty->CharAt(i)) {
+  for (size_t i = 1, offset = 0; i < shorty_len; ++i) {
+    switch (shorty[i]) {
       case 'Z':
       case 'B':
       case 'C':
@@ -313,9 +298,8 @@
 }
 
 static void ThrowNoSuchMethodError(ScopedJniThreadState& ts, Class* c, const char* name, const char* sig, const char* kind) {
-  std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
   ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
-      "no %s method \"%s.%s%s\"", kind, class_descriptor.c_str(), name, sig);
+      "no %s method \"%s.%s%s\"", kind, ClassHelper(c).GetDescriptor().c_str(), name, sig);
 }
 
 static jmethodID FindMethodID(ScopedJniThreadState& ts, jclass jni_class, const char* name, const char* sig, bool is_static) {
@@ -341,8 +325,6 @@
     return NULL;
   }
 
-  method->InitJavaFields();
-
   return EncodeMethod(method);
 }
 
@@ -374,26 +356,22 @@
     // Failed to find type from the signature of the field.
     DCHECK(ts.Self()->IsExceptionPending());
     ts.Self()->ClearException();
-    std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
     ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
         "no type \"%s\" found and so no field \"%s\" could be found in class "
-        "\"%s\" or its superclasses", sig, name, class_descriptor.c_str());
+        "\"%s\" or its superclasses", sig, name, ClassHelper(c).GetDescriptor().c_str());
     return NULL;
   }
-  std::string field_type_descriptor = field_type->GetDescriptor()->ToModifiedUtf8();
   if (is_static) {
-    field = c->FindStaticField(name, field_type_descriptor);
+    field = c->FindStaticField(name, ClassHelper(field_type).GetDescriptor());
   } else {
-    field = c->FindInstanceField(name, field_type_descriptor);
+    field = c->FindInstanceField(name, ClassHelper(field_type).GetDescriptor());
   }
   if (field == NULL) {
-    std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
     ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
         "no \"%s\" field \"%s\" in class \"%s\" or its superclasses", sig,
-        name, class_descriptor.c_str());
+        name, ClassHelper(c).GetDescriptor().c_str());
     return NULL;
   }
-  field->InitJavaFields();
   return EncodeField(field);
 }
 
@@ -1996,7 +1974,7 @@
     Class* element_class = Decode<Class*>(ts, element_jclass);
     std::string descriptor;
     descriptor += "[";
-    descriptor += element_class->GetDescriptor()->ToModifiedUtf8();
+    descriptor += ClassHelper(element_class).GetDescriptor();
 
     // Find the class.
     ScopedLocalRef<jclass> java_array_class(env, FindClass(env, descriptor.c_str()));
@@ -2209,9 +2187,11 @@
         m = c->FindVirtualMethod(name, sig);
       }
       if (m == NULL) {
+        LOG(INFO) << "Failed to register native method " << name << sig;
         ThrowNoSuchMethodError(ts, c, name, sig, "static or non-static");
         return JNI_ERR;
       } else if (!m->IsNative()) {
+        LOG(INFO) << "Failed to register non-native method " << name << sig << " as native";
         ThrowNoSuchMethodError(ts, c, name, sig, "native");
         return JNI_ERR;
       }
diff --git a/src/monitor.cc b/src/monitor.cc
index 3f041e4..69eb9ba 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -27,6 +27,7 @@
 #include "class_linker.h"
 #include "mutex.h"
 #include "object.h"
+#include "object_utils.h"
 #include "stl_util.h"
 #include "thread.h"
 #include "thread_list.h"
@@ -824,15 +825,9 @@
     line_number = 0;
     return;
   }
-
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  Class* c = method->GetDeclaringClass();
-  DexCache* dex_cache = c->GetDexCache();
-  const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
-  const DexFile::ClassDef* class_def = dex_file.FindClassDef(c->GetDescriptor()->ToModifiedUtf8());
-
-  source_file = dex_file.GetSourceFile(*class_def);
-  line_number = dex_file.GetLineNumFromPC(method, method->ToDexPC(pc));
+  MethodHelper mh(method);
+  source_file = mh.GetDeclaringClassSourceFile();
+  line_number = mh.GetLineNumFromNativePC(pc);
 }
 
 MonitorList::MonitorList() : lock_("MonitorList lock") {
diff --git a/src/oatdump.cc b/src/oatdump.cc
index ac9449f..5cff2ea 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -12,6 +12,7 @@
 #include "file.h"
 #include "image.h"
 #include "os.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "space.h"
 #include "stringpiece.h"
@@ -299,7 +300,8 @@
     StringAppendF(&summary, "%p: ", obj);
     if (obj->IsClass()) {
       Class* klass = obj->AsClass();
-      StringAppendF(&summary, "CLASS %s", klass->GetDescriptor()->ToModifiedUtf8().c_str());
+      summary += "CLASS ";
+      summary += ClassHelper(klass).GetDescriptor();
       std::ostringstream ss;
       ss << " (" << klass->GetStatus() << ")";
       summary += ss.str();
@@ -317,7 +319,7 @@
       StringAppendF(&summary, "OBJECT");
     }
     StringAppendF(&summary, "\n");
-    std::string descriptor = obj->GetClass()->GetDescriptor()->ToModifiedUtf8();
+    std::string descriptor(ClassHelper(obj->GetClass()).GetDescriptor());
     StringAppendF(&summary, "\tclass %p: %s\n", obj->GetClass(), descriptor.c_str());
     state->stats_.descriptor_to_bytes[descriptor] += object_bytes;
     state->stats_.descriptor_to_count[descriptor] += 1;
@@ -359,10 +361,7 @@
           state->stats_.pc_mapping_table_bytes += pc_mapping_table_bytes;
         }
 
-        ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-        class DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
-        const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
-        const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
+        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;
       }
diff --git a/src/object.cc b/src/object.cc
index b8d82dc..14e8c5c 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -18,6 +18,7 @@
 #include "intern_table.h"
 #include "logging.h"
 #include "monitor.h"
+#include "object_utils.h"
 #include "runtime.h"
 #include "stack.h"
 #include "utils.h"
@@ -93,73 +94,18 @@
   java_lang_reflect_Field_ = NULL;
 }
 
-void Field::SetTypeIdx(uint32_t type_idx) {
-  SetField32(OFFSET_OF_OBJECT_MEMBER(Field, type_idx_), type_idx, false);
-}
-
-Class* Field::GetTypeDuringLinking() const {
-  // We are assured that the necessary primitive types are in the dex cache
-  // early during class linking
-  return GetDeclaringClass()->GetDexCache()->GetResolvedType(GetTypeIdx());
-}
-
-bool Field::IsPrimitiveType() const {
-  Class* type = GetTypeDuringLinking();
-  return (type == NULL || type->IsPrimitive());
-}
-
-Primitive::Type Field::GetPrimitiveType() const {
-  Class* type = GetTypeDuringLinking();
-  if (type == NULL) {
-    return Primitive::kPrimNot;
-  }
-  return type->GetPrimitiveType();
-}
-
-size_t Field::PrimitiveSize() const {
-  return Primitive::FieldSize(GetPrimitiveType());
-}
-
-const char* Field::GetTypeDescriptor() const {
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(GetDeclaringClass()->GetDexCache());
-  const char* descriptor = dex_file.StringByTypeIdx(GetTypeIdx());
-  DCHECK(descriptor != NULL);
-  return descriptor;
-}
-
-Class* Field::GetType() {
-  Class* type = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Field, type_), false);
-  if (type == NULL) {
-    type = Runtime::Current()->GetClassLinker()->ResolveType(GetTypeIdx(), this);
-    SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Field, type_), type, false);
-  }
-  return type;
-}
-
 void Field::SetOffset(MemberOffset num_bytes) {
   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  Primitive::Type type = GetPrimitiveType();
+#if 0 // TODO enable later in boot and under !NDEBUG
+  FieldHelper fh(this);
+  Primitive::Type type = fh.GetTypeAsPrimitiveType();
   if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
     DCHECK_ALIGNED(num_bytes.Uint32Value(), 8);
   }
+#endif
   SetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), num_bytes.Uint32Value(), false);
 }
 
-void Field::InitJavaFields() {
-  Thread* self = Thread::Current();
-  ScopedThreadStateChange tsc(self, Thread::kRunnable);
-  MonitorEnter(self);
-  if (type_ == NULL) {
-    InitJavaFieldsLocked();
-  }
-  MonitorExit(self);
-}
-
-void Field::InitJavaFieldsLocked() {
-  GetType(); // Resolves type as a side-effect. May throw.
-}
-
 uint32_t Field::Get32(const Object* object) const {
   CHECK((object == NULL) == IsStatic()) << PrettyField(this);
   if (IsStatic()) {
@@ -209,107 +155,121 @@
 }
 
 bool Field::GetBoolean(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimBoolean) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetBoolean(Object* object, bool z) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimBoolean) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
   Set32(object, z);
 }
 
 int8_t Field::GetByte(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimByte) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetByte(Object* object, int8_t b) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimByte) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
   Set32(object, b);
 }
 
 uint16_t Field::GetChar(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimChar) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetChar(Object* object, uint16_t c) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimChar) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   Set32(object, c);
 }
 
 int16_t Field::GetShort(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimShort) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetShort(Object* object, int16_t s) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimShort) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   Set32(object, s);
 }
 
 int32_t Field::GetInt(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimInt) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimInt, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetInt(Object* object, int32_t i) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimInt) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimInt, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   Set32(object, i);
 }
 
 int64_t Field::GetLong(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimLong) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimLong, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   return Get64(object);
 }
 
 void Field::SetLong(Object* object, int64_t j) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimLong) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimLong, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   Set64(object, j);
 }
 
 float Field::GetFloat(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimFloat) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   JValue float_bits;
   float_bits.i = Get32(object);
   return float_bits.f;
 }
 
 void Field::SetFloat(Object* object, float f) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimFloat) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   JValue float_bits;
   float_bits.f = f;
   Set32(object, float_bits.i);
 }
 
 double Field::GetDouble(const Object* object) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimDouble) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   JValue double_bits;
   double_bits.j = Get64(object);
   return double_bits.d;
 }
 
 void Field::SetDouble(Object* object, double d) const {
-  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimDouble) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   JValue double_bits;
   double_bits.d = d;
   Set64(object, double_bits.j);
 }
 
 Object* Field::GetObject(const Object* object) const {
-  CHECK_EQ(GetPrimitiveType(), Primitive::kPrimNot) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   return GetObj(object);
 }
 
 void Field::SetObject(Object* object, const Object* l) const {
-  CHECK_EQ(GetPrimitiveType(), Primitive::kPrimNot) << PrettyField(this);
+  DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
   SetObj(object, l);
 }
 
-bool Method::IsClassInitializer() const {
-  return IsStatic() && GetName()->Equals("<clinit>");
-}
-
 // TODO: get global references for these
 Class* Method::java_lang_reflect_Constructor_ = NULL;
 Class* Method::java_lang_reflect_Method_ = NULL;
@@ -361,118 +321,11 @@
   }
 }
 
-void Method::InitJavaFieldsLocked() {
-  // Create the array.
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  size_t arg_count = GetShorty()->GetLength() - 1;
-  Class* array_class = class_linker->FindSystemClass("[Ljava/lang/Class;");
-  ObjectArray<Class>* parameters = ObjectArray<Class>::Alloc(array_class, arg_count);
-  if (parameters == NULL) {
-    return;
-  }
-
-  // Parse the signature, filling the array.
-  const ClassLoader* cl = GetDeclaringClass()->GetClassLoader();
-  std::string signature(GetSignature()->ToModifiedUtf8());
-  const char* p = signature.c_str();
-  DCHECK_EQ(*p, '(');
-  ++p;
-  for (size_t i = 0; i < arg_count; ++i) {
-    Class* c = ExtractNextClassFromSignature(class_linker, cl, p);
-    if (c == NULL) {
-      return;
-    }
-    parameters->Set(i, c);
-  }
-
-  DCHECK_EQ(*p, ')');
-  ++p;
-
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, java_parameter_types_),
-                 parameters, false);
-  Class* java_return_type = ExtractNextClassFromSignature(class_linker, cl, p);
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, java_return_type_),
-                 java_return_type, false);
-}
-
-void Method::InitJavaFields() {
-  Thread* self = Thread::Current();
-  ScopedThreadStateChange tsc(self, Thread::kRunnable);
-  MonitorEnter(self);
-  if (java_parameter_types_ == NULL || java_return_type_ == NULL) {
-    InitJavaFieldsLocked();
-  }
-  MonitorExit(self);
-}
-
 ObjectArray<String>* Method::GetDexCacheStrings() const {
   return GetFieldObject<ObjectArray<String>*>(
       OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_strings_), false);
 }
 
-void Method::SetReturnTypeIdx(uint32_t new_return_type_idx) {
-  SetField32(OFFSET_OF_OBJECT_MEMBER(Method, java_return_type_idx_),
-             new_return_type_idx, false);
-}
-
-uint32_t Method::GetDexMethodIndex() const {
-  // TODO: add the method index to Method - which will also mean a number of Method fields can
-  // become dex file lookups (which will then mean we may want faster access to the dex file)
-  // Find the dex file
-  const DexCache* dex_cache = GetDeclaringClass()->GetDexCache();
-  const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
-  // Find the class_def in the dex file
-  uint32_t class_def_idx;
-  bool found_class_def =
-      dex_file.FindClassDefIndex(GetDeclaringClass()->GetDescriptor()->ToModifiedUtf8(),
-                                 class_def_idx);
-  CHECK(found_class_def);
-  const DexFile::TypeId& type_id =
-      dex_file.GetTypeId(dex_file.GetClassDef(class_def_idx).class_idx_);
-  const DexFile::StringId* name_str_id = dex_file.FindStringId(GetName()->ToModifiedUtf8());
-  CHECK(name_str_id != NULL);  // Failed to find method's name?
-  uint16_t return_type_idx;
-  std::vector<uint16_t> param_type_idxs;
-  std::string signature = GetSignature()->ToModifiedUtf8();
-  bool found_type_list = dex_file.CreateTypeList(&return_type_idx, &param_type_idxs, signature);
-  CHECK(found_type_list);   // Failed to parse signature
-  const DexFile::ProtoId* sig_proto_id = dex_file.FindProtoId(return_type_idx, param_type_idxs);
-  CHECK(sig_proto_id != NULL);  // Failed to find method's prototype
-  const DexFile::MethodId* method_id =
-      dex_file.FindMethodId(type_id, *name_str_id, *sig_proto_id);
-  CHECK(method_id != NULL);  // Failed to find method?
-  uint32_t method_idx = dex_file.GetIndexForMethodId(*method_id);
-  DCHECK_EQ(PrettyMethod(method_idx, dex_file), PrettyMethod(this));
-  return method_idx;
-}
-
-const char* Method::GetReturnTypeDescriptor() const {
-  Class* declaring_class = GetDeclaringClass();
-  DexCache* dex_cache = declaring_class->GetDexCache();
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
-  const char* descriptor = dex_file.StringByTypeIdx(GetReturnTypeIdx());
-  DCHECK(descriptor != NULL);
-  return descriptor;
-}
-
-Class* Method::GetReturnType() const {
-  DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous())
-      << PrettyMethod(this);
-  Class* java_return_type = java_return_type_;
-  if (java_return_type != NULL) {
-      return java_return_type;
-  }
-  // Short-cut
-  Class* result = GetDexCacheResolvedTypes()->Get(GetReturnTypeIdx());
-  if (result == NULL) {
-    // Do full linkage and set cache value for next call
-    result = Runtime::Current()->GetClassLinker()->ResolveType(GetReturnTypeIdx(), this);
-  }
-  CHECK(result != NULL) << PrettyMethod(this);
-  return result;
-}
-
 void Method::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_strings_),
                  new_dex_cache_strings, false);
@@ -545,85 +398,8 @@
   return num_registers;
 }
 
-size_t Method::NumArgs() const {
-  // "1 +" because the first in Args is the receiver.
-  // "- 1" because we don't count the return type.
-  return (IsStatic() ? 0 : 1) + GetShorty()->GetLength() - 1;
-}
-
-// The number of reference arguments to this method including implicit this
-// pointer
-size_t Method::NumReferenceArgs() const {
-  const String* shorty = GetShorty();
-  size_t result = IsStatic() ? 0 : 1;  // The implicit this pointer.
-  for (int i = 1; i < shorty->GetLength(); i++) {
-    char ch = shorty->CharAt(i);
-    if ((ch == 'L') || (ch == '[')) {
-      result++;
-    }
-  }
-  return result;
-}
-
-// The number of long or double arguments
-size_t Method::NumLongOrDoubleArgs() const {
-  const String* shorty = GetShorty();
-  size_t result = 0;
-  for (int i = 1; i < shorty->GetLength(); i++) {
-    char ch = shorty->CharAt(i);
-    if ((ch == 'D') || (ch == 'J')) {
-      result++;
-    }
-  }
-  return result;
-}
-
-// Is the given method parameter a reference?
-bool Method::IsParamAReference(unsigned int param) const {
-  CHECK_LT(param, NumArgs());
-  if (IsStatic()) {
-    param++;  // 0th argument must skip return value at start of the shorty
-  } else if (param == 0) {
-    return true;  // this argument
-  }
-  return GetShorty()->CharAt(param) == 'L';
-}
-
-// Is the given method parameter a long or double?
-bool Method::IsParamALongOrDouble(unsigned int param) const {
-  CHECK_LT(param, NumArgs());
-  if (IsStatic()) {
-    param++;  // 0th argument must skip return value at start of the shorty
-  } else if (param == 0) {
-    return false;  // this argument
-  }
-  char ch = GetShorty()->CharAt(param);
-  return (ch == 'J' || ch == 'D');
-}
-
-static size_t ShortyCharToSize(char x) {
-  switch (x) {
-    case 'V': return 0;
-    case '[': return kPointerSize;
-    case 'L': return kPointerSize;
-    case 'D': return 8;
-    case 'J': return 8;
-    default:  return 4;
-  }
-}
-
-size_t Method::ParamSize(unsigned int param) const {
-  CHECK_LT(param, NumArgs());
-  if (IsStatic()) {
-    param++;  // 0th argument must skip return value at start of the shorty
-  } else if (param == 0) {
-    return kPointerSize;  // this argument
-  }
-  return ShortyCharToSize(GetShorty()->CharAt(param));
-}
-
-size_t Method::ReturnSize() const {
-  return ShortyCharToSize(GetShorty()->CharAt(0));
+bool Method::IsProxyMethod() const {
+  return GetDeclaringClass()->IsProxyClass();
 }
 
 Method* Method::FindOverriddenMethod() const {
@@ -635,25 +411,39 @@
   uint16_t method_index = GetMethodIndex();
   ObjectArray<Method>* super_class_vtable = super_class->GetVTable();
   Method* result = NULL;
+  // Did this method override a super class method? If so load the result from the super class'
+  // vtable
   if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
     result = super_class_vtable->Get(method_index);
   } else {
-    ObjectArray<Class>* interfaces = declaring_class->GetInterfaces();
-    String* name = GetName();
-    String* signature = GetSignature();
-    for (int32_t i = 0; i < interfaces->GetLength() && result == NULL; i++) {
-      Class* interface = interfaces->Get(i);
-      result = interface->FindInterfaceMethod(name, signature);
+    // Method didn't override superclass method so search interfaces
+    MethodHelper mh(this);
+    MethodHelper interface_mh;
+    ObjectArray<InterfaceEntry>* iftable = GetDeclaringClass()->GetIfTable();
+    for (int32_t i = 0; i < iftable->GetLength() && result == NULL; i++) {
+      InterfaceEntry* entry = iftable->Get(i);
+      Class* interface = entry->GetInterface();
+      for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
+        Method* interface_method = interface->GetVirtualMethod(j);
+        interface_mh.ChangeMethod(interface_method);
+        if (mh.HasSameNameAndSignature(&interface_mh)) {
+          result = interface_method;
+          break;
+        }
+      }
     }
   }
-  DCHECK(result == NULL || HasSameNameAndSignature(result));
+#ifndef NDEBUG
+  MethodHelper result_mh(result);
+  DCHECK(result == NULL || MethodHelper(this).HasSameNameAndSignature(&result_mh));
+#endif
   return result;
 }
 
 uint32_t Method::ToDexPC(const uintptr_t pc) const {
   const uint32_t* mapping_table = GetMappingTable();
   if (mapping_table == NULL) {
-    DCHECK(IsNative() || IsCalleeSaveMethod()) << PrettyMethod(this);
+    DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
     return DexFile::kDexNoIndex;   // Special no mapping case
   }
   size_t mapping_table_length = GetMappingTableLength();
@@ -695,10 +485,8 @@
 }
 
 uint32_t Method::FindCatchBlock(Class* exception_type, uint32_t dex_pc) const {
-  DexCache* dex_cache = GetDeclaringClass()->GetDexCache();
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
-  const DexFile::CodeItem* code_item = dex_file.GetCodeItem(GetCodeItemOffset());
+  MethodHelper mh(this);
+  const DexFile::CodeItem* code_item = mh.GetCodeItem();
   // Iterate over the catch handlers associated with dex_pc
   for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
     uint16_t iter_type_idx = it.GetHandlerTypeIndex();
@@ -707,11 +495,11 @@
       return it.GetHandlerAddress();
     }
     // Does this catch exception type apply?
-    Class* iter_exception_type = dex_cache->GetResolvedType(iter_type_idx);
+    Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
     if (iter_exception_type == NULL) {
       // The verifier should take care of resolving all exception classes early
       LOG(WARNING) << "Unresolved exception class when finding catch block: "
-          << dex_file.GetTypeDescriptor(dex_file.GetTypeId(iter_type_idx));
+          << mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
     } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
       return it.GetHandlerAddress();
     }
@@ -819,8 +607,9 @@
   }
 
   Class* super = GetSuperClass();
+  ClassHelper kh(this);
   os << "----- " << (IsInterface() ? "interface" : "class") << " "
-     << "'" << GetDescriptor()->ToModifiedUtf8() << "' cl=" << GetClassLoader() << " -----\n",
+     << "'" << kh.GetDescriptor() << "' cl=" << GetClassLoader() << " -----\n",
   os << "  objectSize=" << SizeOf() << " "
      << "(" << (super != NULL ? super->SizeOf() : -1) << " from super)\n",
   os << StringPrintf("  access=0x%04x.%04x\n",
@@ -831,10 +620,10 @@
   if (IsArrayClass()) {
     os << "  componentType=" << PrettyClass(GetComponentType()) << "\n";
   }
-  if (NumInterfaces() > 0) {
-    os << "  interfaces (" << NumInterfaces() << "):\n";
-    for (size_t i = 0; i < NumInterfaces(); ++i) {
-      Class* interface = GetInterface(i);
+  if (kh.NumInterfaces() > 0) {
+    os << "  interfaces (" << kh.NumInterfaces() << "):\n";
+    for (size_t i = 0; i < kh.NumInterfaces(); ++i) {
+      Class* interface = kh.GetInterface(i);
       const ClassLoader* cl = interface->GetClassLoader();
       os << StringPrintf("    %2d: %s (cl=%p)\n", i, PrettyClass(interface).c_str(), cl);
     }
@@ -963,11 +752,7 @@
   return false;
 }
 
-bool Class::IsInSamePackage(const String* descriptor_string_1,
-                            const String* descriptor_string_2) {
-  const std::string descriptor1(descriptor_string_1->ToModifiedUtf8());
-  const std::string descriptor2(descriptor_string_2->ToModifiedUtf8());
-
+bool Class::IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2) {
   size_t i = 0;
   while (descriptor1[i] != '\0' && descriptor1[i] == descriptor2[i]) {
     ++i;
@@ -1009,7 +794,11 @@
     klass2 = klass2->GetComponentType();
   }
   // Compare the package part of the descriptor string.
-  return IsInSamePackage(klass1->descriptor_, klass2->descriptor_);
+  ClassHelper kh(klass1);
+  std::string descriptor1 = kh.GetDescriptor();
+  kh.ChangeClass(klass2);
+  std::string descriptor2 = kh.GetDescriptor();
+  return IsInSamePackage(descriptor1, descriptor2);
 }
 
 bool Class::IsClassClass() const {
@@ -1018,8 +807,7 @@
 }
 
 bool Class::IsStringClass() const {
-  // TODO use "this == String::GetJavaLangString()" instead? or do we need this too early?
-  return this == GetDescriptor()->GetClass();
+  return this == String::GetJavaLangString();
 }
 
 ClassLoader* Class::GetClassLoader() const {
@@ -1047,8 +835,7 @@
   if (can_throw) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
         "Class %s does not implement interface %s",
-        PrettyDescriptor(GetDescriptor()).c_str(),
-        PrettyDescriptor(declaring_class->GetDescriptor()).c_str());
+        PrettyDescriptor(this).c_str(), PrettyDescriptor(declaring_class).c_str());
   }
   return NULL;
 }
@@ -1071,30 +858,13 @@
   return NULL;
 }
 
-Method* Class::FindInterfaceMethod(String* name,  String* signature) const {
-  // Check the current class before checking the interfaces.
-  Method* method = FindVirtualMethod(name, signature);
-  if (method != NULL) {
-    return method;
-  }
-  int32_t iftable_count = GetIfTableCount();
-  ObjectArray<InterfaceEntry>* iftable = GetIfTable();
-  for (int32_t i = 0; i < iftable_count; i++) {
-    Class* interface = iftable->Get(i)->GetInterface();
-    method = interface->FindVirtualMethod(name, signature);
-    if (method != NULL) {
-      return method;
-    }
-  }
-  return NULL;
-}
-
 Method* Class::FindDeclaredDirectMethod(const StringPiece& name,
                                         const StringPiece& signature) {
+  MethodHelper mh;
   for (size_t i = 0; i < NumDirectMethods(); ++i) {
     Method* method = GetDirectMethod(i);
-    if (method->GetName()->Equals(name) &&
-        method->GetSignature()->Equals(signature)) {
+    mh.ChangeMethod(method);
+    if (name == mh.GetName() && signature == mh.GetSignature()) {
       return method;
     }
   }
@@ -1114,19 +884,11 @@
 
 Method* Class::FindDeclaredVirtualMethod(const StringPiece& name,
                                          const StringPiece& signature) const {
+  MethodHelper mh;
   for (size_t i = 0; i < NumVirtualMethods(); ++i) {
     Method* method = GetVirtualMethod(i);
-    if (method->GetName()->Equals(name) && method->GetSignature()->Equals(signature)) {
-      return method;
-    }
-  }
-  return NULL;
-}
-
-Method* Class::FindDeclaredVirtualMethod(String* name, String* signature) const {
-  for (size_t i = 0; i < NumVirtualMethods(); ++i) {
-    Method* method = GetVirtualMethod(i);
-    if (method->GetName() == name && method->GetSignature() == signature) {
+    mh.ChangeMethod(method);
+    if (name == mh.GetName() && signature == mh.GetSignature()) {
       return method;
     }
   }
@@ -1143,35 +905,14 @@
   return NULL;
 }
 
-Method* Class::FindVirtualMethod(String* name, String* signature) const {
-  for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
-    Method* method = klass->FindDeclaredVirtualMethod(name, signature);
-    if (method != NULL) {
-      return method;
-    }
-  }
-  return NULL;
-}
-
 Field* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
   // Is the field in this class?
   // Interfaces are not relevant because they can't contain instance fields.
+  FieldHelper fh;
   for (size_t i = 0; i < NumInstanceFields(); ++i) {
     Field* f = GetInstanceField(i);
-    if (f->GetName()->Equals(name) &&
-        StringPiece(f->GetTypeDescriptor()) == type) {
-      return f;
-    }
-  }
-  return NULL;
-}
-
-Field* Class::FindDeclaredInstanceField(String* name, String* type) {
-  // Is the field in this class?
-  // Interfaces are not relevant because they can't contain instance fields.
-  for (size_t i = 0; i < NumInstanceFields(); ++i) {
-    Field* f = GetInstanceField(i);
-    if (f->GetName() == name && type->Equals(f->GetTypeDescriptor())) {
+    fh.ChangeField(f);
+    if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
       return f;
     }
   }
@@ -1190,34 +931,13 @@
   return NULL;
 }
 
-Field* Class::FindInstanceField(String* name, String* type) {
-  // Is the field in this class, or any of its superclasses?
-  // Interfaces are not relevant because they can't contain instance fields.
-  for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
-    Field* f = c->FindDeclaredInstanceField(name, type);
-    if (f != NULL) {
-      return f;
-    }
-  }
-  return NULL;
-}
-
 Field* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
   DCHECK(type != NULL);
+  FieldHelper fh;
   for (size_t i = 0; i < NumStaticFields(); ++i) {
     Field* f = GetStaticField(i);
-    if (f->GetName()->Equals(name) && StringPiece(f->GetTypeDescriptor()) == type) {
-      return f;
-    }
-  }
-  return NULL;
-}
-
-Field* Class::FindDeclaredStaticField(String* name, String* type) {
-  DCHECK(type != NULL);
-  for (size_t i = 0; i < NumStaticFields(); ++i) {
-    Field* f = GetStaticField(i);
-    if (f->GetName() == name && type->Equals(f->GetTypeDescriptor())) {
+    fh.ChangeField(f);
+    if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
       return f;
     }
   }
@@ -1247,29 +967,6 @@
   return NULL;
 }
 
-Field* Class::FindStaticField(String* name, String* type) {
-  // Is the field in this class (or its interfaces), or any of its
-  // superclasses (or their interfaces)?
-  for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
-    // Is the field in this class?
-    Field* f = c->FindDeclaredStaticField(name, type);
-    if (f != NULL) {
-      return f;
-    }
-
-    // Is this field in any of this class' interfaces?
-    for (int32_t i = 0; i < c->GetIfTableCount(); ++i) {
-      InterfaceEntry* interface_entry = c->GetIfTable()->Get(i);
-      Class* interface = interface_entry->GetInterface();
-      f = interface->FindDeclaredStaticField(name, type);
-      if (f != NULL) {
-        return f;
-      }
-    }
-  }
-  return NULL;
-}
-
 Array* Array::Alloc(Class* array_class, int32_t component_count, size_t component_size) {
   DCHECK(array_class != NULL);
   DCHECK_GE(component_count, 0);
@@ -1284,7 +981,7 @@
   if (data_size >> component_shift != size_t(component_count) || size < data_size) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;",
         "%s of length %zd exceeds the VM limit",
-        PrettyDescriptor(array_class->GetDescriptor()).c_str(), component_count);
+        PrettyDescriptor(array_class).c_str(), component_count);
     return NULL;
   }
 
@@ -1553,9 +1250,9 @@
   java_lang_StackTraceElement_ = NULL;
 }
 
-StackTraceElement* StackTraceElement::Alloc(const String* declaring_class,
-                                            const String* method_name,
-                                            const String* file_name,
+StackTraceElement* StackTraceElement::Alloc(String* declaring_class,
+                                            String* method_name,
+                                            String* file_name,
                                             int32_t line_number) {
   StackTraceElement* trace =
       down_cast<StackTraceElement*>(GetStackTraceElement()->AllocObject());
diff --git a/src/object.h b/src/object.h
index 82cd0a3..1a58364 100644
--- a/src/object.h
+++ b/src/object.h
@@ -97,6 +97,7 @@
 
 static const uint32_t kAccConstructor = 0x00010000;  // method (dex only)
 static const uint32_t kAccDeclaredSynchronized = 0x00020000;  // method (dex only)
+static const uint32_t kAccClassIsProxy = 0x00040000;  // class (dex only)
 static const uint32_t kAccWritable = 0x80000000; // method (dex only)
 
 // Special runtime-only flags.
@@ -380,10 +381,6 @@
 
   void SetDeclaringClass(Class *new_declaring_class);
 
-  String* GetName() const;
-
-  void SetName(String* new_name);
-
   uint32_t GetAccessFlags() const;
 
   void SetAccessFlags(uint32_t new_access_flags) {
@@ -402,25 +399,13 @@
     return (GetAccessFlags() & kAccFinal) != 0;
   }
 
-  uint32_t GetTypeIdx() const;
+  uint32_t GetDexFieldIndex() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), false);
+  }
 
-  void SetTypeIdx(uint32_t type_idx);
-
-  // Gets type using type index and resolved types in the dex cache, may be null
-  // if type isn't yet resolved
-  Class* GetTypeDuringLinking() const;
-
-  bool IsPrimitiveType() const;
-
-  Primitive::Type GetPrimitiveType() const;
-
-  size_t PrimitiveSize() const;
-
-  const char* GetTypeDescriptor() const;
-
-  // Performs full resolution, may return null and set exceptions if type cannot
-  // be resolved
-  Class* GetType();
+  void SetDexFieldIndex(uint32_t new_idx) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), new_idx, false);
+  }
 
   // Offset to field within an Object
   MemberOffset GetOffset() const;
@@ -473,35 +458,19 @@
     return (GetAccessFlags() & kAccVolatile) != 0;
   }
 
-  void InitJavaFields();
-
  private:
-  void InitJavaFieldsLocked();
-
   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
-
-  // The class in which this field is declared.
+  // The class we are a part of
   Class* declaring_class_;
 
-  Object* generic_type_;
-
-  String* name_;
-
-  // The possibly null type of the field
-  Class* type_;
-
-  uint32_t generic_types_are_initialized_;
-
   uint32_t access_flags_;
 
+  // Dex cache index of field id
+  uint32_t field_dex_idx_;
+
   // Offset of field within an instance or in the Class' static fields
   uint32_t offset_;
 
-  // Dex cache index of resolved type
-  uint32_t type_idx_;
-
-  int32_t slot_;
-
   static Class* java_lang_reflect_Field_;
 
   friend struct FieldOffsets;  // for verifying offset information
@@ -526,23 +495,6 @@
     return MemberOffset(OFFSETOF_MEMBER(Method, declaring_class_));
   }
 
-  // Returns the method name, e.g. "<init>" or "eatLunch"
-  String* GetName() const;
-
-  void SetName(String* new_name);
-
-  String* GetShorty() const;
-
-  void SetShorty(String* new_shorty);
-
-  String* GetSignature() const;
-
-  void SetSignature(String* new_signature);
-
-  bool HasSameNameAndSignature(const Method* that) const {
-    return GetName() == that->GetName() && GetSignature() == that->GetSignature();
-  }
-
   uint32_t GetAccessFlags() const;
 
   void SetAccessFlags(uint32_t new_access_flags) {
@@ -569,9 +521,6 @@
     return (GetAccessFlags() & kAccConstructor) != 0;
   }
 
-  // Is this method <clinit>
-  bool IsClassInitializer() const;
-
   // Returns true if the method is static, private, or a constructor.
   bool IsDirect() const {
     return IsStatic() || IsPrivate() || IsConstructor();
@@ -603,7 +552,7 @@
     return (GetAccessFlags() & kAccSynthetic) != 0;
   }
 
-  uint32_t GetDexMethodIndex() const;
+  bool IsProxyMethod() const;
 
   uint16_t GetMethodIndex() const;
 
@@ -630,28 +579,10 @@
   // Number of 32bit registers that would be required to hold all the arguments
   static size_t NumArgRegisters(const StringPiece& shorty);
 
-  uint16_t NumRegisters() const;
+  uint32_t GetDexMethodIndex() const;
 
-  void SetNumRegisters(uint16_t new_num_registers) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_registers_), new_num_registers, false);
-  }
-
-  uint16_t NumIns() const;
-
-  void SetNumIns(uint16_t new_num_ins) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_ins_), new_num_ins, false);
-  }
-
-  uint16_t NumOuts() const;
-
-  void SetNumOuts(uint16_t new_num_outs) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_outs_), new_num_outs, false);
-  }
-
-  uint32_t GetProtoIdx() const;
-
-  void SetProtoIdx(uint32_t new_proto_idx) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Method, proto_idx_), new_proto_idx, false);
+  void SetDexMethodIndex(uint32_t new_idx) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_dex_index_), new_idx, false);
   }
 
   ObjectArray<String>* GetDexCacheStrings() const;
@@ -692,63 +623,6 @@
   // Find the method that this method overrides
   Method* FindOverriddenMethod() const;
 
-  void SetReturnTypeIdx(uint32_t new_return_type_idx);
-
-  const char* GetReturnTypeDescriptor() const;
-
-  Class* GetReturnType() const;
-
-  bool IsReturnAReference() const;
-
-  bool IsReturnAFloat() const;
-
-  bool IsReturnADouble() const;
-
-  bool IsReturnAFloatOrDouble() const {
-    return IsReturnAFloat() || IsReturnADouble();
-  }
-
-  bool IsReturnALong() const;
-
-  bool IsReturnALongOrDouble() const {
-    return IsReturnALong() || IsReturnADouble();
-  }
-
-  bool IsReturnVoid() const;
-
-  // "Args" may refer to any of the 3 levels of "Args."
-  // To avoid confusion, our code will denote which "Args" clearly:
-  //  1. UserArgs: Args that a user see.
-  //  2. Args: Logical JVM-level Args. E.g., the first in Args will be the
-  //       receiver.
-  //  3. CConvArgs: Calling Convention Args, which is physical-level Args.
-  //       E.g., the first in Args is Method* for both static and non-static
-  //       methods. And CConvArgs doesn't deal with the receiver because
-  //       receiver is hardwired in an implicit register, so CConvArgs doesn't
-  //       need to deal with it.
-  //
-  // The number of Args that should be supplied to this method
-  size_t NumArgs() const;
-
-  // The number of reference arguments to this method including implicit this
-  // pointer.
-  size_t NumReferenceArgs() const;
-
-  // The number of long or double arguments.
-  size_t NumLongOrDoubleArgs() const;
-
-  // Is the given method parameter a reference?
-  bool IsParamAReference(unsigned int param) const;
-
-  // Is the given method parameter a long or double?
-  bool IsParamALongOrDouble(unsigned int param) const;
-
-  // Size in bytes of the given parameter
-  size_t ParamSize(unsigned int param) const;
-
-  // Size in bytes of the return value
-  size_t ReturnSize() const;
-
   void Invoke(Thread* self, Object* receiver, byte* args, JValue* result) const;
 
   const void* GetCode() const {
@@ -924,18 +798,6 @@
     SetField32(OFFSET_OF_OBJECT_MEMBER(Method, fp_spill_mask_), fp_spill_mask, false);
   }
 
-  ObjectArray<Class>* GetExceptionTypes() const {
-    return GetFieldObject<ObjectArray<Class>*>(
-        OFFSET_OF_OBJECT_MEMBER(Method, java_exception_types_), false);
-  }
-
-  void SetExceptionTypes(ObjectArray<Class>* exception_types);
-
-  ObjectArray<Class>* GetJavaParameterTypes() const {
-    return GetFieldObject<ObjectArray<Class>*>(
-        OFFSET_OF_OBJECT_MEMBER(Method, java_parameter_types_), false);
-  }
-
   // Is this a hand crafted method used for something like describing callee saves?
   bool IsCalleeSaveMethod() const {
     Runtime* runtime = Runtime::Current();
@@ -974,26 +836,10 @@
 
   static void ResetClasses();
 
-  void InitJavaFields();
-
  private:
-  uint32_t GetReturnTypeIdx() const;
-  void InitJavaFieldsLocked();
-
   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
-  // the class we are a part of
+  // The class we are a part of
   Class* declaring_class_;
-  ObjectArray<Class>* java_exception_types_; // TODO
-  Object* java_formal_type_parameters_;
-  Object* java_generic_exception_types_;
-  Object* java_generic_parameter_types_;
-  Object* java_generic_return_type_;
-
-  String* name_;
-
-  // Initialized by InitJavaFields.
-  ObjectArray<Class>* java_parameter_types_;
-  Class* java_return_type_;
 
   // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
   CodeAndDirectMethods* dex_cache_code_and_direct_methods_;
@@ -1016,23 +862,6 @@
   // Garbage collection map
   Object* gc_map_;
 
-  // The short-form method descriptor string.
-  String* shorty_;
-
-  // The method descriptor.  This represents the parameters a method
-  // takes and value it returns.  This string is a list of the type
-  // descriptors for the parameters enclosed in parenthesis followed
-  // by the return type descriptor.  For example, for the method
-  //
-  //   Object mymethod(int i, double d, Thread t)
-  //
-  // the method descriptor would be
-  //
-  //   (IDLjava/lang/Thread;)Ljava/lang/Object;
-  String* signature_;
-
-  uint32_t java_generic_types_are_initialized_;
-
   // Access flags; low 16 bits are defined by spec.
   uint32_t access_flags_;
 
@@ -1055,13 +884,12 @@
   // Native invocation stub entry point for calling from native to managed code.
   const InvokeStub* invoke_stub_;
 
-  // Index of the return type in the declaring classes dex cache or dex file's type ids
-  // TODO: value is really just 16bit
-  uint32_t java_return_type_idx_;
-
   // Mapping from native pc to dex pc
   const uint32_t* mapping_table_;
 
+  // Index into method_ids of the dex file associated with this method
+  uint32_t method_dex_index_;
+
   // For concrete virtual methods, this is the offset of the method in Class::vtable_.
   //
   // For abstract methods in an interface class, this is the offset of the method in
@@ -1071,24 +899,11 @@
   // The target native method registered with this method
   const void* native_method_;
 
-  // Method bounds; not needed for an abstract method.
-  //
-  // For a native method, we compute the size of the argument list, and
-  // set "insSize" and "registerSize" equal to it.
-  uint32_t num_ins_;
-  uint32_t num_outs_;
-  uint32_t num_registers_;  // ins + locals
-
-  // Method prototype descriptor string (return and argument types).
-  uint32_t proto_idx_;
-
   // When a register is promoted into a register, the spill mask holds which registers hold dex
   // registers. The first promoted register's corresponding dex register is vmap_table_[1], the Nth
   // is vmap_table_[N]. vmap_table_[0] holds the length of the table.
   const uint16_t* vmap_table_;
 
-  uint32_t java_slot_;
-
   static Class* java_lang_reflect_Constructor_;
   static Class* java_lang_reflect_Method_;
 
@@ -1351,6 +1166,17 @@
     return (GetAccessFlags() & kAccClassIsPhantomReference) != 0;
   }
 
+  String* GetName() const;
+  void SetName(String* name);
+
+  bool IsProxyClass() const {
+    // Read access flags without using getter as whether something is a proxy can be check in
+    // any loaded state
+    // TODO: switch to a check if the super class is java.lang.reflect.Proxy?
+    uint32_t access_flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
+    return (access_flags & kAccClassIsProxy) != 0;
+  }
+
   Primitive::Type GetPrimitiveType() const {
     DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t));
     return static_cast<Primitive::Type>(
@@ -1444,16 +1270,6 @@
   // Creates a raw object instance but does not invoke the default constructor.
   Object* AllocObject();
 
-  const String* GetDescriptor() const {
-    const String* result = GetFieldObject<const String*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, descriptor_), false);
-    // DCHECK(result != NULL);  // may be NULL prior to class linker initialization
-    // DCHECK_NE(0, result->GetLength());  // TODO: keep?
-    return result;
-  }
-
-  void SetDescriptor(String* new_descriptor);
-
   bool IsVariableSize() const {
     // Classes and arrays vary in size, and so the object_size_ field cannot
     // be used to get their instance size
@@ -1489,15 +1305,15 @@
   // Returns true if this class is in the same packages as that class.
   bool IsInSamePackage(const Class* that) const;
 
-  static bool IsInSamePackage(const String* descriptor1, const String* descriptor2);
+  static bool IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2);
 
   // Returns true if this class can access that class.
-  bool CanAccess(const Class* that) const {
+  bool CanAccess(Class* that) const {
     return that->IsPublic() || this->IsInSamePackage(that);
   }
 
   // Validate method/field access.
-  bool CanAccessMember(const Class* access_to, uint32_t member_flags) const {
+  bool CanAccessMember(Class* access_to, uint32_t member_flags) const {
     // quick accept for public access
     if (member_flags & kAccPublic) {
       return true;
@@ -1556,10 +1372,6 @@
     return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
   }
 
-  static MemberOffset SuperClassOffset() {
-    return MemberOffset(OFFSETOF_MEMBER(Class, super_class_));
-  }
-
   void SetSuperClass(Class *new_super_class) {
     // super class is assigned once, except during class linker initialization
     Class* old_super_class = GetFieldObject<Class*>(
@@ -1573,14 +1385,8 @@
     return GetSuperClass() != NULL;
   }
 
-  uint32_t GetSuperClassTypeIdx() const {
-    DCHECK(IsIdxLoaded() || IsErroneous());
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, super_class_type_idx_),
-                      false);
-  }
-
-  void SetSuperClassTypeIdx(int32_t new_super_class_idx) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Class, super_class_type_idx_), new_super_class_idx, false);
+  static MemberOffset SuperClassOffset() {
+    return MemberOffset(OFFSETOF_MEMBER(Class, super_class_));
   }
 
   ClassLoader* GetClassLoader() const;
@@ -1703,7 +1509,6 @@
   Method* FindVirtualMethodForInterface(Method* method, bool can_throw);
 
   Method* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const;
-  Method* FindInterfaceMethod(String* name, String* descriptor) const;
 
   Method* FindVirtualMethodForVirtualOrInterface(Method* method) {
     if (method->IsDirect()) {
@@ -1716,10 +1521,8 @@
   }
 
   Method* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const;
-  Method* FindDeclaredVirtualMethod(String* name, String* signature) const;
 
   Method* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const;
-  Method* FindVirtualMethod(String* name, String* descriptor) const;
 
   Method* FindDeclaredDirectMethod(const StringPiece& name,
                                    const StringPiece& signature);
@@ -1727,43 +1530,6 @@
   Method* FindDirectMethod(const StringPiece& name,
                            const StringPiece& signature);
 
-  size_t NumInterfaces() const {
-    CHECK(IsIdxLoaded() || IsErroneous()); // used during loading
-    ObjectArray<Class>* interfaces = GetFieldObject<ObjectArray<Class>*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false);
-    return (interfaces != NULL) ? interfaces->GetLength() : 0;
-  }
-
-  IntArray* GetInterfacesTypeIdx() const {
-    CHECK(IsIdxLoaded() || IsErroneous());
-    return GetFieldObject<IntArray*>(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_type_idx_), false);
-  }
-
-  void SetInterfacesTypeIdx(IntArray* new_interfaces_idx);
-
-  ObjectArray<Class>* GetInterfaces() const {
-    CHECK(IsLoaded() || IsErroneous());
-    return GetFieldObject<ObjectArray<Class>*>(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false);
-  }
-
-  void SetInterfaces(ObjectArray<Class>* new_interfaces) {
-    DCHECK(NULL == GetFieldObject<Object*>(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false));
-    SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), new_interfaces, false);
-  }
-
-  void SetInterface(uint32_t i, Class* f) {  // TODO: uint16_t
-    DCHECK_LT(i, NumInterfaces());
-    ObjectArray<Class>* interfaces =
-        GetFieldObject<ObjectArray<Class>*>(
-            OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false);
-    interfaces->Set(i, f);
-  }
-
-  Class* GetInterface(uint32_t i) const {
-    DCHECK_LT(i, NumInterfaces());
-    return GetInterfaces()->Get(i);
-  }
-
   int32_t GetIfTableCount() const {
     ObjectArray<InterfaceEntry>* iftable = GetIfTable();
     if (iftable == NULL) {
@@ -1890,17 +1656,13 @@
 
   // Finds the given instance field in this class or a superclass.
   Field* FindInstanceField(const StringPiece& name, const StringPiece& type);
-  Field* FindInstanceField(String* name, String* type);
 
   Field* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type);
-  Field* FindDeclaredInstanceField(String* name, String* type);
 
   // Finds the given static field in this class or a superclass.
   Field* FindStaticField(const StringPiece& name, const StringPiece& type);
-  Field* FindStaticField(String* name, String* type);
 
   Field* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type);
-  Field* FindDeclaredStaticField(String* name, String* type);
 
   pid_t GetClinitThreadId() const {
     DCHECK(IsIdxLoaded() || IsErroneous());
@@ -1920,26 +1682,14 @@
     klass->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), klass, false);
   }
 
-  uint32_t GetAnnotationsOffset() {
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, annotations_offset_), false);
+  uint16_t GetDexTypeIndex() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), false);
   }
 
-  void SetAnnotationsOffset(uint32_t annotations_offset) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Class, annotations_offset_), annotations_offset, false);
+  void SetDexTypeIndex(uint16_t type_idx) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), type_idx, false);
   }
 
-  uint32_t GetTypeIdx() {
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, type_idx_), false);
-  }
-
-  void SetTypeIdx(uint32_t type_idx) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Class, type_idx_), type_idx, false);
-  }
-
-  String* GetSourceFile() const;
-
-  void SetSourceFile(String* new_source_file);
-
  private:
   bool Implements(const Class* klass) const;
   bool IsArrayAssignableFromArray(const Class* klass) const;
@@ -1955,9 +1705,6 @@
   // (for String[][][], this will be String[][]). NULL for non-array classes.
   Class* component_type_;
 
-  // descriptor for the class such as "Ljava/lang/Class;" or "[C"
-  String* descriptor_;
-
   // DexCache of resolved constant pool entries
   // (will be NULL for VM-generated, e.g. arrays and primitive classes)
   DexCache* dex_cache_;
@@ -1992,20 +1739,9 @@
   // of the concrete vtable_ methods for the methods in the interface.
   ObjectArray<InterfaceEntry>* iftable_;
 
-  // array of interfaces this class implements directly
-  // see also interfaces_type_idx_
-  ObjectArray<Class>* interfaces_;
-
-  // array of type_idx's for interfaces this class implements directly
-  // see also interfaces_
-  IntArray* interfaces_type_idx_;
-
   // Static fields
   ObjectArray<Field>* sfields_;
 
-  // source file name, if known.  Otherwise, NULL.
-  String* source_file_;
-
   // The superclass, or NULL if this is java.lang.Object or a
   // primitive type.
   // see also super_class_type_idx_;
@@ -2023,12 +1759,13 @@
   // virtual_ methods_ for miranda methods.
   ObjectArray<Method>* vtable_;
 
+  // type index from dex file
+  // TODO: really 16bits
+  uint32_t dex_type_idx_;
+
   // access flags; low 16 bits are defined by VM spec
   uint32_t access_flags_;
 
-  // annotation directory offset from dex file
-  uint32_t annotations_offset_;
-
   // Total size of the Class instance; used when allocating storage on gc heap.
   // See also object_size_.
   size_t class_size_;
@@ -2059,15 +1796,6 @@
   // state of class initialization
   Status status_;
 
-  // Set in LoadClass, used to LinkClass
-  // see also super_class_
-  // TODO: really 16bits
-  uint32_t super_class_type_idx_;
-
-  // type index from dex file
-  // TODO: really 16bits
-  uint32_t type_idx_;
-
   // TODO: ?
   // initiating class loader list
   // NOTE: for classes with low serialNumber, these are unused, and the
@@ -2187,32 +1915,6 @@
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, declaring_class_), new_declaring_class, false);
 }
 
-inline uint32_t Method::GetReturnTypeIdx() const {
-  DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, java_return_type_idx_), false);
-}
-
-inline bool Method::IsReturnAReference() const {
-  char d = GetReturnTypeDescriptor()[0];
-  return d == 'L' || d == '[';
-}
-
-inline bool Method::IsReturnAFloat() const {
-  return GetReturnTypeDescriptor()[0] == 'F';
-}
-
-inline bool Method::IsReturnADouble() const {
-  return GetReturnTypeDescriptor()[0] == 'D';
-}
-
-inline bool Method::IsReturnALong() const {
-  return GetReturnTypeDescriptor()[0] == 'J';
-}
-
-inline bool Method::IsReturnVoid() const {
-  return GetReturnTypeDescriptor()[0] == 'V';
-}
-
 inline size_t Array::SizeOf() const {
   // This is safe from overflow because the array was already allocated, so we know it's sane.
   return sizeof(Array) + GetLength() * GetClass()->GetComponentSize();
@@ -2309,14 +2011,6 @@
 class MANAGED FieldClass : public Class {
  private:
   Object* ORDER_BY_NAME_AND_DECLARING_CLASS_;
-  uint32_t TYPE_BOOLEAN_;
-  uint32_t TYPE_BYTE_;
-  uint32_t TYPE_CHAR_;
-  uint32_t TYPE_DOUBLE_;
-  uint32_t TYPE_FLOAT_;
-  uint32_t TYPE_INTEGER_;
-  uint32_t TYPE_LONG_;
-  uint32_t TYPE_SHORT_;
   friend struct FieldClassOffsets;  // for verifying offset information
   DISALLOW_IMPLICIT_CONSTRUCTORS(FieldClass);
 };
@@ -2377,13 +2071,6 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(PrimitiveArray);
 };
 
-inline void Class::SetInterfacesTypeIdx(IntArray* new_interfaces_idx) {
-  DCHECK(NULL == GetFieldObject<IntArray*>(
-      OFFSET_OF_OBJECT_MEMBER(Class, interfaces_type_idx_), false));
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_type_idx_),
-                 new_interfaces_idx, false);
-}
-
 // C++ mirror of java.lang.String
 class MANAGED String : public Object {
  public:
@@ -2500,27 +2187,11 @@
   }
 };
 
-inline String* Field::GetName() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  String* result = GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Field, name_), false);
-  DCHECK(result != NULL);
-  return result;
-}
-
-inline void Field::SetName(String* new_name) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Field, name_), new_name, false);
-}
-
 inline uint32_t Field::GetAccessFlags() const {
   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), false);
 }
 
-inline uint32_t Field::GetTypeIdx() const {
-  DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, type_idx_), false);
-}
-
 inline MemberOffset Field::GetOffset() const {
   DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
   return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
@@ -2531,43 +2202,6 @@
   return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
 }
 
-inline String* Method::GetName() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  String* result = GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Method, name_), false);
-  DCHECK(result != NULL);
-  return result;
-}
-
-inline void Method::SetName(String* new_name) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, name_), new_name, false);
-}
-
-inline String* Method::GetShorty() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Method, shorty_), false);
-}
-
-inline void Method::SetShorty(String* new_shorty) {
-  DCHECK(NULL == GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Method, shorty_), false));
-  DCHECK_LE(1, new_shorty->GetLength());
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, shorty_), new_shorty, false);
-}
-
-inline String* Method::GetSignature() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  String* result = GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Method, signature_), false);
-  DCHECK(result != NULL);
-  return result;
-}
-
-inline void Method::SetSignature(String* new_signature) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, signature_), new_signature, false);
-}
-
-inline void Method::SetExceptionTypes(ObjectArray<Class>* exception_types) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, java_exception_types_), exception_types, false);
-}
-
 inline uint32_t Class::GetAccessFlags() const {
   // Check class is loaded or this is java.lang.String that has a
   // circularity issue during loading the names of its members
@@ -2579,23 +2213,6 @@
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
 }
 
-inline void Class::SetDescriptor(String* new_descriptor) {
-  DCHECK(GetDescriptor() == NULL);
-  DCHECK(new_descriptor != NULL);
-  DCHECK_NE(0, new_descriptor->GetLength());
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, descriptor_),
-                 new_descriptor, false);
-}
-
-inline String* Class::GetSourceFile() const {
-  DCHECK(IsLoaded() || IsErroneous());
-  return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, source_file_), false);
-}
-
-inline void Class::SetSourceFile(String* new_source_file) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, source_file_), new_source_file, false);
-}
-
 inline uint32_t Method::GetAccessFlags() const {
   DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, access_flags_), false);
@@ -2606,24 +2223,16 @@
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_index_), false);
 }
 
-inline uint16_t Method::NumRegisters() const {
+inline uint32_t Method::GetDexMethodIndex() const {
   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_registers_), false);
+  return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_dex_index_), false);
 }
 
-inline uint16_t Method::NumIns() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_ins_), false);
+inline String* Class::GetName() const {
+  return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, name_), false);
 }
-
-inline uint16_t Method::NumOuts() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_outs_), false);
-}
-
-inline uint32_t Method::GetProtoIdx() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, proto_idx_), false);
+inline void Class::SetName(String* name) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, name_), name, false);
 }
 
 // C++ mirror of java.lang.Throwable
@@ -2675,9 +2284,9 @@
         OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_), false);
   }
 
-  static StackTraceElement* Alloc(const String* declaring_class,
-                                  const String* method_name,
-                                  const String* file_name,
+  static StackTraceElement* Alloc(String* declaring_class,
+                                  String* method_name,
+                                  String* file_name,
                                   int32_t line_number);
 
   static void SetClass(Class* java_lang_StackTraceElement);
@@ -2686,9 +2295,9 @@
 
  private:
   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
-  const String* declaring_class_;
-  const String* file_name_;
-  const String* method_name_;
+  String* declaring_class_;
+  String* file_name_;
+  String* method_name_;
   int32_t line_number_;
 
   static Class* GetStackTraceElement() {
@@ -2719,7 +2328,7 @@
 
   size_t GetMethodArrayCount() const {
     ObjectArray<Method>* method_array = down_cast<ObjectArray<Method>*>(Get(kMethodArray));
-    if (method_array == 0) {
+    if (method_array == NULL) {
       return 0;
     }
     return method_array->GetLength();
diff --git a/src/object_test.cc b/src/object_test.cc
index 08abb6f..b1d5885 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -42,18 +42,12 @@
 
 TEST_F(ObjectTest, IsInSamePackage) {
   // Matches
-  SirtRef<String> Object_descriptor(String::AllocFromModifiedUtf8("Ljava/lang/Object;"));
-  SirtRef<String> Class_descriptor(String::AllocFromModifiedUtf8("Ljava/lang/Class;"));
-  EXPECT_TRUE(Class::IsInSamePackage(Object_descriptor.get(), Class_descriptor.get()));
-  SirtRef<String> Foo_descriptor(String::AllocFromModifiedUtf8("LFoo;"));
-  SirtRef<String> Bar_descriptor(String::AllocFromModifiedUtf8("LBar;"));
-  EXPECT_TRUE(Class::IsInSamePackage(Foo_descriptor.get(), Bar_descriptor.get()));
+  EXPECT_TRUE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/Class;"));
+  EXPECT_TRUE(Class::IsInSamePackage("LFoo;", "LBar;"));
 
   // Mismatches
-  SirtRef<String> File_descriptor(String::AllocFromModifiedUtf8("Ljava/io/File;"));
-  EXPECT_FALSE(Class::IsInSamePackage(Object_descriptor.get(), File_descriptor.get()));
-  SirtRef<String> Method_descriptor(String::AllocFromModifiedUtf8("Ljava/lang/reflect/Method;"));
-  EXPECT_FALSE(Class::IsInSamePackage(Object_descriptor.get(), Method_descriptor.get()));
+  EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/io/File;"));
+  EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/reflect/Method;"));
 }
 
 TEST_F(ObjectTest, Clone) {
@@ -90,11 +84,10 @@
   self->ClearException();
 
   ASSERT_TRUE(oa->GetClass() != NULL);
-  ASSERT_EQ(2U, oa->GetClass()->NumInterfaces());
-  EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"),
-            oa->GetClass()->GetInterface(0));
-  EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"),
-            oa->GetClass()->GetInterface(1));
+  ClassHelper oa_ch(oa->GetClass());
+  ASSERT_EQ(2U, oa_ch.NumInterfaces());
+  EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"), oa_ch.GetInterface(0));
+  EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"), oa_ch.GetInterface(1));
 }
 
 TEST_F(ObjectTest, AllocArray) {
@@ -288,34 +281,50 @@
   ASSERT_TRUE(klass2 != NULL);
 
   Method* m1_1 = klass1->GetVirtualMethod(0);
-  EXPECT_TRUE(m1_1->GetName()->Equals("m1"));
+  MethodHelper mh(m1_1);
+  EXPECT_STREQ(mh.GetName(), "m1");
   Method* m2_1 = klass1->GetVirtualMethod(1);
-  EXPECT_TRUE(m2_1->GetName()->Equals("m2"));
+  mh.ChangeMethod(m2_1);
+  EXPECT_STREQ(mh.GetName(), "m2");
   Method* m3_1 = klass1->GetVirtualMethod(2);
-  EXPECT_TRUE(m3_1->GetName()->Equals("m3"));
+  mh.ChangeMethod(m3_1);
+  EXPECT_STREQ(mh.GetName(), "m3");
   Method* m4_1 = klass1->GetVirtualMethod(3);
-  EXPECT_TRUE(m4_1->GetName()->Equals("m4"));
+  mh.ChangeMethod(m4_1);
+  EXPECT_STREQ(mh.GetName(), "m4");
 
   Method* m1_2 = klass2->GetVirtualMethod(0);
-  EXPECT_TRUE(m1_2->GetName()->Equals("m1"));
+  mh.ChangeMethod(m1_2);
+  EXPECT_STREQ(mh.GetName(), "m1");
   Method* m2_2 = klass2->GetVirtualMethod(1);
-  EXPECT_TRUE(m2_2->GetName()->Equals("m2"));
+  mh.ChangeMethod(m2_2);
+  EXPECT_STREQ(mh.GetName(), "m2");
   Method* m3_2 = klass2->GetVirtualMethod(2);
-  EXPECT_TRUE(m3_2->GetName()->Equals("m3"));
+  mh.ChangeMethod(m3_2);
+  EXPECT_STREQ(mh.GetName(), "m3");
   Method* m4_2 = klass2->GetVirtualMethod(3);
-  EXPECT_TRUE(m4_2->GetName()->Equals("m4"));
+  mh.ChangeMethod(m4_2);
+  EXPECT_STREQ(mh.GetName(), "m4");
 
-  EXPECT_TRUE(m1_1->HasSameNameAndSignature(m1_2));
-  EXPECT_TRUE(m1_2->HasSameNameAndSignature(m1_1));
+  mh.ChangeMethod(m1_1);
+  MethodHelper mh2(m1_2);
+  EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
+  EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
 
-  EXPECT_TRUE(m2_1->HasSameNameAndSignature(m2_2));
-  EXPECT_TRUE(m2_2->HasSameNameAndSignature(m2_1));
+  mh.ChangeMethod(m2_1);
+  mh2.ChangeMethod(m2_2);
+  EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
+  EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
 
-  EXPECT_TRUE(m3_1->HasSameNameAndSignature(m3_2));
-  EXPECT_TRUE(m3_2->HasSameNameAndSignature(m3_1));
+  mh.ChangeMethod(m3_1);
+  mh2.ChangeMethod(m3_2);
+  EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
+  EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
 
-  EXPECT_TRUE(m4_1->HasSameNameAndSignature(m4_2));
-  EXPECT_TRUE(m4_2->HasSameNameAndSignature(m4_1));
+  mh.ChangeMethod(m4_1);
+  mh2.ChangeMethod(m4_2);
+  EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
+  EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
 }
 
 
diff --git a/src/object_utils.h b/src/object_utils.h
new file mode 100644
index 0000000..dc48aa0
--- /dev/null
+++ b/src/object_utils.h
@@ -0,0 +1,508 @@
+/*
+ * Copyright (C) 2011 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_OBJECT_UTILS_H_
+#define ART_SRC_OBJECT_UTILS_H_
+
+#include "class_linker.h"
+#include "dex_cache.h"
+#include "dex_file.h"
+#include "object.h"
+#include "runtime.h"
+
+#include <string>
+
+namespace art {
+
+class ClassHelper {
+ public:
+  ClassHelper() : class_def_(NULL), class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL),
+      interface_type_list_(NULL), klass_(NULL) {}
+  ClassHelper(const Class* c) : class_def_(NULL), class_linker_(NULL), dex_cache_(NULL),
+      dex_file_(NULL), interface_type_list_(NULL), klass_(c) {}
+  ClassHelper(const Class* c, ClassLinker* l) : class_def_(NULL), class_linker_(l),
+      dex_cache_(NULL), dex_file_(NULL), interface_type_list_(NULL), klass_(c) {}
+
+  void ChangeClass(const Class* new_c) {
+    DCHECK(new_c != NULL);
+    if (dex_cache_ != NULL) {
+      DexCache* new_c_dex_cache = new_c->GetDexCache();
+      if (new_c_dex_cache != dex_cache_) {
+        dex_cache_ = new_c_dex_cache;
+        dex_file_ = NULL;
+      }
+    }
+    klass_ = new_c;
+    interface_type_list_ = NULL;
+    class_def_ = NULL;
+  }
+
+  std::string GetDescriptor() {
+    if (klass_->IsArrayClass()) {
+      std::string result = "[";
+      const Class* saved_klass = klass_;
+      ChangeClass(klass_->GetComponentType());
+      result += GetDescriptor();
+      ChangeClass(saved_klass);
+      return result;
+    } else if (klass_->IsPrimitive()){
+      std::string result;
+      result += Primitive::DescriptorChar(klass_->GetPrimitiveType());
+      return result;
+    } else if (klass_->IsProxyClass()) {
+      return GetClassLinker()->GetDescriptorForProxy(klass_);
+    } else {
+      const DexFile& dex_file = GetDexFile();
+      const DexFile::TypeId& type_id = dex_file.GetTypeId(klass_->GetDexTypeIndex());
+      return dex_file.GetTypeDescriptor(type_id);
+    }
+  }
+  const DexFile::ClassDef* GetClassDef() {
+    const DexFile::ClassDef* result = class_def_;
+    if (result == NULL) {
+      result = GetDexFile().FindClassDef(GetDescriptor());
+      class_def_ = result;
+    }
+    return result;
+  }
+  uint32_t NumInterfaces() {
+    if (klass_->IsPrimitive()) {
+      return 0;
+    } else if (klass_->IsArrayClass()) {
+      return 2;
+    } else {
+      CHECK(!klass_->IsProxyClass());
+      const DexFile::TypeList* interfaces = GetInterfaceTypeList();
+      if (interfaces == NULL) {
+        return 0;
+      } else {
+        return interfaces->Size();
+      }
+    }
+  }
+  uint16_t GetInterfaceTypeIdx(uint32_t idx) {
+    DCHECK(!klass_->IsPrimitive());
+    DCHECK(!klass_->IsArrayClass());
+    return GetInterfaceTypeList()->GetTypeItem(idx).type_idx_;
+  }
+  Class* GetInterface(uint32_t idx) {
+    DCHECK(!klass_->IsPrimitive());
+    if (klass_->IsArrayClass()) {
+      if (idx == 0) {
+        return GetClassLinker()->FindSystemClass("Ljava/lang/Cloneable;");
+      } else {
+        DCHECK_EQ(1U, idx);
+        return GetClassLinker()->FindSystemClass("Ljava/io/Serializable;");
+      }
+    } else {
+      uint16_t type_idx = GetInterfaceTypeIdx(idx);
+      Class* interface = GetDexCache()->GetResolvedType(type_idx);
+      if (interface == NULL) {
+        interface = GetClassLinker()->ResolveType(GetDexFile(), type_idx, klass_);
+        CHECK(interface != NULL || Thread::Current()->IsExceptionPending());
+      }
+      return interface;
+    }
+  }
+  const char* GetSourceFile() {
+    std::string descriptor = GetDescriptor();
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
+    if (dex_class_def == NULL) {
+      return NULL;
+    } else {
+      return dex_file.GetSourceFile(*dex_class_def);
+    }
+  }
+  std::string GetLocation() {
+    return GetDexCache()->GetLocation()->ToModifiedUtf8();
+  }
+
+  const DexFile& GetDexFile() {
+    const DexFile* result = dex_file_;
+    if (result == NULL) {
+      const DexCache* dex_cache = GetDexCache();
+      result = &GetClassLinker()->FindDexFile(dex_cache);
+      dex_file_ = result;
+    }
+    return *result;
+  }
+
+ private:
+  const DexFile::TypeList* GetInterfaceTypeList() {
+    const DexFile::TypeList* result = interface_type_list_;
+    if (result == NULL) {
+      const DexFile::ClassDef* class_def = GetClassDef();
+      if (class_def != NULL) {
+        result =  GetDexFile().GetInterfacesList(*class_def);
+        interface_type_list_ = result;
+      }
+    }
+    return result;
+  }
+  DexCache* GetDexCache() {
+    DexCache* result = dex_cache_;
+    if (result == NULL) {
+      result = klass_->GetDexCache();
+      dex_cache_ = result;
+    }
+    return result;
+  }
+  ClassLinker* GetClassLinker() {
+    ClassLinker* result = class_linker_;
+    if (result == NULL) {
+      result = Runtime::Current()->GetClassLinker();
+      class_linker_ = result;
+    }
+    return result;
+  }
+
+  const DexFile::ClassDef* class_def_;
+  ClassLinker* class_linker_;
+  DexCache* dex_cache_;
+  const DexFile* dex_file_;
+  const DexFile::TypeList* interface_type_list_;
+  const Class* klass_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClassHelper);
+};
+
+class FieldHelper {
+ public:
+  FieldHelper() : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(NULL) {}
+  FieldHelper(const Field* f) : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
+  FieldHelper(const Field* f, ClassLinker* l) : class_linker_(l), dex_cache_(NULL), dex_file_(NULL),
+      field_(f) {}
+
+  void ChangeField(const Field* new_f) {
+    DCHECK(new_f != NULL);
+    if (dex_cache_ != NULL) {
+      DexCache* new_f_dex_cache = new_f->GetDeclaringClass()->GetDexCache();
+      if (new_f_dex_cache != dex_cache_) {
+        dex_cache_ = new_f_dex_cache;
+        dex_file_ = NULL;
+      }
+    }
+    field_ = new_f;
+  }
+  const char* GetName() {
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetFieldName(dex_file.GetFieldId(field_->GetDexFieldIndex()));
+  }
+  String* GetNameAsString() {
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::FieldId& field_id = dex_file.GetFieldId(field_->GetDexFieldIndex());
+    return GetClassLinker()->ResolveString(dex_file, field_id.name_idx_, GetDexCache());
+  }
+  Class* GetType() {
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::FieldId& field_id = dex_file.GetFieldId(field_->GetDexFieldIndex());
+    Class* type = GetDexCache()->GetResolvedType(field_id.type_idx_);
+    if (type == NULL) {
+      type = GetClassLinker()->ResolveType(field_id.type_idx_, field_);
+      CHECK(type != NULL || Thread::Current()->IsExceptionPending());
+    }
+    return type;
+  }
+  const char* GetTypeDescriptor() {
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::FieldId& field_id = dex_file.GetFieldId(field_->GetDexFieldIndex());
+    return dex_file.GetFieldTypeDescriptor(field_id);
+  }
+  Primitive::Type GetTypeAsPrimitiveType() {
+    return Primitive::GetType(GetTypeDescriptor()[0]);
+  }
+  bool IsPrimitiveType() {
+    Primitive::Type type = GetTypeAsPrimitiveType();
+    return type != Primitive::kPrimNot;
+  }
+  size_t FieldSize() {
+    Primitive::Type type = GetTypeAsPrimitiveType();
+    return Primitive::FieldSize(type);
+  }
+  const char* GetDeclaringClassDescriptor() {
+    uint16_t type_idx = field_->GetDeclaringClass()->GetDexTypeIndex();
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
+  }
+
+ private:
+  DexCache* GetDexCache() {
+    DexCache* result = dex_cache_;
+    if (result == NULL) {
+      result = field_->GetDeclaringClass()->GetDexCache();
+      dex_cache_ = result;
+    }
+    return result;
+  }
+  ClassLinker* GetClassLinker() {
+    ClassLinker* result = class_linker_;
+    if (result == NULL) {
+      result = Runtime::Current()->GetClassLinker();
+      class_linker_ = result;
+    }
+    return result;
+  }
+  const DexFile& GetDexFile() {
+    const DexFile* result = dex_file_;
+    if (result == NULL) {
+      const DexCache* dex_cache = GetDexCache();
+      result = &GetClassLinker()->FindDexFile(dex_cache);
+      dex_file_ = result;
+    }
+    return *result;
+  }
+
+  ClassLinker* class_linker_;
+  DexCache* dex_cache_;
+  const DexFile* dex_file_;
+  const Field* field_;
+
+  DISALLOW_COPY_AND_ASSIGN(FieldHelper);
+};
+
+class MethodHelper {
+ public:
+  MethodHelper() : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL),
+      shorty_(NULL), shorty_len_(0) {}
+  MethodHelper(const Method* m) : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL),
+      method_(NULL), shorty_(NULL), shorty_len_(0) {
+    SetMethod(m);
+  }
+  MethodHelper(const Method* m, ClassLinker* l) : class_linker_(l), dex_cache_(NULL),
+      dex_file_(NULL), method_(NULL), shorty_(NULL), shorty_len_(0) {
+    SetMethod(m);
+  }
+
+  void ChangeMethod(Method* new_m) {
+    DCHECK(new_m != NULL);
+    if (dex_cache_ != NULL) {
+      Class* klass = new_m->GetDeclaringClass();
+      if (klass->IsProxyClass()) {
+        dex_cache_ = NULL;
+        dex_file_ = NULL;
+      } else {
+        DexCache* new_m_dex_cache = klass->GetDexCache();
+        if (new_m_dex_cache != dex_cache_) {
+          dex_cache_ = new_m_dex_cache;
+          dex_file_ = NULL;
+        }
+      }
+    }
+    SetMethod(new_m);
+    shorty_ = NULL;
+  }
+  const char* GetName() {
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetMethodName(dex_file.GetMethodId(method_->GetDexMethodIndex()));
+  }
+  String* GetNameAsString() {
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
+    return GetClassLinker()->ResolveString(dex_file, method_id.name_idx_, GetDexCache());
+  }
+  const char* GetShorty() {
+    const char* result = shorty_;
+    if (result == NULL) {
+      const DexFile& dex_file = GetDexFile();
+      result = dex_file.GetMethodShorty(dex_file.GetMethodId(method_->GetDexMethodIndex()),
+                                        &shorty_len_);
+      shorty_ = result;
+    }
+    return result;
+  }
+  int32_t GetShortyLength() {
+    if (shorty_ == NULL) {
+      GetShorty();
+    }
+    return shorty_len_;
+  }
+  const std::string GetSignature() {
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetMethodSignature(dex_file.GetMethodId(method_->GetDexMethodIndex()));
+  }
+  const DexFile::ProtoId& GetPrototype() {
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetMethodPrototype(dex_file.GetMethodId(method_->GetDexMethodIndex()));
+  }
+  const DexFile::TypeList* GetParameterTypeList() {
+    const DexFile::ProtoId& proto = GetPrototype();
+    return GetDexFile().GetProtoParameters(proto);
+  }
+  ObjectArray<Class>* GetParameterTypes() {
+    const DexFile::TypeList* params = GetParameterTypeList();
+    Class* array_class = GetClassLinker()->FindSystemClass("[Ljava/lang/Class;");
+    uint32_t num_params = params == NULL ? 0 : params->Size();
+    ObjectArray<Class>* result = ObjectArray<Class>::Alloc(array_class, num_params);
+    for (uint32_t i = 0; i < num_params; i++) {
+      Class* param_type = GetClassFromTypeIdx(params->GetTypeItem(i).type_idx_);
+      result->Set(i, param_type);
+    }
+    return result;
+  }
+  Class* GetReturnType() {
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
+    const DexFile::ProtoId& proto_id = dex_file.GetMethodPrototype(method_id);
+    uint16_t return_type_idx = proto_id.return_type_idx_;
+    return GetClassFromTypeIdx(return_type_idx);
+  }
+  const char* GetReturnTypeDescriptor() {
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
+    const DexFile::ProtoId& proto_id = dex_file.GetMethodPrototype(method_id);
+    uint16_t return_type_idx = proto_id.return_type_idx_;
+    return dex_file.GetTypeDescriptor(dex_file.GetTypeId(return_type_idx));
+  }
+  int32_t GetLineNumFromNativePC(uintptr_t raw_pc) {
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetLineNumFromPC(method_, method_->ToDexPC(raw_pc));
+  }
+  const char* GetDeclaringClassDescriptor() {
+    Class* klass = method_->GetDeclaringClass();
+    CHECK(!klass->IsProxyClass());
+    uint16_t type_idx = klass->GetDexTypeIndex();
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
+  }
+  const char* GetDeclaringClassSourceFile() {
+    const char* descriptor = GetDeclaringClassDescriptor();
+    const DexFile& dex_file = GetDexFile();
+    const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
+    if (dex_class_def == NULL) {
+      return NULL;
+    } else {
+      return dex_file.GetSourceFile(*dex_class_def);
+    }
+  }
+  bool IsStatic() {
+    return method_->IsStatic();
+  }
+  bool IsClassInitializer() {
+    return IsStatic() && StringPiece(GetName()) == "<clinit>";
+  }
+  size_t NumArgs() {
+    // "1 +" because the first in Args is the receiver.
+    // "- 1" because we don't count the return type.
+    return (IsStatic() ? 0 : 1) + GetShortyLength() - 1;
+  }
+  // Is the specified parameter a long or double, where parameter 0 is 'this' for instance methods
+  bool IsParamALongOrDouble(size_t param) {
+    CHECK_LT(param, NumArgs());
+    if (IsStatic()) {
+      param++;  // 0th argument must skip return value at start of the shorty
+    } else if (param == 0) {
+      return false;  // this argument
+    }
+    char ch = GetShorty()[param];
+    return (ch == 'J' || ch == 'D');
+  }
+  // Is the specified parameter a reference, where parameter 0 is 'this' for instance methods
+  bool IsParamAReference(size_t param) {
+    CHECK_LT(param, NumArgs());
+    if (IsStatic()) {
+      param++;  // 0th argument must skip return value at start of the shorty
+    } else if (param == 0) {
+      return true;  // this argument
+    }
+    return GetShorty()[param] == 'L';  // An array also has a shorty character of 'L' (not '[')
+  }
+  bool HasSameNameAndSignature(MethodHelper* other) {
+    StringPiece name(GetName());
+    StringPiece other_name(other->GetName());
+    if (name != other_name) {
+      return false;
+    }
+    if (GetDexCache() == other->GetDexCache()) {
+      const DexFile& dex_file = GetDexFile();
+      const DexFile::MethodId& mid = dex_file.GetMethodId(method_->GetDexMethodIndex());
+      const DexFile::MethodId& other_mid =
+          dex_file.GetMethodId(other->method_->GetDexMethodIndex());
+      return mid.proto_idx_ == other_mid.proto_idx_;
+    }
+    return GetSignature() == other->GetSignature();
+  }
+  const DexFile::CodeItem* GetCodeItem() {
+    return GetDexFile().GetCodeItem(method_->GetCodeItemOffset());
+  }
+  Class* GetClassFromTypeIdx(uint16_t type_idx) {
+    Class* type = method_->GetDexCacheResolvedTypes()->Get(type_idx);
+    if (type == NULL) {
+      type = GetClassLinker()->ResolveType(type_idx, method_);
+      CHECK(type != NULL || Thread::Current()->IsExceptionPending());
+    }
+    return type;
+  }
+  const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx) {
+    const DexFile& dex_file = GetDexFile();
+    return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
+  }
+  Class* GetDexCacheResolvedType(uint16_t type_idx) {
+    return GetDexCache()->GetResolvedType(type_idx);
+  }
+  const DexFile& GetDexFile() {
+    const DexFile* result = dex_file_;
+    if (result == NULL) {
+      const DexCache* dex_cache = GetDexCache();
+      result = &GetClassLinker()->FindDexFile(dex_cache);
+      dex_file_ = result;
+    }
+    return *result;
+  }
+ private:
+  // Set the method_ field, for proxy methods looking up the interface method via the resolved
+  // methods table.
+  void SetMethod(const Method* method) {
+    if (method != NULL) {
+      Class* klass = method->GetDeclaringClass();
+      if (klass->IsProxyClass()) {
+        method = method->GetDexCacheResolvedMethods()->Get(method->GetDexMethodIndex());
+        CHECK(method != NULL);
+      }
+    }
+    method_ = method;
+  }
+  DexCache* GetDexCache() {
+    DexCache* result = dex_cache_;
+    if (result == NULL) {
+      Class* klass = method_->GetDeclaringClass();
+      result = klass->GetDexCache();
+      dex_cache_ = result;
+    }
+    return result;
+  }
+  ClassLinker* GetClassLinker() {
+    ClassLinker* result = class_linker_;
+    if (result == NULL) {
+      result = Runtime::Current()->GetClassLinker();
+      class_linker_ = result;
+    }
+    return result;
+  }
+
+  ClassLinker* class_linker_;
+  DexCache* dex_cache_;
+  const DexFile* dex_file_;
+  const Method* method_;
+  const char* shorty_;
+  int32_t shorty_len_;
+
+  DISALLOW_COPY_AND_ASSIGN(MethodHelper);
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_OBJECT_UTILS_H_
diff --git a/src/primitive.h b/src/primitive.h
index 5d41966..402a2b5 100644
--- a/src/primitive.h
+++ b/src/primitive.h
@@ -101,11 +101,13 @@
       case kPrimInt:
         return 'I';
       case kPrimFloat:
-        return 'J';
+        return 'F';
       case kPrimLong:
         return 'J';
       case kPrimDouble:
         return 'D';
+      case kPrimVoid:
+        return 'V';
       default:
         LOG(FATAL) << "Primitive char conversion on invalid type " << static_cast<int>(type);
         return 0;
diff --git a/src/reflection.cc b/src/reflection.cc
index f02c2d2..a6ae096 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -19,6 +19,7 @@
 #include "class_linker.h"
 #include "jni_internal.h"
 #include "object.h"
+#include "object_utils.h"
 
 #include "JniConstants.h" // Last to avoid problems with LOG redefinition.
 
@@ -45,7 +46,7 @@
   gShort_valueOf = class_linker->FindSystemClass("Ljava/lang/Short;")->FindDeclaredDirectMethod("valueOf", "(S)Ljava/lang/Short;");
 }
 
-jobject InvokeMethod(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs, jobject javaParams) {
+jobject InvokeMethod(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
   Thread* self = Thread::Current();
   ScopedThreadStateChange tsc(self, Thread::kRunnable);
 
@@ -72,21 +73,23 @@
 
   // Get our arrays of arguments and their types, and check they're the same size.
   ObjectArray<Object>* objects = Decode<ObjectArray<Object>*>(env, javaArgs);
-  ObjectArray<Class>* classes = Decode<ObjectArray<Class>*>(env, javaParams);
-  int32_t arg_count = (objects != NULL) ? objects->GetLength() : 0;
-  if (arg_count != classes->GetLength()) {
+  MethodHelper mh(m);
+  const DexFile::TypeList* classes = mh.GetParameterTypeList();
+  uint32_t classes_size = classes == NULL ? 0 : classes->Size();
+  uint32_t arg_count = (objects != NULL) ? objects->GetLength() : 0;
+  if (arg_count != classes_size) {
     self->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
         "wrong number of arguments; expected %d, got %d",
-        classes->GetLength(), arg_count);
+        classes_size, arg_count);
     return NULL;
   }
 
   // Translate javaArgs to a jvalue[].
   UniquePtr<jvalue[]> args(new jvalue[arg_count]);
   JValue* decoded_args = reinterpret_cast<JValue*>(args.get());
-  for (int32_t i = 0; i < arg_count; ++i) {
+  for (uint32_t i = 0; i < arg_count; ++i) {
     Object* arg = objects->Get(i);
-    Class* dst_class = classes->Get(i);
+    Class* dst_class = mh.GetClassFromTypeIdx(classes->GetTypeItem(i).type_idx_);
     if (dst_class->IsPrimitive()) {
       if (!UnboxPrimitive(env, arg, dst_class, decoded_args[i])) {
         return NULL;
@@ -111,7 +114,7 @@
   }
 
   // Box if necessary and return.
-  BoxPrimitive(env, m->GetReturnType()->GetPrimitiveType(), value);
+  BoxPrimitive(env, mh.GetReturnType()->GetPrimitiveType(), value);
   return AddLocalReference<jobject>(env, value.l);
 }
 
@@ -121,7 +124,7 @@
     return false;
   }
   if (!o->InstanceOf(c)) {
-    std::string expectedClassName(PrettyDescriptor(c->GetDescriptor()));
+    std::string expectedClassName(PrettyDescriptor(c));
     std::string actualClassName(PrettyTypeOf(o));
     jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
         "expected receiver of type %s, but got %s",
@@ -283,7 +286,7 @@
     if (o != NULL && !o->InstanceOf(dst_class)) {
       jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
           "expected object of type %s, but got %s",
-          PrettyDescriptor(dst_class->GetDescriptor()).c_str(),
+          PrettyDescriptor(dst_class).c_str(),
           PrettyTypeOf(o).c_str());
       return false;
     }
@@ -302,37 +305,37 @@
   }
 
   JValue boxed_value = { 0 };
-  const String* src_descriptor = o->GetClass()->GetDescriptor();
+  std::string src_descriptor = ClassHelper(o->GetClass()).GetDescriptor();
   Class* src_class = NULL;
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Field* primitive_field = o->GetClass()->GetIFields()->Get(0);
-  if (src_descriptor->Equals("Ljava/lang/Boolean;")) {
+  if (src_descriptor == "Ljava/lang/Boolean;") {
     src_class = class_linker->FindPrimitiveClass('Z');
     boxed_value.i = primitive_field->GetBoolean(o);  // and extend read value to 32bits
-  } else if (src_descriptor->Equals("Ljava/lang/Byte;")) {
+  } else if (src_descriptor == "Ljava/lang/Byte;") {
     src_class = class_linker->FindPrimitiveClass('B');
     boxed_value.i = primitive_field->GetByte(o);  // and extend read value to 32bits
-  } else if (src_descriptor->Equals("Ljava/lang/Character;")) {
+  } else if (src_descriptor == "Ljava/lang/Character;") {
     src_class = class_linker->FindPrimitiveClass('C');
     boxed_value.i = primitive_field->GetChar(o);  // and extend read value to 32bits
-  } else if (src_descriptor->Equals("Ljava/lang/Float;")) {
+  } else if (src_descriptor == "Ljava/lang/Float;") {
     src_class = class_linker->FindPrimitiveClass('F');
     boxed_value.f = primitive_field->GetFloat(o);
-  } else if (src_descriptor->Equals("Ljava/lang/Double;")) {
+  } else if (src_descriptor == "Ljava/lang/Double;") {
     src_class = class_linker->FindPrimitiveClass('D');
     boxed_value.d = primitive_field->GetDouble(o);
-  } else if (src_descriptor->Equals("Ljava/lang/Integer;")) {
+  } else if (src_descriptor == "Ljava/lang/Integer;") {
     src_class = class_linker->FindPrimitiveClass('I');
     boxed_value.i = primitive_field->GetInt(o);
-  } else if (src_descriptor->Equals("Ljava/lang/Long;")) {
+  } else if (src_descriptor == "Ljava/lang/Long;") {
     src_class = class_linker->FindPrimitiveClass('J');
     boxed_value.j = primitive_field->GetLong(o);
-  } else if (src_descriptor->Equals("Ljava/lang/Short;")) {
+  } else if (src_descriptor == "Ljava/lang/Short;") {
     src_class = class_linker->FindPrimitiveClass('S');
     boxed_value.i = primitive_field->GetShort(o);  // and extend read value to 32bits
   } else {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
-        "%s is not a boxed primitive type", PrettyDescriptor(src_descriptor).c_str());
+        "%s is not a boxed primitive type", PrettyDescriptor(src_descriptor.c_str()).c_str());
     return false;
   }
 
diff --git a/src/reflection.h b/src/reflection.h
index df19deb..e832c3d 100644
--- a/src/reflection.h
+++ b/src/reflection.h
@@ -32,7 +32,7 @@
 
 bool ConvertPrimitiveValue(Primitive::Type src_class, Primitive::Type dst_class, const JValue& src, JValue& dst);
 
-jobject InvokeMethod(JNIEnv* env, jobject method, jobject receiver, jobject args, jobject params);
+jobject InvokeMethod(JNIEnv* env, jobject method, jobject receiver, jobject args);
 
 bool VerifyObjectInClass(JNIEnv* env, Object* o, Class* c);
 
diff --git a/src/runtime.cc b/src/runtime.cc
index 9e6ebb1..6491138 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -800,19 +800,8 @@
   Class* method_class = Method::GetMethodClass();
   SirtRef<Method> method(down_cast<Method*>(method_class->AllocObject()));
   method->SetDeclaringClass(method_class);
-  const char* name;
-  if (type == kSaveAll) {
-    name = "$$$callee_save_method$$$";
-  } else if (type == kRefsOnly) {
-    name = "$$$refs_only_callee_save_method$$$";
-  } else {
-    DCHECK(type == kRefsAndArgs);
-    name = "$$$refs_and_args_callee_save_method$$$";
-  }
-  method->SetName(intern_table_->InternStrong(name));
-  CHECK(method->GetName() != NULL);
-  method->SetSignature(intern_table_->InternStrong("()V"));
-  CHECK(method->GetSignature() != NULL);
+  // TODO: use a special method for callee saves
+  method->SetMethodIndex(DexFile::kDexNoIndex16);
   method->SetCode(NULL);
   if ((instruction_set == kThumb2) || (instruction_set == kArm)) {
     uint32_t ref_spills = (1 << art::arm::R5) | (1 << art::arm::R6)  | (1 << art::arm::R7) |
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index e6011da..1d05527 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -19,6 +19,8 @@
 #include "dex_cache.h"
 #include "dex_verifier.h"
 #include "macros.h"
+#include "object.h"
+#include "object_utils.h"
 #include "reflection.h"
 #include "ScopedLocalRef.h"
 
@@ -172,7 +174,7 @@
   result += "tried to access class ";
   result += class_name;
   result += " from class ";
-  result += PrettyDescriptor(method->GetDeclaringClass()->GetDescriptor());
+  result += PrettyDescriptor(method->GetDeclaringClass());
   return result;
 }
 
@@ -194,7 +196,7 @@
   result += "tried to access field ";
   result += class_name + "." + field_name;
   result += " from class ";
-  result += PrettyDescriptor(method->GetDeclaringClass()->GetDescriptor());
+  result += PrettyDescriptor(method->GetDeclaringClass());
   return result;
 }
 
@@ -217,7 +219,7 @@
   result += class_name + "." + method_name + ":" +
       dex_file.CreateMethodSignature(id.proto_idx_, NULL);
   result += " from class ";
-  result += PrettyDescriptor(method->GetDeclaringClass()->GetDescriptor());
+  result += PrettyDescriptor(method->GetDeclaringClass());
   return result;
 }
 
@@ -352,9 +354,7 @@
     Method* caller = *caller_sp;
     // less two as return address may span into next dex instruction
     uint32_t dex_pc = caller->ToDexPC(caller_pc - 2);
-    const DexFile& dex_file = Runtime::Current()->GetClassLinker()
-                                  ->FindDexFile(caller->GetDeclaringClass()->GetDexCache());
-    const DexFile::CodeItem* code = dex_file.GetCodeItem(caller->GetCodeItemOffset());
+    const DexFile::CodeItem* code = MethodHelper(caller).GetCodeItem();
     CHECK_LT(dex_pc, code->insns_size_in_code_units_);
     const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
     Instruction::Code instr_code = instr->Opcode();
@@ -473,14 +473,16 @@
                                            Thread* self, Method** sp) {
   Field* field = FindFieldFast(field_idx, referrer);
   if (LIKELY(field != NULL)) {
-    if (LIKELY(field->IsPrimitiveType() && field->PrimitiveSize() == sizeof(int32_t))) {
+    FieldHelper fh(field);
+    if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int32_t))) {
       return field->Get32(NULL);
     }
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   field = FindFieldFromCode(field_idx, referrer, true);
   if (field != NULL) {
-    if (!field->IsPrimitiveType() || field->PrimitiveSize() != sizeof(int32_t)) {
+    FieldHelper fh(field);
+    if (!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int32_t)) {
       self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
                                "Attempted read of 32-bit primitive on field '%s'",
                                PrettyField(field, true).c_str());
@@ -495,14 +497,16 @@
                                            Thread* self, Method** sp) {
   Field* field = FindFieldFast(field_idx, referrer);
   if (LIKELY(field != NULL)) {
-    if (LIKELY(field->IsPrimitiveType() && field->PrimitiveSize() == sizeof(int64_t))) {
+    FieldHelper fh(field);
+    if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int64_t))) {
       return field->Get64(NULL);
     }
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   field = FindFieldFromCode(field_idx, referrer, true);
   if (field != NULL) {
-    if (!field->IsPrimitiveType() || field->PrimitiveSize() != sizeof(int64_t)) {
+    FieldHelper fh(field);
+    if (!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int64_t)) {
       self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
                                "Attempted read of 64-bit primitive on field '%s'",
                                PrettyField(field, true).c_str());
@@ -517,14 +521,16 @@
                                            Thread* self, Method** sp) {
   Field* field = FindFieldFast(field_idx, referrer);
   if (LIKELY(field != NULL)) {
-    if (LIKELY(!field->IsPrimitiveType())) {
+    FieldHelper fh(field);
+    if (LIKELY(!fh.IsPrimitiveType())) {
       return field->GetObj(NULL);
     }
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   field = FindFieldFromCode(field_idx, referrer, true);
   if (field != NULL) {
-    if (field->IsPrimitiveType()) {
+    FieldHelper fh(field);
+    if (fh.IsPrimitiveType()) {
       self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
                                "Attempted read of reference on primitive field '%s'",
                                PrettyField(field, true).c_str());
@@ -539,7 +545,8 @@
                                        uint32_t new_value, Thread* self, Method** sp) {
   Field* field = FindFieldFast(field_idx, referrer);
   if (LIKELY(field != NULL)) {
-    if (LIKELY(field->IsPrimitiveType() && field->PrimitiveSize() == sizeof(int32_t))) {
+    FieldHelper fh(field);
+    if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int32_t))) {
       field->Set32(NULL, new_value);
       return 0;  // success
     }
@@ -547,7 +554,8 @@
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   field = FindFieldFromCode(field_idx, referrer, true);
   if (field != NULL) {
-    if (!field->IsPrimitiveType() || field->PrimitiveSize() != sizeof(int32_t)) {
+    FieldHelper fh(field);
+    if (!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int32_t)) {
       self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
                                "Attempted write of 32-bit primitive to field '%s'",
                                PrettyField(field, true).c_str());
@@ -563,7 +571,8 @@
                                       uint64_t new_value, Thread* self, Method** sp) {
   Field* field = FindFieldFast(field_idx, referrer);
   if (LIKELY(field != NULL)) {
-    if (LIKELY(field->IsPrimitiveType() && field->PrimitiveSize() == sizeof(int64_t))) {
+    FieldHelper fh(field);
+    if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int64_t))) {
       field->Set64(NULL, new_value);
       return 0;  // success
     }
@@ -571,7 +580,8 @@
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   field = FindFieldFromCode(field_idx, referrer, true);
   if (LIKELY(field != NULL)) {
-    if (UNLIKELY(!field->IsPrimitiveType() || field->PrimitiveSize() != sizeof(int64_t))) {
+    FieldHelper fh(field);
+    if (UNLIKELY(!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int64_t))) {
       self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
                                "Attempted write of 64-bit primitive to field '%s'",
                                PrettyField(field, true).c_str());
@@ -587,7 +597,7 @@
                                        Object* new_value, Thread* self, Method** sp) {
   Field* field = FindFieldFast(field_idx, referrer);
   if (LIKELY(field != NULL)) {
-    if (LIKELY(!field->IsPrimitiveType())) {
+    if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
       field->SetObj(NULL, new_value);
       return 0;  // success
     }
@@ -595,7 +605,7 @@
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   field = FindFieldFromCode(field_idx, referrer, true);
   if (field != NULL) {
-    if (field->IsPrimitiveType()) {
+    if (FieldHelper(field).IsPrimitiveType()) {
       self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
                                "Attempted write of reference to primitive field '%s'",
                                PrettyField(field, true).c_str());
@@ -643,8 +653,8 @@
   Class* referrer = method->GetDeclaringClass();
   if (UNLIKELY(!referrer->CanAccess(klass))) {
     self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;", "illegal class access: '%s' -> '%s'",
-                             PrettyDescriptor(referrer->GetDescriptor()).c_str(),
-                             PrettyDescriptor(klass->GetDescriptor()).c_str());
+                             PrettyDescriptor(referrer).c_str(),
+                             PrettyDescriptor(klass).c_str());
     return NULL;  // Failure
   }
   if (!runtime->GetClassLinker()->EnsureInitialized(klass, true)) {
@@ -672,11 +682,11 @@
     if (klass->IsPrimitiveLong() || klass->IsPrimitiveDouble()) {
       Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
           "Bad filled array request for type %s",
-          PrettyDescriptor(klass->GetDescriptor()).c_str());
+          PrettyDescriptor(klass).c_str());
     } else {
       Thread::Current()->ThrowNewExceptionF("Ljava/lang/InternalError;",
           "Found type %s; filled-new-array not implemented for anything but \'int\'",
-          PrettyDescriptor(klass->GetDescriptor()).c_str());
+          PrettyDescriptor(klass).c_str());
     }
     return NULL;  // Failure
   } else {
@@ -731,8 +741,8 @@
     FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
         "%s cannot be cast to %s",
-        PrettyDescriptor(a->GetDescriptor()).c_str(),
-        PrettyDescriptor(b->GetDescriptor()).c_str());
+        PrettyDescriptor(a).c_str(),
+        PrettyDescriptor(b).c_str());
     return -1;  // Failure
   }
 }
@@ -751,8 +761,8 @@
     FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
         "Cannot store an object of type %s in to an array of type %s",
-        PrettyDescriptor(element_class->GetDescriptor()).c_str(),
-        PrettyDescriptor(array_class->GetDescriptor()).c_str());
+        PrettyDescriptor(element_class).c_str(),
+        PrettyDescriptor(array_class).c_str());
     return -1;  // Failure
   }
 }
@@ -769,7 +779,7 @@
   //
   // Do not set the DexCache InitializedStaticStorage, since that implies <clinit> has finished
   // running.
-  if (klass == referrer->GetDeclaringClass() && referrer->IsClassInitializer()) {
+  if (klass == referrer->GetDeclaringClass() && MethodHelper(referrer).IsClassInitializer()) {
     return klass;
   }
   if (!class_linker->EnsureInitialized(klass, true)) {
@@ -792,14 +802,14 @@
   if (UNLIKELY(!referrer->GetDeclaringClass()->CanAccess(klass))) {
     self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
         "Class %s is inaccessible to method %s",
-        PrettyDescriptor(klass->GetDescriptor()).c_str(),
+        PrettyDescriptor(klass).c_str(),
         PrettyMethod(referrer, true).c_str());
   }
   // If we are the <clinit> of this class, just return our storage.
   //
   // Do not set the DexCache InitializedStaticStorage, since that implies <clinit> has finished
   // running.
-  if (klass == referrer->GetDeclaringClass() && referrer->IsClassInitializer()) {
+  if (klass == referrer->GetDeclaringClass() && MethodHelper(referrer).IsClassInitializer()) {
     return klass;
   }
   if (!class_linker->EnsureInitialized(klass, true)) {
@@ -1000,10 +1010,11 @@
 
   // Placing into local references incoming arguments from the caller's register arguments,
   // replacing original Object* with jobject
-  const size_t num_params = proxy_method->NumArgs();
+  MethodHelper proxy_mh(proxy_method);
+  const size_t num_params = proxy_mh.NumArgs();
   size_t args_in_regs = 0;
   for (size_t i = 1; i < num_params; i++) {  // skip receiver
-    args_in_regs = args_in_regs + (proxy_method->IsParamALongOrDouble(i) ? 2 : 1);
+    args_in_regs = args_in_regs + (proxy_mh.IsParamALongOrDouble(i) ? 2 : 1);
     if (args_in_regs > 2) {
       args_in_regs = 2;
       break;
@@ -1012,23 +1023,23 @@
   size_t cur_arg = 0;  // current stack location to read
   size_t param_index = 1;  // skip receiver
   while (cur_arg < args_in_regs && param_index < num_params) {
-    if (proxy_method->IsParamAReference(param_index)) {
+    if (proxy_mh.IsParamAReference(param_index)) {
       Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
       jobject jobj = AddLocalReference<jobject>(env, obj);
       *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
     }
-    cur_arg = cur_arg + (proxy_method->IsParamALongOrDouble(param_index) ? 2 : 1);
+    cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
     param_index++;
   }
   // Placing into local references incoming arguments from the caller's stack arguments
   cur_arg += 11;  // skip callee saves, LR, Method* and out arg spills for R1 to R3
   while (param_index < num_params) {
-    if (proxy_method->IsParamAReference(param_index)) {
+    if (proxy_mh.IsParamAReference(param_index)) {
       Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
       jobject jobj = AddLocalReference<jobject>(env, obj);
       *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
     }
-    cur_arg = cur_arg + (proxy_method->IsParamALongOrDouble(param_index) ? 2 : 1);
+    cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
     param_index++;
   }
   // Set up arguments array and place in local IRT during boxing (which may allocate/GC)
@@ -1049,13 +1060,14 @@
   // Convert proxy method into expected interface method
   Method* interface_method = proxy_method->FindOverriddenMethod();
   CHECK(interface_method != NULL);
+  CHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
   args_jobj[1].l = AddLocalReference<jobject>(env, interface_method);
   LOG(INFO) << "Interface method is " << PrettyMethod(interface_method, true);
   // Box arguments
   cur_arg = 0;  // reset stack location to read to start
   // reset index, will index into param type array which doesn't include the receiver
   param_index = 0;
-  ObjectArray<Class>* param_types = interface_method->GetJavaParameterTypes();
+  ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes();
   CHECK(param_types != NULL);
   // Check number of parameter types agrees with number from the Method - less 1 for the receiver.
   CHECK_EQ(static_cast<size_t>(param_types->GetLength()), num_params - 1);
@@ -1119,7 +1131,7 @@
     Object* result_ref = self->DecodeJObject(result);
     if (result_ref != NULL) {
       JValue result_unboxed;
-      UnboxPrimitive(env, result_ref, interface_method->GetReturnType(), result_unboxed);
+      UnboxPrimitive(env, result_ref, proxy_mh.GetReturnType(), result_unboxed);
       *reinterpret_cast<JValue*>(stack_args) = result_unboxed;
     } else {
       *reinterpret_cast<jobject*>(stack_args) = NULL;
@@ -1132,7 +1144,10 @@
     if (!exception->IsCheckedException()) {
       self->SetException(exception);
     } else {
-      ObjectArray<Class>* declared_exceptions = proxy_method->GetExceptionTypes();
+      // TODO: get the correct intersection of exceptions as passed to the class linker's create
+      // proxy code.
+      UNIMPLEMENTED(FATAL);
+      ObjectArray<Class>* declared_exceptions = NULL; // proxy_mh.GetExceptionTypes();
       Class* exception_class = exception->GetClass();
       bool declares_exception = false;
       for (int i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
diff --git a/src/stack.cc b/src/stack.cc
index 542ac47..9944ec3 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -18,9 +18,12 @@
 
 #include "compiler.h"
 #include "object.h"
+#include "object_utils.h"
 #include "thread_list.h"
 
-int oatVRegOffsetFromMethod(art::Method* method, int reg);
+int oatVRegOffset(const art::DexFile::CodeItem* code_item,
+                  uint32_t core_spills, uint32_t fp_spills,
+                  size_t frame_size, int reg);
 
 namespace art {
 
@@ -45,16 +48,31 @@
   return *reinterpret_cast<uintptr_t*>(pc_addr);
 }
 
-uint32_t Frame::GetVReg(Method* method, int vreg) const {
-  DCHECK(method == GetMethod());
-  int offset = oatVRegOffsetFromMethod(method, vreg);
+uint32_t Frame::GetVReg(const DexFile::CodeItem* code_item, uint32_t core_spills,
+                        uint32_t fp_spills, size_t frame_size, int vreg) const {
+  int offset = oatVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
   byte* vreg_addr = reinterpret_cast<byte*>(sp_) + offset;
   return *reinterpret_cast<uint32_t*>(vreg_addr);
 }
 
-void Frame::SetVReg(Method* method, int vreg, uint32_t new_value) {
-  DCHECK(method == GetMethod());
-  int offset = oatVRegOffsetFromMethod(method, vreg);
+uint32_t Frame::GetVReg(Method* m, int vreg) const {
+  DCHECK(m == GetMethod());
+  const art::DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
+  DCHECK(code_item != NULL);  // can't be NULL or how would we compile its instructions?
+  uint32_t core_spills = m->GetCoreSpillMask();
+  uint32_t fp_spills = m->GetFpSpillMask();
+  size_t frame_size = m->GetFrameSizeInBytes();
+  return GetVReg(code_item, core_spills, fp_spills, frame_size, vreg);
+}
+
+void Frame::SetVReg(Method* m, int vreg, uint32_t new_value) {
+  DCHECK(m == GetMethod());
+  const art::DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
+  DCHECK(code_item != NULL);  // can't be NULL or how would we compile its instructions?
+  uint32_t core_spills = m->GetCoreSpillMask();
+  uint32_t fp_spills = m->GetFpSpillMask();
+  size_t frame_size = m->GetFrameSizeInBytes();
+  int offset = oatVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
   byte* vreg_addr = reinterpret_cast<byte*>(sp_) + offset;
   *reinterpret_cast<uint32_t*>(vreg_addr) = new_value;
 }
diff --git a/src/stack.h b/src/stack.h
index a0f13d3..eee1d56 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -17,6 +17,7 @@
 #ifndef ART_SRC_STACK_H_
 #define ART_SRC_STACK_H_
 
+#include "dex_file.h"
 #include "jni.h"
 #include "macros.h"
 
@@ -54,7 +55,11 @@
 
   uintptr_t LoadCalleeSave(int num) const;
 
-  uint32_t GetVReg(Method* method, int vreg) const;
+
+  uint32_t GetVReg(const DexFile::CodeItem* code_item, uint32_t core_spills, uint32_t fp_spills,
+                    size_t frame_size, int vreg) const;
+
+  uintptr_t GetVReg(Method* m, int vreg) const;
   void SetVReg(Method* method, int vreg, uint32_t new_value);
 
   Method** GetSP() const {
diff --git a/src/thread.cc b/src/thread.cc
index b6962f9..092c071 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -35,6 +35,7 @@
 #include "jni_internal.h"
 #include "monitor.h"
 #include "object.h"
+#include "object_utils.h"
 #include "reflection.h"
 #include "runtime.h"
 #include "runtime_support.h"
@@ -534,8 +535,9 @@
       if (m->IsNative()) {
         os << "(Native method)";
       } else {
-        SirtRef<String> source_file(c->GetSourceFile());
-        os << "(" << (source_file.get() != NULL ? source_file->ToModifiedUtf8() : "unavailable")
+        mh.ChangeMethod(m);
+        const char* source_file(mh.GetDeclaringClassSourceFile());
+        os << "(" << (source_file != NULL ? source_file : "unavailable")
            << ":" << line_number << ")";
       }
       os << "\n";
@@ -545,6 +547,7 @@
       Monitor::DescribeWait(os, thread);
     }
   }
+  MethodHelper mh;
   Method* last_method;
   int last_line_number;
   int repetition_count;
@@ -1172,27 +1175,32 @@
     *stack_depth = depth;
   }
 
+  MethodHelper mh;
   for (int32_t i = 0; i < depth; ++i) {
     // Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
     Method* method = down_cast<Method*>(method_trace->Get(i));
+    mh.ChangeMethod(method);
     uint32_t native_pc = pc_trace->Get(i);
-    Class* klass = method->GetDeclaringClass();
-    std::string class_name(PrettyDescriptor(klass->GetDescriptor()));
-    int32_t line_number = -1;
-    DexCache* dex_cache = klass->GetDexCache();
-    if (dex_cache != NULL) {
-      const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
-      line_number = dex_file.GetLineNumFromPC(method, method->ToDexPC(native_pc));
-    }
+    int32_t line_number = mh.GetLineNumFromNativePC(native_pc);
     // Allocate element, potentially triggering GC
     // TODO: reuse class_name_object via Class::name_?
+    std::string class_name(PrettyDescriptor(mh.GetDeclaringClassDescriptor()));
     SirtRef<String> class_name_object(String::AllocFromModifiedUtf8(class_name.c_str()));
     if (class_name_object.get() == NULL) {
       return NULL;
     }
+    SirtRef<String> method_name_object(String::AllocFromModifiedUtf8(mh.GetName()));
+    if (method_name_object.get() == NULL) {
+      return NULL;
+    }
+    SirtRef<String>
+        source_name_object(String::AllocFromModifiedUtf8(mh.GetDeclaringClassSourceFile()));
+    if (source_name_object.get() == NULL) {
+      return NULL;
+    }
     StackTraceElement* obj = StackTraceElement::Alloc(class_name_object.get(),
-                                                      method->GetName(),
-                                                      klass->GetSourceFile(),
+                                                      method_name_object.get(),
+                                                      source_name_object.get(),
                                                       line_number);
     if (obj == NULL) {
       return NULL;
@@ -1247,7 +1255,7 @@
 
 void Thread::ThrowOutOfMemoryError(Class* c, size_t byte_count) {
   std::string msg(StringPrintf("Failed to allocate a %zd-byte %s", byte_count,
-      PrettyDescriptor(c->GetDescriptor()).c_str()));
+      PrettyDescriptor(c).c_str()));
   ThrowOutOfMemoryError(msg.c_str());
 }
 
@@ -1432,8 +1440,14 @@
       const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
       CHECK(reg_bitmap != NULL);
       const VmapTable vmap_table(m->GetVmapTableRaw());
+      const art::DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
+      DCHECK(code_item != NULL);  // can't be NULL or how would we compile its instructions?
+      uint32_t core_spills = m->GetCoreSpillMask();
+      uint32_t fp_spills = m->GetFpSpillMask();
+      size_t frame_size = m->GetFrameSizeInBytes();
       // For all dex registers in the bitmap
-      size_t num_regs = std::min(map.RegWidth() * 8, static_cast<size_t>(m->NumRegisters()));
+      size_t num_regs = std::min(map.RegWidth() * 8,
+                                 static_cast<size_t>(code_item->registers_size_));
       for (size_t reg = 0; reg < num_regs; ++reg) {
         // Does this register hold a reference?
         if (TestBitmap(reg, reg_bitmap)) {
@@ -1454,7 +1468,8 @@
             spill_shifts--;  // wind back one as we want the last match
             ref = reinterpret_cast<Object*>(context_->GetGPR(spill_shifts));
           } else {
-            ref = reinterpret_cast<Object*>(frame.GetVReg(m, reg));
+            ref = reinterpret_cast<Object*>(frame.GetVReg(code_item, core_spills, fp_spills,
+                                                          frame_size, reg));
           }
           if (ref != NULL) {
             root_visitor_(ref, arg_);
diff --git a/src/utils.cc b/src/utils.cc
index 63787a8..943899d 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -13,6 +13,7 @@
 #include "class_loader.h"
 #include "file.h"
 #include "object.h"
+#include "object_utils.h"
 #include "os.h"
 
 #if defined(HAVE_PRCTL)
@@ -68,6 +69,14 @@
   return PrettyDescriptor(java_descriptor->ToModifiedUtf8());
 }
 
+std::string PrettyDescriptor(const Class* klass) {
+  if (klass == NULL) {
+    return "null";
+  }
+  return PrettyDescriptor(ClassHelper(klass).GetDescriptor());
+
+}
+
 std::string PrettyDescriptor(const std::string& descriptor) {
   // Count the number of '['s to get the dimensionality.
   const char* c = descriptor.c_str();
@@ -126,14 +135,15 @@
   if (f == NULL) {
     return "null";
   }
+  FieldHelper fh(f);
   std::string result;
   if (with_type) {
-    result += PrettyDescriptor(f->GetTypeDescriptor());
+    result += PrettyDescriptor(fh.GetTypeDescriptor());
     result += ' ';
   }
-  result += PrettyDescriptor(f->GetDeclaringClass()->GetDescriptor());
+  result += PrettyDescriptor(fh.GetDeclaringClassDescriptor());
   result += '.';
-  result += f->GetName()->ToModifiedUtf8();
+  result += fh.GetName();
   return result;
 }
 
@@ -141,14 +151,14 @@
   if (m == NULL) {
     return "null";
   }
-  Class* c = m->GetDeclaringClass();
-  std::string result(PrettyDescriptor(c->GetDescriptor()));
+  MethodHelper mh(m);
+  std::string result(PrettyDescriptor(mh.GetDeclaringClassDescriptor()));
   result += '.';
-  result += m->GetName()->ToModifiedUtf8();
+  result += mh.GetName();
   if (with_signature) {
     // TODO: iterate over the signature's elements and pass them all to
     // PrettyDescriptor? We'd need to pull out the return type specially, too.
-    result += m->GetSignature()->ToModifiedUtf8();
+    result += mh.GetSignature();
   }
   return result;
 }
@@ -173,9 +183,11 @@
   if (obj->GetClass() == NULL) {
     return "(raw)";
   }
-  std::string result(PrettyDescriptor(obj->GetClass()->GetDescriptor()));
+  ClassHelper kh(obj->GetClass());
+  std::string result(PrettyDescriptor(kh.GetDescriptor()));
   if (obj->IsClass()) {
-    result += "<" + PrettyDescriptor(obj->AsClass()->GetDescriptor()) + ">";
+    kh.ChangeClass(obj->AsClass());
+    result += "<" + PrettyDescriptor(kh.GetDescriptor()) + ">";
   }
   return result;
 }
@@ -186,7 +198,7 @@
   }
   std::string result;
   result += "java.lang.Class<";
-  result += PrettyDescriptor(c->GetDescriptor());
+  result += PrettyDescriptor(c);
   result += ">";
   return result;
 }
@@ -197,7 +209,7 @@
   }
   std::string result;
   result += "java.lang.Class<";
-  result += PrettyDescriptor(c->GetDescriptor());
+  result += PrettyDescriptor(c);
   result += ",";
   result += PrettyTypeOf(c->GetClassLoader());
   // TODO: add an identifying hash value for the loader
@@ -254,16 +266,15 @@
 }
 
 std::string JniShortName(const Method* m) {
-  Class* declaring_class = m->GetDeclaringClass();
-
-  std::string class_name(declaring_class->GetDescriptor()->ToModifiedUtf8());
+  MethodHelper mh(m);
+  std::string class_name(mh.GetDeclaringClassDescriptor());
   // Remove the leading 'L' and trailing ';'...
   CHECK_EQ(class_name[0], 'L') << class_name;
   CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name;
   class_name.erase(0, 1);
   class_name.erase(class_name.size() - 1, 1);
 
-  std::string method_name(m->GetName()->ToModifiedUtf8());
+  std::string method_name(mh.GetName());
 
   std::string short_name;
   short_name += "Java_";
@@ -278,7 +289,7 @@
   long_name += JniShortName(m);
   long_name += "__";
 
-  std::string signature(m->GetSignature()->ToModifiedUtf8());
+  std::string signature(MethodHelper(m).GetSignature());
   signature.erase(0, 1);
   signature.erase(signature.begin() + signature.find(')'), signature.end());
 
diff --git a/src/utils.h b/src/utils.h
index f5e0c49..5b3a036 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -159,6 +159,7 @@
 std::string PrettyDescriptor(const String* descriptor);
 std::string PrettyDescriptor(const std::string& descriptor);
 std::string PrettyDescriptor(Primitive::Type type);
+std::string PrettyDescriptor(const Class* klass);
 
 // Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
 // "int a.b.C.f" (depending on the value of 'with_type').
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 77fe2ee..547f8c9 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -6,13 +6,14 @@
 #include "class_linker.h"
 #include "dex_verifier.h"
 #include "object.h"
+#include "object_utils.h"
 #include "thread.h"
 #include "jni.h"
 
 namespace art {
 
-#define IS_IN_REF_BITMAP(method, ref_bitmap, reg) \
-  ( ((reg) < (method)->NumRegisters()) &&                       \
+#define IS_IN_REF_BITMAP(mh, ref_bitmap, reg) \
+  ( ((reg) < mh.GetCodeItem()->registers_size_) &&                       \
     (( *((ref_bitmap) + (reg)/8) >> ((reg) % 8) ) & 0x01) )
 
 #define CHECK_REGS_CONTAIN_REFS(...)     \
@@ -20,7 +21,7 @@
     int t[] = {__VA_ARGS__};             \
     int t_size = sizeof(t) / sizeof(*t);      \
     for (int i = 0; i < t_size; ++i)          \
-      CHECK(IS_IN_REF_BITMAP(m, ref_bitmap, t[i])) \
+      CHECK(IS_IN_REF_BITMAP(mh, ref_bitmap, t[i])) \
           << "Error: Reg @ " << i << "-th argument is not in GC map"; \
   } while(false)
 
@@ -52,7 +53,8 @@
       art::verifier::DexVerifier::VerifyMethodAndDump(m);
     }
     const uint8_t* ref_bitmap = NULL;
-    std::string m_name = m->GetName()->ToModifiedUtf8();
+    MethodHelper mh(m);
+    std::string m_name(mh.GetName());
 
     // Given the method name and the number of times the method has been called,
     // we know the Dex registers with live reference values. Assert that what we
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index ad9c674..06b3d41 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -6,19 +6,20 @@
 #include "class_linker.h"
 #include "dex_verifier.h"
 #include "object.h"
+#include "object_utils.h"
 #include "jni.h"
 
 namespace art {
 
-#define REG(method, reg_bitmap, reg) \
-  ( ((reg) < (method)->NumRegisters()) &&                       \
+#define REG(mh, reg_bitmap, reg) \
+  ( ((reg) < mh.GetCodeItem()->registers_size_) &&                       \
     (( *((reg_bitmap) + (reg)/8) >> ((reg) % 8) ) & 0x01) )
 
 #define CHECK_REGS(...) do {          \
     int t[] = {__VA_ARGS__};             \
     int t_size = sizeof(t) / sizeof(*t);      \
     for (int i = 0; i < t_size; ++i)          \
-      CHECK(REG(m, reg_bitmap, t[i])) << "Error: Reg " << i << " is not in RegisterMap";  \
+      CHECK(REG(mh, reg_bitmap, t[i])) << "Error: Reg " << i << " is not in RegisterMap";  \
   } while(false)
 
 static int gJava_StackWalk_refmap_calls = 0;
@@ -39,12 +40,13 @@
     }
     verifier::PcToReferenceMap map(m);
     const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
-    String* m_name = m->GetName();
+    MethodHelper mh(m);
+    StringPiece m_name(mh.GetName());
 
     // Given the method name and the number of times the method has been called,
     // we know the Dex registers with live reference values. Assert that what we
     // find is what is expected.
-    if (m_name->Equals("f")) {
+    if (m_name == "f") {
       if (gJava_StackWalk_refmap_calls == 1) {
         CHECK_EQ(1U, m->ToDexPC(pc));
         CHECK_REGS(1);
@@ -53,7 +55,7 @@
         CHECK_EQ(5U, m->ToDexPC(pc));
         CHECK_REGS(1);
       }
-    } else if (m_name->Equals("g")) {
+    } else if (m_name == "g") {
       if (gJava_StackWalk_refmap_calls == 1) {
         CHECK_EQ(0xcU, m->ToDexPC(pc));
         CHECK_REGS(0, 2);  // Note that v1 is not in the minimal root set
@@ -62,7 +64,7 @@
         CHECK_EQ(0xcU, m->ToDexPC(pc));
         CHECK_REGS(0, 2);
       }
-    } else if (m_name->Equals("shlemiel")) {
+    } else if (m_name == "shlemiel") {
       if (gJava_StackWalk_refmap_calls == 1) {
         CHECK_EQ(0x380U, m->ToDexPC(pc));
         CHECK_REGS(2, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 25);