1 files changed, 15 insertions, 28 deletions

diff --git a/runtime/gc/reference_processor.h b/runtime/gc/reference_processor.h
index 0f84211a87..51c50544bf 100644
--- a/runtime/gc/reference_processor.h
+++ b/runtime/gc/reference_processor.h
@@ -46,29 +46,19 @@ class Heap;
 class ReferenceProcessor {
  public:
   ReferenceProcessor();
-
-  // Initialize for a reference processing pass. Called before suspending weak
-  // access.
-  void Setup(Thread* self,
-             collector::GarbageCollector* collector,
-             bool concurrent,
-             bool clear_soft_references)
-      REQUIRES(!Locks::reference_processor_lock_);
-  // Enqueue all types of java.lang.ref.References, and mark through finalizers.
-  // Assumes there is no concurrent mutator-driven marking, i.e. all potentially
-  // mutator-accessible objects should be marked before this.
-  void ProcessReferences(Thread* self, TimingLogger* timings)
+  void ProcessReferences(bool concurrent,
+                         TimingLogger* timings,
+                         bool clear_soft_references,
+                         gc::collector::GarbageCollector* collector)
       REQUIRES_SHARED(Locks::mutator_lock_)
       REQUIRES(Locks::heap_bitmap_lock_)
       REQUIRES(!Locks::reference_processor_lock_);
-
   // The slow path bool is contained in the reference class object, can only be set once
   // Only allow setting this with mutators suspended so that we can avoid using a lock in the
   // GetReferent fast path as an optimization.
   void EnableSlowPath() REQUIRES_SHARED(Locks::mutator_lock_);
   void BroadcastForSlowPath(Thread* self);
-  // Decode the referent, may block if references are being processed. In the normal
-  // no-read-barrier or Baker-read-barrier cases, we assume reference is not a PhantomReference.
+  // Decode the referent, may block if references are being processed.
   ObjPtr<mirror::Object> GetReferent(Thread* self, ObjPtr<mirror::Reference> reference)
       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Locks::reference_processor_lock_);
   // Collects the cleared references and returns a task, to be executed after FinishGC, that will
@@ -88,30 +78,27 @@ class ReferenceProcessor {
   void ClearReferent(ObjPtr<mirror::Reference> ref)
       REQUIRES_SHARED(Locks::mutator_lock_)
       REQUIRES(!Locks::reference_processor_lock_);
-  uint32_t ForwardSoftReferences(TimingLogger* timings)
-      REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
   bool SlowPathEnabled() REQUIRES_SHARED(Locks::mutator_lock_);
   // Called by ProcessReferences.
   void DisableSlowPath(Thread* self) REQUIRES(Locks::reference_processor_lock_)
       REQUIRES_SHARED(Locks::mutator_lock_);
+  // If we are preserving references it means that some dead objects may become live, we use start
+  // and stop preserving to block mutators using GetReferrent from getting access to these
+  // referents.
+  void StartPreservingReferences(Thread* self) REQUIRES(!Locks::reference_processor_lock_);
+  void StopPreservingReferences(Thread* self) REQUIRES(!Locks::reference_processor_lock_);
   // Wait until reference processing is done.
   void WaitUntilDoneProcessingReferences(Thread* self)
       REQUIRES_SHARED(Locks::mutator_lock_)
       REQUIRES(Locks::reference_processor_lock_);
   // Collector which is clearing references, used by the GetReferent to return referents which are
-  // already marked. Only updated by thread currently running GC.
-  // Guarded by reference_processor_lock_ when not read by collector. Only the collector changes
-  // it.
-  collector::GarbageCollector* collector_;
-  // Reference processor state. Only valid while weak reference processing is suspended.
-  // Used by GetReferent and friends to return early.
-  enum class RpState : uint8_t { kStarting, kInitMarkingDone, kInitClearingDone };
-  RpState rp_state_ GUARDED_BY(Locks::reference_processor_lock_);
-  bool concurrent_;  // Running concurrently with mutator? Only used by GC thread.
-  bool clear_soft_references_;  // Only used by GC thread.
-
+  // already marked.
+  collector::GarbageCollector* collector_ GUARDED_BY(Locks::reference_processor_lock_);
+  // Boolean for whether or not we are preserving references (either soft references or finalizers).
+  // If this is true, then we cannot return a referent (see comment in GetReferent).
+  bool preserving_references_ GUARDED_BY(Locks::reference_processor_lock_);
   // Condition that people wait on if they attempt to get the referent of a reference while
   // processing is in progress. Broadcast when an empty checkpoint is requested, but not for other
   // checkpoints or thread suspensions. See mutator_gc_coord.md.