diff --git a/src/class_linker.cc b/src/class_linker.cc
index 15c2e40..19f2f93 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -27,12 +27,23 @@
 }
 
 void ClassLinker::Init() {
-  // Allocate and partially initialize the Object and Class classes.
+  // Allocate and partially initialize the Class, Object, Field, Method classes.
   // Initialization will be completed when the definitions are loaded.
-  java_lang_Object_ = Heap::AllocClass(NULL);
-  java_lang_Object_->descriptor_ = "Ljava/lang/Object;";
-  java_lang_Class_ = Heap::AllocClass(NULL);
+  java_lang_Class_ = reinterpret_cast<Class*>(Heap::AllocRaw(sizeof(Class), NULL));
   java_lang_Class_->descriptor_ = "Ljava/lang/Class;";
+  java_lang_Class_->object_size_ = sizeof(Class);
+  java_lang_Class_->klass_ = java_lang_Class_;
+
+  java_lang_Object_ = AllocClass(NULL);
+  java_lang_Object_->descriptor_ = "Ljava/lang/Object;";
+
+  java_lang_Class_->super_class_ = java_lang_Object_;
+
+  java_lang_ref_Field_ = AllocClass(NULL);
+  java_lang_ref_Field_->descriptor_ = "Ljava/lang/ref/Field;";
+
+  java_lang_ref_Method_ = AllocClass(NULL);
+  java_lang_ref_Method_->descriptor_ = "Ljava/lang/Method;";
 
   // Allocate and initialize the primitive type classes.
   primitive_byte_ = CreatePrimitiveClass(kTypeByte, "B");
@@ -44,6 +55,32 @@
   primitive_short_ = CreatePrimitiveClass(kTypeShort, "S");
   primitive_boolean_ = CreatePrimitiveClass(kTypeBoolean, "Z");
   primitive_void_ = CreatePrimitiveClass(kTypeVoid, "V");
+
+  char_array_class_ = AllocClass(NULL);
+  char_array_class_->descriptor_ = "[C";
+  char_array_class_->status_ = Class::kStatusInitialized;
+  char_array_class_->component_type_ = primitive_char_;
+  char_array_class_->array_rank_ = 1;
+  char_array_class_->primitive_type_ = Class::kPrimNot;
+  char_array_class_->super_class_ = java_lang_Object_;
+}
+
+Class* ClassLinker::AllocClass(DexFile* dex_file) {
+  Class* klass = reinterpret_cast<Class*>(Heap::AllocObject(java_lang_Class_));
+  klass->dex_file_ = dex_file;
+  return klass;
+}
+
+StaticField* ClassLinker::AllocStaticField() {
+  return reinterpret_cast<StaticField*>(Heap::AllocRaw(sizeof(StaticField), java_lang_ref_Field_));
+}
+
+InstanceField* ClassLinker::AllocInstanceField() {
+  return reinterpret_cast<InstanceField*>(Heap::AllocRaw(sizeof(InstanceField), java_lang_ref_Field_));
+}
+
+Method* ClassLinker::AllocMethod() {
+  return reinterpret_cast<Method*>(Heap::AllocRaw(sizeof(Method), java_lang_ref_Method_));
 }
 
 Class* ClassLinker::FindClass(const char* descriptor,
@@ -55,25 +92,52 @@
   Class* klass = LookupClass(descriptor, class_loader);
   if (klass == NULL) {
     // Class is not yet loaded.
+    const RawDexFile::ClassDef* class_def;
     if (dex_file == NULL) {
       // No .dex file specified, search the class path.
-      dex_file = FindInClassPath(descriptor);
-      if (dex_file == NULL) {
+      ClassPathEntry pair = FindInClassPath(descriptor);
+      if (pair.first == NULL) {
         LG << "Class " << descriptor << " really not found";
         return NULL;
       }
+      dex_file = pair.first;
+      class_def = pair.second;
+    } else {
+      class_def = dex_file->GetRaw()->FindClassDef(descriptor);
     }
     // Load the class from the dex file.
     if (!strcmp(descriptor, "Ljava/lang/Object;")) {
       klass = java_lang_Object_;
       klass->dex_file_ = dex_file;
+      klass->object_size_ = sizeof(Object);
+      if (class_def != NULL) {
+        char_array_class_->super_class_idx_ = class_def->class_idx_;
+      }
     } else if (!strcmp(descriptor, "Ljava/lang/Class;")) {
       klass = java_lang_Class_;
       klass->dex_file_ = dex_file;
+      klass->object_size_ = sizeof(Class);
+    } else if (!strcmp(descriptor, "Ljava/lang/ref/Field;")) {
+      klass = java_lang_ref_Field_;
+      klass->dex_file_ = dex_file;
+      klass->object_size_ = sizeof(Field);
+    } else if (!strcmp(descriptor, "Ljava/lang/ref/Method;")) {
+      klass = java_lang_ref_Method_;
+      klass->dex_file_ = dex_file;
+      klass->object_size_ = sizeof(Method);
+    } else if (!strcmp(descriptor, "Ljava/lang/String;")) {
+      klass = java_lang_String_;
+      klass->dex_file_ = dex_file;
+      klass->object_size_ = sizeof(String);
     } else {
-      klass = Heap::AllocClass(dex_file);
+      klass = AllocClass(dex_file);
     }
-    bool is_loaded = LoadClass(descriptor, klass);
+    bool is_loaded;
+    if (class_def == NULL) {
+      is_loaded = false;
+    } else {
+      is_loaded = LoadClass(*class_def, klass);
+    }
     if (!is_loaded) {
       // TODO: this occurs only when a dex file is provided.
       LG << "Class not found";  // TODO: NoClassDefFoundError
@@ -177,7 +241,7 @@
     for (size_t i = 0; i < klass->num_sfields_; ++i) {
       RawDexFile::Field raw_field;
       raw->dexReadClassDataField(&class_data, &raw_field, &last_idx);
-      StaticField* sfield = Heap::AllocStaticField();
+      StaticField* sfield = AllocStaticField();
       klass->sfields_[i] = sfield;
       LoadField(klass, raw_field, sfield);
     }
@@ -191,7 +255,7 @@
     for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
       RawDexFile::Field raw_field;
       raw->dexReadClassDataField(&class_data, &raw_field, &last_idx);
-      InstanceField* ifield = Heap::AllocInstanceField();
+      InstanceField* ifield = AllocInstanceField();
       klass->ifields_[i] = ifield;
       LoadField(klass, raw_field, ifield);
     }
@@ -205,7 +269,7 @@
     for (size_t i = 0; i < klass->NumDirectMethods(); ++i) {
       RawDexFile::Method raw_method;
       raw->dexReadClassDataMethod(&class_data, &raw_method, &last_idx);
-      Method* meth = Heap::AllocMethod();
+      Method* meth = AllocMethod();
       klass->direct_methods_[i] = meth;
       LoadMethod(klass, raw_method, meth);
       // TODO: register maps
@@ -220,14 +284,13 @@
     for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
       RawDexFile::Method raw_method;
       raw->dexReadClassDataMethod(&class_data, &raw_method, &last_idx);
-      Method* meth = Heap::AllocMethod();
+      Method* meth = AllocMethod();
       klass->virtual_methods_[i] = meth;
       LoadMethod(klass, raw_method, meth);
       // TODO: register maps
     }
   }
-
-  return klass;
+  return true;
 }
 
 void ClassLinker::LoadInterfaces(const RawDexFile::ClassDef& class_def,
@@ -283,14 +346,15 @@
   }
 }
 
-DexFile* ClassLinker::FindInClassPath(const char* descriptor) {
+ClassLinker::ClassPathEntry ClassLinker::FindInClassPath(const char* descriptor) {
   for (size_t i = 0; i != class_path_.size(); ++i) {
     DexFile* dex_file = class_path_[i];
-    if (dex_file->HasClass(descriptor)) {
-      return dex_file;
+    const RawDexFile::ClassDef* class_def = dex_file->GetRaw()->FindClassDef(descriptor);
+    if (class_def != NULL) {
+      return ClassPathEntry(dex_file, class_def);
     }
   }
-  return NULL;
+  return ClassPathEntry(NULL, NULL);
 }
 
 void ClassLinker::AppendToClassPath(DexFile* dex_file) {
@@ -298,9 +362,9 @@
 }
 
 Class* ClassLinker::CreatePrimitiveClass(JType type, const char* descriptor) {
-  Class* klass = Heap::AllocClass(NULL);
+  Class* klass = AllocClass(NULL);
   CHECK(klass != NULL);
-  klass->super_class_ = java_lang_Class_;
+  klass->super_class_ = NULL;
   klass->access_flags_ = kAccPublic | kAccFinal | kAccAbstract;
   klass->descriptor_ = descriptor;
   klass->status_ = Class::kStatusInitialized;
@@ -946,7 +1010,7 @@
     klass->vtable_count_ += miranda_count;
 
     for (int i = 0; i < miranda_count; i++) {
-      Method* meth = Heap::AllocMethod();
+      Method* meth = AllocMethod();
       memcpy(meth, miranda_list[i], sizeof(Method));
       meth->klass_ = klass;
       meth->access_flags_ |= kAccMiranda;
@@ -968,11 +1032,11 @@
 }
 
 bool ClassLinker::LinkInstanceFields(Class* klass) {
-  int fieldOffset;
+  int field_offset;
   if (klass->GetSuperClass() != NULL) {
-    fieldOffset = klass->GetSuperClass()->object_size_;
+    field_offset = klass->GetSuperClass()->object_size_;
   } else {
-    fieldOffset = OFFSETOF_MEMBER(DataObject, fields_);
+    field_offset = OFFSETOF_MEMBER(DataObject, fields_);
   }
   // Move references to the front.
   klass->num_reference_ifields_ = 0;
@@ -1000,22 +1064,22 @@
     if (c != '[' && c != 'L') {
       break;
     }
-    pField->SetOffset(fieldOffset);
-    fieldOffset += sizeof(uint32_t);
+    pField->SetOffset(field_offset);
+    field_offset += sizeof(uint32_t);
   }
 
   // Now we want to pack all of the double-wide fields together.  If
   // we're not aligned, though, we want to shuffle one 32-bit field
   // into place.  If we can't find one, we'll have to pad it.
-  if (i != klass->NumInstanceFields() && (fieldOffset & 0x04) != 0) {
+  if (i != klass->NumInstanceFields() && (field_offset & 0x04) != 0) {
     InstanceField* pField = klass->GetInstanceField(i);
     char c = pField->GetType();
 
     if (c != 'J' && c != 'D') {
       // The field that comes next is 32-bit, so just advance past it.
       assert(c != '[' && c != 'L');
-      pField->SetOffset(fieldOffset);
-      fieldOffset += sizeof(uint32_t);
+      pField->SetOffset(field_offset);
+      field_offset += sizeof(uint32_t);
       i++;
     } else {
       // Next field is 64-bit, so search for a 32-bit field we can
@@ -1028,22 +1092,22 @@
           klass->SetInstanceField(i, singleField);
           klass->SetInstanceField(j, pField);
           pField = singleField;
-          pField->SetOffset(fieldOffset);
-          fieldOffset += sizeof(uint32_t);
+          pField->SetOffset(field_offset);
+          field_offset += sizeof(uint32_t);
           found = true;
           i++;
           break;
         }
       }
       if (!found) {
-        fieldOffset += sizeof(uint32_t);
+        field_offset += sizeof(uint32_t);
       }
     }
   }
 
   // Alignment is good, shuffle any double-wide fields forward, and
   // finish assigning field offsets to all fields.
-  assert(i == klass->NumInstanceFields() || (fieldOffset & 0x04) == 0);
+  assert(i == klass->NumInstanceFields() || (field_offset & 0x04) == 0);
   for ( ; i < klass->NumInstanceFields(); i++) {
     InstanceField* pField = klass->GetInstanceField(i);
     char c = pField->GetType();
@@ -1063,10 +1127,10 @@
       // This is a double-wide field, leave it be.
     }
 
-    pField->SetOffset(fieldOffset);
-    fieldOffset += sizeof(uint32_t);
+    pField->SetOffset(field_offset);
+    field_offset += sizeof(uint32_t);
     if (c == 'J' || c == 'D')
-      fieldOffset += sizeof(uint32_t);
+      field_offset += sizeof(uint32_t);
   }
 
 #ifndef NDEBUG
@@ -1096,7 +1160,7 @@
   }
 #endif
 
-  klass->object_size_ = fieldOffset;
+  klass->object_size_ = field_offset;
   return true;
 }
 
@@ -1170,7 +1234,7 @@
   const RawDexFile* raw = referring->GetDexFile()->GetRaw();
   const RawDexFile::StringId& string_id = raw->GetStringId(string_idx);
   const char* string_data = raw->GetStringData(string_id);
-  String* new_string = Heap::AllocStringFromModifiedUtf8(string_data);
+  String* new_string = Heap::AllocStringFromModifiedUtf8(java_lang_String_, char_array_class_, string_data);
   // TODO: intern the new string
   referring->GetDexFile()->SetResolvedString(new_string, string_idx);
   return new_string;
diff --git a/src/class_linker.h b/src/class_linker.h
index 00271a5..e4c5ff9 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -20,6 +20,11 @@
 
   ~ClassLinker() {}
 
+  Class* AllocClass(DexFile* dex_file);
+  StaticField* AllocStaticField();
+  InstanceField* AllocInstanceField();
+  Method* AllocMethod();
+
   // Finds a class by its descriptor name.
   Class* FindClass(const char* descriptor,
                    Object* class_loader,
@@ -43,7 +48,9 @@
 
   String* ResolveString(const Class* referring, uint32_t string_idx);
 
-  DexFile* FindInClassPath(const char* descriptor);
+  typedef std::pair<DexFile*, const RawDexFile::ClassDef*> ClassPathEntry;
+
+  ClassPathEntry FindInClassPath(const char* descriptor);
 
   void AppendToClassPath(DexFile* dex_file);
 
@@ -117,8 +124,12 @@
   Class* primitive_long_;
   Class* primitive_void_;
 
-  Class* java_lang_Object_;
   Class* java_lang_Class_;
+  Class* java_lang_Object_;
+  Class* java_lang_ref_Field_;
+  Class* java_lang_ref_Method_;
+  Class* java_lang_String_;
+  Class* char_array_class_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassLinker);
 };
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index d755e3e..bbe6ebc 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -15,7 +15,7 @@
   scoped_ptr<ClassLinker> linker(ClassLinker::Create());
   linker->AppendToClassPath(dex.get());
 
-  scoped_ptr<Class> klass(Heap::AllocClass(dex.get()));
+  scoped_ptr<Class> klass(linker.get()->AllocClass(dex.get()));
   bool result1 = linker->LoadClass("NoSuchClass", klass.get());
   EXPECT_FALSE(result1);
   bool result2 = linker->LoadClass("LNoSuchClass;", klass.get());
@@ -29,7 +29,7 @@
   scoped_ptr<ClassLinker> linker(ClassLinker::Create());
   linker->AppendToClassPath(dex.get());
 
-  scoped_ptr<Class> klass(Heap::AllocClass(dex.get()));
+  scoped_ptr<Class> klass(linker.get()->AllocClass(dex.get()));
   bool result = linker->LoadClass("LNested;", klass.get());
   ASSERT_TRUE(result);
 
@@ -52,7 +52,9 @@
 
   Class* JavaLangObject = linker->FindClass("Ljava/lang/Object;", NULL, dex.get());
   ASSERT_TRUE(JavaLangObject != NULL);
-  EXPECT_TRUE(JavaLangObject->GetClass() != NULL);
+  ASSERT_TRUE(JavaLangObject->GetClass() != NULL);
+  ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
+  EXPECT_EQ(JavaLangObject->GetClass()->GetSuperClass(), JavaLangObject);
   ASSERT_TRUE(JavaLangObject->GetDescriptor() == "Ljava/lang/Object;");
   EXPECT_TRUE(JavaLangObject->GetSuperClass() == NULL);
   EXPECT_FALSE(JavaLangObject->HasSuperClass());
@@ -72,7 +74,9 @@
 
   Class* MyClass = linker->FindClass("LMyClass;", NULL, dex.get());
   ASSERT_TRUE(MyClass != NULL);
-  EXPECT_TRUE(MyClass->GetClass() != NULL);
+  ASSERT_TRUE(MyClass->GetClass() != NULL);
+  ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
+  EXPECT_EQ(MyClass->GetClass()->GetSuperClass(), JavaLangObject);
   ASSERT_TRUE(MyClass->GetDescriptor() == "LMyClass;");
   EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
   EXPECT_TRUE(MyClass->HasSuperClass());
@@ -90,6 +94,9 @@
   EXPECT_EQ(0U, MyClass->NumVirtualMethods());
   EXPECT_EQ(0U, MyClass->NumInstanceFields());
   EXPECT_EQ(0U, MyClass->NumStaticFields());
+
+  EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
+
 }
 
 }  // namespace art
diff --git a/src/heap.h b/src/heap.h
index b9f7937..f7ae5a5 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -19,47 +19,30 @@
 
   ~Heap() {}
 
-  static Class* AllocClass(DexFile* dex_file) {
-    byte* raw = new byte[sizeof(Class)]();
-    Class* klass = reinterpret_cast<Class*>(raw);
-    klass->dex_file_ = dex_file;
-    return klass;
-  }
-
-  static StaticField* AllocStaticField() {
-    size_t size = sizeof(StaticField);
+  static Object* AllocRaw(size_t size, Class* klass) {
     byte* raw = new byte[size]();
-    return reinterpret_cast<StaticField*>(raw);
+    Object* object = reinterpret_cast<Object*>(raw);
+    object->klass_ = klass;
+    return object;
   }
 
-  static InstanceField* AllocInstanceField() {
-    size_t size = sizeof(InstanceField);
-    byte* raw = new byte[size]();
-    return reinterpret_cast<InstanceField*>(raw);
+  static Object* AllocObject(Class* klass) {
+    return AllocRaw(klass->object_size_, klass);
   }
 
-  static Method* AllocMethod() {
-    size_t size = sizeof(Method);
-    byte* raw = new byte[size]();
-    return reinterpret_cast<Method*>(raw);
-  }
-
-  static CharArray* AllocCharArray(size_t length) {
+  static CharArray* AllocCharArray(Class* char_array, size_t length) {
     size_t size = sizeof(Array) + length * sizeof(uint16_t);
-    byte* raw = new byte[size]();
-    return reinterpret_cast<CharArray*>(raw);
+    return reinterpret_cast<CharArray*>(AllocRaw(size, char_array));
   }
 
-  static String* AllocString() {
-    size_t size = sizeof(String);
-    byte* raw = new byte[size]();
-    return reinterpret_cast<String*>(raw);
+  static String* AllocString(Class* java_lang_String) {
+    return reinterpret_cast<String*>(AllocObject(java_lang_String));
   }
 
-  static String* AllocStringFromModifiedUtf8(const char* data) {
-    String* string = AllocString();
+  static String* AllocStringFromModifiedUtf8(Class* java_lang_String, Class* char_array, const char* data) {
+    String* string = AllocString(java_lang_String);
     uint32_t count = strlen(data);  // TODO
-    CharArray* array = AllocCharArray(count);
+    CharArray* array = AllocCharArray(char_array, count);
     string->array_ = array;
     string->count_ = count;
     return string;
diff --git a/src/object.h b/src/object.h
index d7df9dc..cd57460 100644
--- a/src/object.h
+++ b/src/object.h
@@ -190,8 +190,8 @@
 
 class Field : public Object {
  public:
-  Class* GetClass() const {
-    return klass_;
+  Class* GetDeclaringClass() const {
+    return declaring_class_;
   }
 
   const char* GetName() const {
@@ -219,7 +219,7 @@
 #undef FIELD_FIELD_SLOTS
 
   // The class in which this field is declared.
-  Class* klass_;
+  Class* declaring_class_;
 
   const char* name_;
 
@@ -315,12 +315,12 @@
     return name_;
   }
 
-  Class* GetClass() const {
-    return klass_;
+  Class* GetDeclaringClass() const {
+    return declaring_class_;
   }
 
   // const char* GetReturnTypeDescriptor() const {
-  //   return klass_->GetDexFile_->GetRaw()->dexStringByTypeIdx(proto_id_.return_type_id_);
+  //   return declaring_class_->GetDexFile_->GetRaw()->dexStringByTypeIdx(proto_id_.return_type_id_);
   // }
 
   // Returns true if the method is declared public.
@@ -400,7 +400,7 @@
 #undef METHOD_FIELD_SLOTS
 
   // the class we are a part of
-  Class* klass_;
+  Class* declaring_class_;
 
   // access flags; low 16 bits are defined by spec (could be uint16_t?)
   uint32_t access_flags_;
diff --git a/src/object_test.cc b/src/object_test.cc
index c49c4fd..b00e123 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -36,7 +36,7 @@
   scoped_ptr<ClassLinker> linker(ClassLinker::Create());
   linker->AppendToClassPath(dex_file.get());
 
-  scoped_ptr<Class> klass(Heap::AllocClass(dex_file.get()));
+  scoped_ptr<Class> klass(linker.get()->AllocClass(dex_file.get()));
   bool result = linker->LoadClass("LProtoCompare;", klass.get());
   ASSERT_TRUE(result);
 
@@ -95,10 +95,10 @@
   scoped_ptr<ClassLinker> linker2(ClassLinker::Create());
   linker2->AppendToClassPath(dex_file2.get());
 
-  scoped_ptr<Class> klass1(Heap::AllocClass(dex_file1.get()));
+  scoped_ptr<Class> klass1(linker1.get()->AllocClass(dex_file1.get()));
   bool result1 = linker1->LoadClass("LProtoCompare;", klass1.get());
   ASSERT_TRUE(result1);
-  scoped_ptr<Class> klass2(Heap::AllocClass(dex_file2.get()));
+  scoped_ptr<Class> klass2(linker2.get()->AllocClass(dex_file2.get()));
   bool result2 = linker2->LoadClass("LProtoCompare2;", klass2.get());
   ASSERT_TRUE(result2);