Add comment explaining ZGC check in RelativizeDerivedOopClosure

Author: stefank

src/hotspot/share/gc/z/zMark.cpp

@@ -282,7 +282,8 @@ void ZMark::follow_array_object(objArrayOop obj, bool finalizable) {
 
 void ZMark::follow_object(oop obj, bool finalizable) {
   if (ContinuationGCSupport::relativize_stack_chunk(obj)) {
-    // Loom doesn't support mixing of finalizable marking and strong marking of chunks
+    // Loom doesn't support mixing of finalizable marking and strong marking of
+    // stack chunks. See: RelativizeDerivedOopClosure.
     ZMarkBarrierOopClosure<false /* finalizable */> cl;
     obj->oop_iterate(&cl);
     return;

src/hotspot/share/oops/stackChunkOop.cpp

@@ -141,6 +141,18 @@ class RelativizeDerivedOopClosure : public DerivedOopClosure {
 
 #if INCLUDE_ZGC
     if (UseZGC) {
+      // This closure can be concurrently called from both GC marking and from
+      // the mutator. For it to work it is important that the old base value is
+      // used for the offset calculation below. As soon at the base oop has
+      // been updated we must *not* proceed to run the code below this check.
+      //
+      // This code only works if there's only one possible transition from old
+      // to good. This isn't necessarily for oops when objects are marked from
+      // finalizers. In that case oops can go from old to finalizable_marked
+      // to good. This breaks this check, because finalizable_marked are not
+      // considered good, but it's also not the old value. To workaround this
+      // we upgrade finalizable marking through stack chunks to be strong
+      // marking. See: ZMark::follow_object.
       if (ZAddress::is_good(cast_from_oop<uintptr_t>(base))) {
         return;
       }