commit 0cfe1fb7060576d047f7f894fc0d8b87de84fcab
author Ian Rogers <irogers@google.com> Fri Aug 26 03:29:44 2011 -0700
committer Ian Rogers <irogers@google.com> Fri Sep 02 14:48:01 2011 -0700
tree 4255eae2034dcb0febe28411c50cba76189f39ae
parent a09576416788b916095739e43a16917e7948f3a4

Use accessor methods for Object fields.

Ensure that Object fields are modified via accessors so that it's easy
to insert barriers (make all fields within Objects private). Add validity
checks to Field and Method accessors to ensure they are accessed when a
Class is in a suitable state. Add validity checks to all Object
accessors to check heap isn't corrupted. Remove hacked in strings from Field
and Method; make type fields used the dex cache that is lazily initialized.
Clean up various other TODOs and lint issues.

Change-Id: Iac0afc515c01f5419874d9cdcdb9a7b45443e3fb

src/heap.h

diff --git a/src/heap.h b/src/heap.h
index 6420a2a..bc06289 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -7,6 +7,7 @@
 
 #include "globals.h"
 #include "object_bitmap.h"
+#include "offsets.h"
 
 namespace art {
 
@@ -36,6 +37,9 @@
   // Check sanity of given reference. Requires the heap lock.
   static void VerifyObject(const Object *obj);
 
+  // Check sanity of all live references. Requires the heap lock.
+  static void VerifyHeap();
+
   // A weaker test than VerifyObject that doesn't require the heap lock,
   // and doesn't abort on error, allowing the caller to report more
   // meaningful diagnostics.
@@ -74,16 +78,16 @@
     return mark_bitmap_;
   }
 
-  static void SetReferenceOffsets(size_t reference_referent_offset,
-                                  size_t reference_queue_offset,
-                                  size_t reference_queueNext_offset,
-                                  size_t reference_pendingNext_offset,
-                                  size_t finalizer_reference_zombie_offset) {
-    CHECK_NE(reference_referent_offset, 0U);
-    CHECK_NE(reference_queue_offset, 0U);
-    CHECK_NE(reference_queueNext_offset, 0U);
-    CHECK_NE(reference_pendingNext_offset, 0U);
-    CHECK_NE(finalizer_reference_zombie_offset, 0U);
+  static void SetReferenceOffsets(MemberOffset reference_referent_offset,
+                                  MemberOffset reference_queue_offset,
+                                  MemberOffset reference_queueNext_offset,
+                                  MemberOffset reference_pendingNext_offset,
+                                  MemberOffset finalizer_reference_zombie_offset) {
+    CHECK_NE(reference_referent_offset.Uint32Value(), 0U);
+    CHECK_NE(reference_queue_offset.Uint32Value(), 0U);
+    CHECK_NE(reference_queueNext_offset.Uint32Value(), 0U);
+    CHECK_NE(reference_pendingNext_offset.Uint32Value(), 0U);
+    CHECK_NE(finalizer_reference_zombie_offset.Uint32Value(), 0U);
     reference_referent_offset_ = reference_referent_offset;
     reference_queue_offset_ = reference_queue_offset;
     reference_queueNext_offset_ = reference_queueNext_offset;
@@ -91,31 +95,36 @@
     finalizer_reference_zombie_offset_ = finalizer_reference_zombie_offset;
   }
 
-  static size_t GetReferenceReferentOffset() {
-    DCHECK_NE(reference_referent_offset_, 0U);
+  static MemberOffset GetReferenceReferentOffset() {
+    DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
     return reference_referent_offset_;
   }
 
-  static size_t GetReferenceQueueOffset() {
-    DCHECK_NE(reference_queue_offset_, 0U);
+  static MemberOffset GetReferenceQueueOffset() {
+    DCHECK_NE(reference_queue_offset_.Uint32Value(), 0U);
     return reference_queue_offset_;
   }
 
-  static size_t GetReferenceQueueNextOffset() {
-    DCHECK_NE(reference_queueNext_offset_, 0U);
+  static MemberOffset GetReferenceQueueNextOffset() {
+    DCHECK_NE(reference_queueNext_offset_.Uint32Value(), 0U);
     return reference_queueNext_offset_;
   }
 
-  static size_t GetReferencePendingNextOffset() {
-    DCHECK_NE(reference_pendingNext_offset_, 0U);
+  static MemberOffset GetReferencePendingNextOffset() {
+    DCHECK_NE(reference_pendingNext_offset_.Uint32Value(), 0U);
     return reference_pendingNext_offset_;
   }
 
-  static size_t GetFinalizerReferenceZombieOffset() {
-    DCHECK_NE(finalizer_reference_zombie_offset_, 0U);
+  static MemberOffset GetFinalizerReferenceZombieOffset() {
+    DCHECK_NE(finalizer_reference_zombie_offset_.Uint32Value(), 0U);
     return finalizer_reference_zombie_offset_;
   }
 
+  static void DisableObjectValidation() {
+    // TODO: remove this hack necessary for image writing
+    verify_object_disabled_ = true;
+  }
+
  private:
   // Allocates uninitialized storage.
   static Object* Allocate(size_t num_bytes);
@@ -158,19 +167,21 @@
   static size_t num_objects_allocated_;
 
   // offset of java.lang.ref.Reference.referent
-  static size_t reference_referent_offset_;
+  static MemberOffset reference_referent_offset_;
 
   // offset of java.lang.ref.Reference.queue
-  static size_t reference_queue_offset_;
+  static MemberOffset reference_queue_offset_;
 
   // offset of java.lang.ref.Reference.queueNext
-  static size_t reference_queueNext_offset_;
+  static MemberOffset reference_queueNext_offset_;
 
   // offset of java.lang.ref.Reference.pendingNext
-  static size_t reference_pendingNext_offset_;
+  static MemberOffset reference_pendingNext_offset_;
 
   // offset of java.lang.ref.FinalizerReference.zombie
-  static size_t finalizer_reference_zombie_offset_;
+  static MemberOffset finalizer_reference_zombie_offset_;
+
+  static bool verify_object_disabled_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Heap);
 };