diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 7a54bb1..cef9954 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -504,13 +504,6 @@
   CHECK_STREQ(fh.GetName(), "zombie");
   CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
 
-  gc::Heap* heap = Runtime::Current()->GetHeap();
-  heap->SetReferenceOffsets(referent->GetOffset(),
-                            queue->GetOffset(),
-                            queueNext->GetOffset(),
-                            pendingNext->GetOffset(),
-                            zombie->GetOffset());
-
   // ensure all class_roots_ are initialized
   for (size_t i = 0; i < kClassRootsMax; i++) {
     ClassRoot class_root = static_cast<ClassRoot>(i);
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index d0555ff..7eb7b01 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -32,6 +32,7 @@
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/proxy.h"
+#include "mirror/reference.h"
 #include "mirror/stack_trace_element.h"
 #include "sirt_ref.h"
 
@@ -624,6 +625,25 @@
   };
 };
 
+struct ReferenceOffsets : public CheckOffsets<mirror::Reference> {
+  ReferenceOffsets() : CheckOffsets<mirror::Reference>(false, "Ljava/lang/ref/Reference;") {
+    // alphabetical references
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Reference, pending_next_),  "pendingNext"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Reference, queue_),         "queue"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Reference, queue_next_),    "queueNext"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Reference, referent_),      "referent"));
+  };
+};
+
+struct FinalizerReferenceOffsets : public CheckOffsets<mirror::FinalizerReference> {
+  FinalizerReferenceOffsets() : CheckOffsets<mirror::FinalizerReference>(false, "Ljava/lang/ref/FinalizerReference;") {
+    // alphabetical references
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, next_),   "next"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, prev_),   "prev"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, zombie_), "zombie"));
+  };
+};
+
 // C++ fields must exactly match the fields in the Java classes. If this fails,
 // reorder the fields in the C++ class. Managed class fields are ordered by
 // ClassLinker::LinkFields.
@@ -639,6 +659,8 @@
   EXPECT_TRUE(ClassLoaderOffsets().Check());
   EXPECT_TRUE(ProxyOffsets().Check());
   EXPECT_TRUE(DexCacheOffsets().Check());
+  EXPECT_TRUE(ReferenceOffsets().Check());
+  EXPECT_TRUE(FinalizerReferenceOffsets().Check());
 
   EXPECT_TRUE(ClassClassOffsets().Check());
   EXPECT_TRUE(StringClassOffsets().Check());
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index 8b9f60e..4f3ad32 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -44,6 +44,7 @@
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/dex_cache.h"
+#include "mirror/reference-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array.h"
 #include "mirror/object_array-inl.h"
@@ -1189,9 +1190,7 @@
 // the heap for later processing.
 void MarkSweep::DelayReferenceReferent(mirror::Class* klass, Object* obj) {
   DCHECK(klass != nullptr);
-  DCHECK(klass->IsReferenceClass());
-  DCHECK(obj != NULL);
-  heap_->DelayReferenceReferent(klass, obj, IsMarkedCallback, this);
+  heap_->DelayReferenceReferent(klass, obj->AsReference(), IsMarkedCallback, this);
 }
 
 class MarkObjectVisitor {
diff --git a/runtime/gc/collector/semi_space.cc b/runtime/gc/collector/semi_space.cc
index 89694d4..23b155c 100644
--- a/runtime/gc/collector/semi_space.cc
+++ b/runtime/gc/collector/semi_space.cc
@@ -44,6 +44,7 @@
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/dex_cache.h"
+#include "mirror/reference-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array.h"
 #include "mirror/object_array-inl.h"
@@ -633,7 +634,7 @@
 // Process the "referent" field in a java.lang.ref.Reference.  If the referent has not yet been
 // marked, put it on the appropriate list in the heap for later processing.
 void SemiSpace::DelayReferenceReferent(mirror::Class* klass, Object* obj) {
-  heap_->DelayReferenceReferent(klass, obj, MarkedForwardingAddressCallback, this);
+  heap_->DelayReferenceReferent(klass, obj->AsReference(), MarkedForwardingAddressCallback, this);
 }
 
 class SemiSpaceMarkObjectVisitor {
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 13dd90e..76b94fd 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -54,6 +54,7 @@
 #include "mirror/object.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
+#include "mirror/reference-inl.h"
 #include "object_utils.h"
 #include "os.h"
 #include "runtime.h"
@@ -103,11 +104,6 @@
       ignore_max_footprint_(ignore_max_footprint),
       have_zygote_space_(false),
       large_object_threshold_(std::numeric_limits<size_t>::max()),  // Starts out disabled.
-      soft_reference_queue_(this),
-      weak_reference_queue_(this),
-      finalizer_reference_queue_(this),
-      phantom_reference_queue_(this),
-      cleared_references_(this),
       collector_type_running_(kCollectorTypeNone),
       last_gc_type_(collector::kGcTypeNone),
       next_gc_type_(collector::kGcTypePartial),
@@ -144,11 +140,6 @@
       current_non_moving_allocator_(kAllocatorTypeNonMoving),
       bump_pointer_space_(nullptr),
       temp_space_(nullptr),
-      reference_referent_offset_(0),
-      reference_queue_offset_(0),
-      reference_queueNext_offset_(0),
-      reference_pendingNext_offset_(0),
-      finalizer_reference_zombie_offset_(0),
       min_free_(min_free),
       max_free_(max_free),
       target_utilization_(target_utilization),
@@ -792,29 +783,12 @@
   timings.EndSplit();
 }
 
-bool Heap::IsEnqueued(mirror::Object* ref) const {
-  // Since the references are stored as cyclic lists it means that once enqueued, the pending next
-  // will always be non-null.
-  return ref->GetFieldObject<mirror::Object>(GetReferencePendingNextOffset(), false) != nullptr;
-}
-
-bool Heap::IsEnqueuable(mirror::Object* ref) const {
-  DCHECK(ref != nullptr);
-  const mirror::Object* queue =
-      ref->GetFieldObject<mirror::Object>(GetReferenceQueueOffset(), false);
-  const mirror::Object* queue_next =
-      ref->GetFieldObject<mirror::Object>(GetReferenceQueueNextOffset(), false);
-  return queue != nullptr && queue_next == nullptr;
-}
-
 // Process the "referent" field in a java.lang.ref.Reference.  If the referent has not yet been
 // marked, put it on the appropriate list in the heap for later processing.
-void Heap::DelayReferenceReferent(mirror::Class* klass, mirror::Object* obj,
+void Heap::DelayReferenceReferent(mirror::Class* klass, mirror::Reference* ref,
                                   IsMarkedCallback is_marked_callback, void* arg) {
-  DCHECK(klass != nullptr);
-  DCHECK(klass->IsReferenceClass());
-  DCHECK(obj != nullptr);
-  mirror::Object* referent = GetReferenceReferent(obj);
+  DCHECK_EQ(klass, ref->GetClass());
+  mirror::Object* referent = ref->GetReferent();
   if (referent != nullptr) {
     mirror::Object* forward_address = is_marked_callback(referent, arg);
     // Null means that the object is not currently marked.
@@ -824,20 +798,20 @@
       // We need to check that the references haven't already been enqueued since we can end up
       // scanning the same reference multiple times due to dirty cards.
       if (klass->IsSoftReferenceClass()) {
-        soft_reference_queue_.AtomicEnqueueIfNotEnqueued(self, obj);
+        soft_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
       } else if (klass->IsWeakReferenceClass()) {
-        weak_reference_queue_.AtomicEnqueueIfNotEnqueued(self, obj);
+        weak_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
       } else if (klass->IsFinalizerReferenceClass()) {
-        finalizer_reference_queue_.AtomicEnqueueIfNotEnqueued(self, obj);
+        finalizer_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
       } else if (klass->IsPhantomReferenceClass()) {
-        phantom_reference_queue_.AtomicEnqueueIfNotEnqueued(self, obj);
+        phantom_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
       } else {
         LOG(FATAL) << "Invalid reference type " << PrettyClass(klass) << " " << std::hex
                    << klass->GetAccessFlags();
       }
     } else if (referent != forward_address) {
       // Referent is already marked and we need to update it.
-      SetReferenceReferent(obj, forward_address);
+      ref->SetReferent<false>(forward_address);
     }
   }
 }
@@ -2013,8 +1987,9 @@
     VerifyReferenceVisitor visitor(heap_);
     // The class doesn't count as a reference but we should verify it anyways.
     collector::MarkSweep::VisitObjectReferences(obj, visitor, true);
-    if (obj->GetClass()->IsReferenceClass()) {
-      visitor(obj, heap_->GetReferenceReferent(obj), MemberOffset(0), false);
+    if (obj->IsReferenceInstance()) {
+      mirror::Reference* ref = obj->AsReference();
+      visitor(obj, ref->GetReferent(), mirror::Reference::ReferentOffset(), false);
     }
     failed_ = failed_ || visitor.Failed();
   }
@@ -2476,35 +2451,6 @@
   non_moving_space_->ClearGrowthLimit();
 }
 
-void Heap::SetReferenceOffsets(MemberOffset reference_referent_offset,
-                               MemberOffset reference_queue_offset,
-                               MemberOffset reference_queueNext_offset,
-                               MemberOffset reference_pendingNext_offset,
-                               MemberOffset finalizer_reference_zombie_offset) {
-  reference_referent_offset_ = reference_referent_offset;
-  reference_queue_offset_ = reference_queue_offset;
-  reference_queueNext_offset_ = reference_queueNext_offset;
-  reference_pendingNext_offset_ = reference_pendingNext_offset;
-  finalizer_reference_zombie_offset_ = 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);
-}
-
-void Heap::SetReferenceReferent(mirror::Object* reference, mirror::Object* referent) {
-  DCHECK(reference != NULL);
-  DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
-  reference->SetFieldObject<false, false>(reference_referent_offset_, referent, true);
-}
-
-mirror::Object* Heap::GetReferenceReferent(mirror::Object* reference) {
-  DCHECK(reference != NULL);
-  DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
-  return reference->GetFieldObject<mirror::Object>(reference_referent_offset_, true);
-}
-
 void Heap::AddFinalizerReference(Thread* self, mirror::Object* object) {
   ScopedObjectAccess soa(self);
   JValue result;
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 12c55c4..1e0a596 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -312,26 +312,6 @@
     return discontinuous_spaces_;
   }
 
-  void SetReferenceOffsets(MemberOffset reference_referent_offset,
-                           MemberOffset reference_queue_offset,
-                           MemberOffset reference_queueNext_offset,
-                           MemberOffset reference_pendingNext_offset,
-                           MemberOffset finalizer_reference_zombie_offset);
-  MemberOffset GetReferenceReferentOffset() const {
-    return reference_referent_offset_;
-  }
-  MemberOffset GetReferenceQueueOffset() const {
-    return reference_queue_offset_;
-  }
-  MemberOffset GetReferenceQueueNextOffset() const {
-    return reference_queueNext_offset_;
-  }
-  MemberOffset GetReferencePendingNextOffset() const {
-    return reference_pendingNext_offset_;
-  }
-  MemberOffset GetFinalizerReferenceZombieOffset() const {
-    return finalizer_reference_zombie_offset_;
-  }
   static mirror::Object* PreserveSoftReferenceCallback(mirror::Object* obj, void* arg);
   void ProcessReferences(TimingLogger& timings, bool clear_soft,
                          IsMarkedCallback* is_marked_callback,
@@ -624,20 +604,9 @@
   bool IsValidContinuousSpaceObjectAddress(const mirror::Object* obj) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  // Pushes a list of cleared references out to the managed heap.
-  void SetReferenceReferent(mirror::Object* reference, mirror::Object* referent)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::Object* GetReferenceReferent(mirror::Object* reference)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void ClearReferenceReferent(mirror::Object* reference)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    SetReferenceReferent(reference, nullptr);
-  }
   void EnqueueClearedReferences();
   // Returns true if the reference object has not yet been enqueued.
-  bool IsEnqueuable(mirror::Object* ref) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  bool IsEnqueued(mirror::Object* ref) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void DelayReferenceReferent(mirror::Class* klass, mirror::Object* obj,
+  void DelayReferenceReferent(mirror::Class* klass, mirror::Reference* ref,
                               IsMarkedCallback is_marked_callback, void* arg)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -918,17 +887,6 @@
   // Temp space is the space which the semispace collector copies to.
   space::BumpPointerSpace* temp_space_;
 
-  // offset of java.lang.ref.Reference.referent
-  MemberOffset reference_referent_offset_;
-  // offset of java.lang.ref.Reference.queue
-  MemberOffset reference_queue_offset_;
-  // offset of java.lang.ref.Reference.queueNext
-  MemberOffset reference_queueNext_offset_;
-  // offset of java.lang.ref.Reference.pendingNext
-  MemberOffset reference_pendingNext_offset_;
-  // offset of java.lang.ref.FinalizerReference.zombie
-  MemberOffset finalizer_reference_zombie_offset_;
-
   // Minimum free guarantees that you always have at least min_free_ free bytes after growing for
   // utilization, regardless of target utilization ratio.
   size_t min_free_;
diff --git a/runtime/gc/reference_queue.cc b/runtime/gc/reference_queue.cc
index 203701f..aee7891 100644
--- a/runtime/gc/reference_queue.cc
+++ b/runtime/gc/reference_queue.cc
@@ -20,91 +20,84 @@
 #include "heap.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
+#include "mirror/reference-inl.h"
 
 namespace art {
 namespace gc {
 
-ReferenceQueue::ReferenceQueue(Heap* heap)
+ReferenceQueue::ReferenceQueue()
     : lock_("reference queue lock"),
-      heap_(heap),
       list_(nullptr) {
 }
 
-void ReferenceQueue::AtomicEnqueueIfNotEnqueued(Thread* self, mirror::Object* ref) {
+void ReferenceQueue::AtomicEnqueueIfNotEnqueued(Thread* self, mirror::Reference* ref) {
   DCHECK(ref != NULL);
   MutexLock mu(self, lock_);
-  if (!heap_->IsEnqueued(ref)) {
+  if (!ref->IsEnqueued()) {
     EnqueuePendingReference(ref);
   }
 }
 
-void ReferenceQueue::EnqueueReference(mirror::Object* ref) {
-  CHECK(heap_->IsEnqueuable(ref));
+void ReferenceQueue::EnqueueReference(mirror::Reference* ref) {
+  CHECK(ref->IsEnqueuable());
   EnqueuePendingReference(ref);
 }
 
-void ReferenceQueue::EnqueuePendingReference(mirror::Object* ref) {
+void ReferenceQueue::EnqueuePendingReference(mirror::Reference* ref) {
   DCHECK(ref != NULL);
-  MemberOffset pending_next_offset = heap_->GetReferencePendingNextOffset();
-  DCHECK_NE(pending_next_offset.Uint32Value(), 0U);
   if (IsEmpty()) {
     // 1 element cyclic queue, ie: Reference ref = ..; ref.pendingNext = ref;
-    if (Runtime::Current()->IsActiveTransaction()) {
-      ref->SetFieldObject<true>(pending_next_offset, ref, false);
-    } else {
-      ref->SetFieldObject<false>(pending_next_offset, ref, false);
-    }
     list_ = ref;
   } else {
-    mirror::Object* head = list_->GetFieldObject<mirror::Object>(pending_next_offset, false);
+    mirror::Reference* head = list_->GetPendingNext();
     if (Runtime::Current()->IsActiveTransaction()) {
-      ref->SetFieldObject<true>(pending_next_offset, head, false);
-      list_->SetFieldObject<true>(pending_next_offset, ref, false);
+      ref->SetPendingNext<true>(head);
     } else {
-      ref->SetFieldObject<false>(pending_next_offset, head, false);
-      list_->SetFieldObject<false>(pending_next_offset, ref, false);
+      ref->SetPendingNext<false>(head);
     }
   }
+  if (Runtime::Current()->IsActiveTransaction()) {
+    list_->SetPendingNext<true>(ref);
+  } else {
+    list_->SetPendingNext<false>(ref);
+  }
 }
 
-mirror::Object* ReferenceQueue::DequeuePendingReference() {
+mirror::Reference* ReferenceQueue::DequeuePendingReference() {
   DCHECK(!IsEmpty());
-  MemberOffset pending_next_offset = heap_->GetReferencePendingNextOffset();
-  mirror::Object* head = list_->GetFieldObject<mirror::Object>(pending_next_offset, false);
+  mirror::Reference* head = list_->GetPendingNext();
   DCHECK(head != nullptr);
-  mirror::Object* ref;
+  mirror::Reference* ref;
   // Note: the following code is thread-safe because it is only called from ProcessReferences which
   // is single threaded.
   if (list_ == head) {
     ref = list_;
     list_ = nullptr;
   } else {
-    mirror::Object* next = head->GetFieldObject<mirror::Object>(pending_next_offset, false);
+    mirror::Reference* next = head->GetPendingNext();
     if (Runtime::Current()->IsActiveTransaction()) {
-      list_->SetFieldObject<true>(pending_next_offset, next, false);
+      list_->SetPendingNext<true>(next);
     } else {
-      list_->SetFieldObject<false>(pending_next_offset, next, false);
+      list_->SetPendingNext<false>(next);
     }
     ref = head;
   }
   if (Runtime::Current()->IsActiveTransaction()) {
-    ref->SetFieldObject<true>(pending_next_offset, nullptr, false);
+    ref->SetPendingNext<true>(nullptr);
   } else {
-    ref->SetFieldObject<false>(pending_next_offset, nullptr, false);
+    ref->SetPendingNext<false>(nullptr);
   }
   return ref;
 }
 
 void ReferenceQueue::Dump(std::ostream& os) const {
-  mirror::Object* cur = list_;
+  mirror::Reference* cur = list_;
   os << "Reference starting at list_=" << list_ << "\n";
   while (cur != nullptr) {
-    mirror::Object* pending_next =
-        cur->GetFieldObject<mirror::Object>(heap_->GetReferencePendingNextOffset(), false);
+    mirror::Reference* pending_next = cur->GetPendingNext();
     os << "PendingNext=" << pending_next;
-    if (cur->GetClass()->IsFinalizerReferenceClass()) {
-      os << " Zombie=" <<
-          cur->GetFieldObject<mirror::Object>(heap_->GetFinalizerReferenceZombieOffset(), false);
+    if (cur->IsFinalizerReferenceInstance()) {
+      os << " Zombie=" << cur->AsFinalizerReference()->GetZombie();
     }
     os << "\n";
     cur = pending_next;
@@ -115,19 +108,23 @@
                                           IsMarkedCallback* preserve_callback,
                                           void* arg) {
   while (!IsEmpty()) {
-    mirror::Object* ref = DequeuePendingReference();
-    mirror::Object* referent = heap_->GetReferenceReferent(ref);
+    mirror::Reference* ref = DequeuePendingReference();
+    mirror::Object* referent = ref->GetReferent();
     if (referent != nullptr) {
       mirror::Object* forward_address = preserve_callback(referent, arg);
       if (forward_address == nullptr) {
         // Referent is white, clear it.
-        heap_->ClearReferenceReferent(ref);
-        if (heap_->IsEnqueuable(ref)) {
+        if (Runtime::Current()->IsActiveTransaction()) {
+          ref->ClearReferent<true>();
+        } else {
+          ref->ClearReferent<false>();
+        }
+        if (ref->IsEnqueuable()) {
           cleared_references.EnqueuePendingReference(ref);
         }
       } else if (referent != forward_address) {
         // Object moved, need to updated the referent.
-        heap_->SetReferenceReferent(ref, forward_address);
+        ref->SetReferent<false>(forward_address);
       }
     }
   }
@@ -138,42 +135,43 @@
                                                 MarkObjectCallback recursive_mark_callback,
                                                 void* arg) {
   while (!IsEmpty()) {
-    mirror::Object* ref = DequeuePendingReference();
-    mirror::Object* referent = heap_->GetReferenceReferent(ref);
+    mirror::FinalizerReference* ref = DequeuePendingReference()->AsFinalizerReference();
+    mirror::Object* referent = ref->GetReferent();
     if (referent != nullptr) {
       mirror::Object* forward_address = is_marked_callback(referent, arg);
       // If the referent isn't marked, mark it and update the
       if (forward_address == nullptr) {
         forward_address = recursive_mark_callback(referent, arg);
         // If the referent is non-null the reference must queuable.
-        DCHECK(heap_->IsEnqueuable(ref));
+        DCHECK(ref->IsEnqueuable());
         // Move the updated referent to the zombie field.
         if (Runtime::Current()->IsActiveTransaction()) {
-          ref->SetFieldObject<true>(heap_->GetFinalizerReferenceZombieOffset(), forward_address, false);
+          ref->SetZombie<true>(forward_address);
+          ref->ClearReferent<true>();
         } else {
-          ref->SetFieldObject<false>(heap_->GetFinalizerReferenceZombieOffset(), forward_address, false);
+          ref->SetZombie<false>(forward_address);
+          ref->ClearReferent<false>();
         }
-        heap_->ClearReferenceReferent(ref);
         cleared_references.EnqueueReference(ref);
       } else if (referent != forward_address) {
-        heap_->SetReferenceReferent(ref, forward_address);
+        ref->SetReferent<false>(forward_address);
       }
     }
   }
 }
 
 void ReferenceQueue::PreserveSomeSoftReferences(IsMarkedCallback preserve_callback, void* arg) {
-  ReferenceQueue cleared(heap_);
+  ReferenceQueue cleared;
   while (!IsEmpty()) {
-    mirror::Object* ref = DequeuePendingReference();
-    mirror::Object* referent = heap_->GetReferenceReferent(ref);
+    mirror::Reference* ref = DequeuePendingReference();
+    mirror::Object* referent = ref->GetReferent();
     if (referent != nullptr) {
       mirror::Object* forward_address = preserve_callback(referent, arg);
       if (forward_address == nullptr) {
         // Either the reference isn't marked or we don't wish to preserve it.
         cleared.EnqueuePendingReference(ref);
       } else if (forward_address != referent) {
-        heap_->SetReferenceReferent(ref, forward_address);
+        ref->SetReferent<false>(forward_address);
       }
     }
   }
diff --git a/runtime/gc/reference_queue.h b/runtime/gc/reference_queue.h
index 99314ba..8d392ba 100644
--- a/runtime/gc/reference_queue.h
+++ b/runtime/gc/reference_queue.h
@@ -31,6 +31,10 @@
 #include "thread_pool.h"
 
 namespace art {
+namespace mirror {
+class Reference;
+}  // namespace mirror
+
 namespace gc {
 
 class Heap;
@@ -40,18 +44,18 @@
 // java.lang.ref.Reference objects.
 class ReferenceQueue {
  public:
-  explicit ReferenceQueue(Heap* heap);
+  explicit ReferenceQueue();
   // Enqueue a reference if is not already enqueued. Thread safe to call from multiple threads
   // since it uses a lock to avoid a race between checking for the references presence and adding
   // it.
-  void AtomicEnqueueIfNotEnqueued(Thread* self, mirror::Object* ref)
+  void AtomicEnqueueIfNotEnqueued(Thread* self, mirror::Reference* ref)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCKS_EXCLUDED(lock_);
   // Enqueue a reference, unlike EnqueuePendingReference, enqueue reference checks that the
   // reference IsEnqueueable. Not thread safe, used when mutators are paused to minimize lock
   // overhead.
-  void EnqueueReference(mirror::Object* ref) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void EnqueuePendingReference(mirror::Object* ref) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::Object* DequeuePendingReference() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void EnqueueReference(mirror::Reference* ref) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void EnqueuePendingReference(mirror::Reference* ref) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  mirror::Reference* DequeuePendingReference() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   // Enqueues finalizer references with white referents.  White referents are blackened, moved to the
   // zombie field, and the referent field is cleared.
   void EnqueueFinalizerReferences(ReferenceQueue& cleared_references,
@@ -76,7 +80,7 @@
   void Clear() {
     list_ = nullptr;
   }
-  mirror::Object* GetList() {
+  mirror::Reference* GetList() {
     return list_;
   }
 
@@ -84,10 +88,8 @@
   // Lock, used for parallel GC reference enqueuing. It allows for multiple threads simultaneously
   // calling AtomicEnqueueIfNotEnqueued.
   Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
-  // The heap contains the reference offsets.
-  Heap* const heap_;
   // The actual reference list. Not a root since it will be nullptr when the GC is not running.
-  mirror::Object* list_;
+  mirror::Reference* list_;
 };
 
 }  // namespace gc
diff --git a/runtime/mirror/object-inl.h b/runtime/mirror/object-inl.h
index 484c21a..cad1017 100644
--- a/runtime/mirror/object-inl.h
+++ b/runtime/mirror/object-inl.h
@@ -27,6 +27,7 @@
 #include "lock_word-inl.h"
 #include "monitor.h"
 #include "runtime.h"
+#include "reference.h"
 #include "throwable.h"
 
 namespace art {
@@ -197,6 +198,12 @@
 }
 
 template<VerifyObjectFlags kVerifyFlags>
+inline Reference* Object::AsReference() {
+  DCHECK(IsReferenceInstance<kVerifyFlags>());
+  return down_cast<Reference*>(this);
+}
+
+template<VerifyObjectFlags kVerifyFlags>
 inline Array* Object::AsArray() {
   DCHECK(IsArrayInstance<kVerifyFlags>());
   return down_cast<Array*>(this);
@@ -314,6 +321,12 @@
 }
 
 template<VerifyObjectFlags kVerifyFlags>
+inline FinalizerReference* Object::AsFinalizerReference() {
+  DCHECK(IsFinalizerReferenceInstance<kVerifyFlags>());
+  return down_cast<FinalizerReference*>(this);
+}
+
+template<VerifyObjectFlags kVerifyFlags>
 inline bool Object::IsPhantomReferenceInstance() {
   return GetClass<kVerifyFlags>()->IsPhantomReferenceClass();
 }
diff --git a/runtime/mirror/object.h b/runtime/mirror/object.h
index 4e2c624..476259f 100644
--- a/runtime/mirror/object.h
+++ b/runtime/mirror/object.h
@@ -41,6 +41,7 @@
 class ArtMethod;
 class Array;
 class Class;
+class FinalizerReference;
 template<class T> class ObjectArray;
 template<class T> class PrimitiveArray;
 typedef PrimitiveArray<uint8_t> BooleanArray;
@@ -51,6 +52,7 @@
 typedef PrimitiveArray<int32_t> IntArray;
 typedef PrimitiveArray<int64_t> LongArray;
 typedef PrimitiveArray<int16_t> ShortArray;
+class Reference;
 class String;
 class Throwable;
 
@@ -170,12 +172,16 @@
   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
   bool IsReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
+  Reference* AsReference() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
   bool IsWeakReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
   bool IsSoftReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
   bool IsFinalizerReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
+  FinalizerReference* AsFinalizerReference() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
   bool IsPhantomReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Accessor for Java type fields.
diff --git a/runtime/mirror/reference-inl.h b/runtime/mirror/reference-inl.h
new file mode 100644
index 0000000..0f76f77
--- /dev/null
+++ b/runtime/mirror/reference-inl.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014 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_RUNTIME_MIRROR_REFERENCE_INL_H_
+#define ART_RUNTIME_MIRROR_REFERENCE_INL_H_
+
+#include "reference.h"
+
+namespace art {
+namespace mirror {
+
+inline bool Reference::IsEnqueuable() {
+  // Not using volatile reads as an optimization since this is only called with all the mutators
+  // suspended.
+  const Object* queue = GetFieldObject<mirror::Object>(QueueOffset(), false);
+  const Object* queue_next = GetFieldObject<mirror::Object>(QueueNextOffset(), false);
+  return queue != nullptr && queue_next == nullptr;
+}
+
+}  // namespace mirror
+}  // namespace art
+
+#endif  // ART_RUNTIME_MIRROR_REFERENCE_INL_H_
diff --git a/runtime/mirror/reference.h b/runtime/mirror/reference.h
new file mode 100644
index 0000000..c2a83ff
--- /dev/null
+++ b/runtime/mirror/reference.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2014 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_RUNTIME_MIRROR_REFERENCE_H_
+#define ART_RUNTIME_MIRROR_REFERENCE_H_
+
+#include "object.h"
+
+namespace art {
+
+struct ReferenceOffsets;
+struct FinalizerReferenceOffsets;
+
+namespace mirror {
+
+// C++ mirror of java.lang.ref.Reference
+class MANAGED Reference : public Object {
+ public:
+  static MemberOffset PendingNextOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(Reference, pending_next_);
+  }
+  static MemberOffset QueueOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(Reference, queue_);
+  }
+  static MemberOffset QueueNextOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(Reference, queue_next_);
+  }
+  static MemberOffset ReferentOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(Reference, referent_);
+  }
+
+  Object* GetReferent() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return GetFieldObject<Object>(ReferentOffset(), true);
+  }
+  template<bool kTransactionActive>
+  void SetReferent(Object* referent) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    SetFieldObject<kTransactionActive>(ReferentOffset(), referent, true);
+  }
+  template<bool kTransactionActive>
+  void ClearReferent() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    SetFieldObject<kTransactionActive>(ReferentOffset(), nullptr, true);
+  }
+
+  // Volatile read/write is not necessary since the java pending next is only accessed from
+  // the java threads for cleared references. Once these cleared references have a null referent,
+  // we never end up reading their pending next from the GC again.
+  Reference* GetPendingNext() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return GetFieldObject<Reference>(PendingNextOffset(), false);
+  }
+  template<bool kTransactionActive>
+  void SetPendingNext(Reference* pending_next) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    SetFieldObject<kTransactionActive>(PendingNextOffset(), pending_next, false);
+  }
+
+  bool IsEnqueued() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    // Since the references are stored as cyclic lists it means that once enqueued, the pending
+    // next is always non-null.
+    return GetPendingNext() != nullptr;
+  }
+
+  bool IsEnqueuable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ private:
+  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+  HeapReference<Reference> pending_next_;  // Note this is Java volatile:
+  HeapReference<Object> queue_;  // Note this is Java volatile:
+  HeapReference<Reference> queue_next_;  // Note this is Java volatile:
+  HeapReference<Object> referent_;  // Note this is Java volatile:
+
+  friend struct art::ReferenceOffsets;  // for verifying offset information
+  DISALLOW_IMPLICIT_CONSTRUCTORS(Reference);
+};
+
+// C++ mirror of java.lang.ref.FinalizerReference
+class MANAGED FinalizerReference : public Reference {
+ public:
+  static MemberOffset ZombieOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(FinalizerReference, zombie_);
+  }
+
+  template<bool kTransactionActive>
+  void SetZombie(Object* zombie) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return SetFieldObject<kTransactionActive>(ZombieOffset(), zombie, true);
+  }
+  Object* GetZombie() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return GetFieldObject<Object>(ZombieOffset(), true);
+  }
+
+ private:
+  HeapReference<FinalizerReference> next_;
+  HeapReference<FinalizerReference> prev_;
+  HeapReference<Object> zombie_;
+
+  friend struct art::FinalizerReferenceOffsets;  // for verifying offset information
+  DISALLOW_IMPLICIT_CONSTRUCTORS(FinalizerReference);
+};
+
+}  // namespace mirror
+}  // namespace art
+
+#endif  // ART_RUNTIME_MIRROR_REFERENCE_H_