src/hotspot/share/gc/shenandoah/shenandoahAsserts.hpp

rev 57589 : 8237632: Shenandoah fails some vmTestbase_nsk_jvmti tests with "Forwardee must point to a heap address"

@@ -67,55 +67,79 @@
   static void assert_rp_isalive_installed(const char *file, int line);
 
   static void assert_locked_or_shenandoah_safepoint(Mutex* lock, const char* file, int line);
 
 #ifdef ASSERT
+  // Shenandoah uses oop's marked pattern to indicate forwarding. Unfortunately, ObjectMarker (jvmtiTagMap.cpp)
+  // also uses this pattern to indicate visited.
+  // In ObjectMarker's destructor, it invokes heap iteration to reset the marked bits to their original values.
+  // That trips over many assertions on heap iteration code paths, but there are invariants:
+  //   1. Marked pattern in collection set indicates forwarding
+  //   2. Marked pattern off collection set indicates visited by ObjectMarker (because oops seen by
+  //      ObjectMarker were LRB'd)
+  //   3. No off collection set marked pattern at any shenandoah safepoint. In fact, no off collection set
+  //      marked pattern at any safepoints other than VM_HeapWalkOperation safepoints.
+  //      This is an important invariant, since traversal degenerated GC clears collection set before
+  //      entering degenerated GC cycle.
+  // So, we will need temporary disable assertions for oops with marked pattern outside collection set.
+  // Note: We only enforce this check for debug assertion to preserve full capacities of verifier,
+  //       because verifier always runs at safepoints.
+  static bool can_verify_oop(oop obj);
+
 #define shenandoah_assert_in_heap(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_in_heap(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_in_correct_region(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_in_correct_region(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_correct_if(interior_loc, obj, condition) \
-  if (condition)    ShenandoahAsserts::assert_correct(interior_loc, obj, __FILE__, __LINE__);
+  if (condition && ShenandoahAsserts::can_verify_oop(obj))    ShenandoahAsserts::assert_correct(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_correct_except(interior_loc, obj, exception) \
-  if (!(exception)) ShenandoahAsserts::assert_correct(interior_loc, obj, __FILE__, __LINE__);
+  if (!(exception) && ShenandoahAsserts::can_verify_oop(obj)) ShenandoahAsserts::assert_correct(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_correct(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_correct(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_forwarded_if(interior_loc, obj, condition) \
-  if (condition)    ShenandoahAsserts::assert_forwarded(interior_loc, obj, __FILE__, __LINE__);
+  if (condition && ShenandoahAsserts::can_verify_oop(obj))    ShenandoahAsserts::assert_forwarded(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_forwarded_except(interior_loc, obj, exception) \
-  if (!(exception)) ShenandoahAsserts::assert_forwarded(interior_loc, obj, __FILE__, __LINE__);
+  if (!(exception) && ShenandoahAsserts::can_verify_oop(obj)) ShenandoahAsserts::assert_forwarded(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_forwarded(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_forwarded(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_not_forwarded_if(interior_loc, obj, condition) \
-  if (condition)    ShenandoahAsserts::assert_not_forwarded(interior_loc, obj, __FILE__, __LINE__);
+  if (condition && ShenandoahAsserts::can_verify_oop(obj))    ShenandoahAsserts::assert_not_forwarded(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_not_forwarded_except(interior_loc, obj, exception) \
-  if (!(exception)) ShenandoahAsserts::assert_not_forwarded(interior_loc, obj, __FILE__, __LINE__);
+  if (!(exception) && ShenandoahAsserts::can_verify_oop(obj)) ShenandoahAsserts::assert_not_forwarded(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_not_forwarded(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_not_forwarded(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_marked_if(interior_loc, obj, condition) \
-  if (condition)    ShenandoahAsserts::assert_marked(interior_loc, obj, __FILE__, __LINE__);
+  if (condition && ShenandoahAsserts::can_verify_oop(obj))    ShenandoahAsserts::assert_marked(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_marked_except(interior_loc, obj, exception) \
-  if (!(exception)) ShenandoahAsserts::assert_marked(interior_loc, obj, __FILE__, __LINE__);
+  if (!(exception) && ShenandoahAsserts::can_verify_oop(obj)) ShenandoahAsserts::assert_marked(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_marked(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_marked(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_in_cset_if(interior_loc, obj, condition) \
-  if (condition)    ShenandoahAsserts::assert_in_cset(interior_loc, obj, __FILE__, __LINE__);
+  if (condition && ShenandoahAsserts::can_verify_oop(obj))    ShenandoahAsserts::assert_in_cset(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_in_cset_except(interior_loc, obj, exception) \
-  if (!(exception)) ShenandoahAsserts::assert_in_cset(interior_loc, obj, __FILE__, __LINE__);
+  if (!(exception) && ShenandoahAsserts::can_verify_oop(obj)) ShenandoahAsserts::assert_in_cset(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_in_cset(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_in_cset(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_not_in_cset_if(interior_loc, obj, condition) \
-  if (condition)    ShenandoahAsserts::assert_not_in_cset(interior_loc, obj, __FILE__, __LINE__);
+  if (condition && ShenandoahAsserts::can_verify_oop(obj))    ShenandoahAsserts::assert_not_in_cset(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_not_in_cset_except(interior_loc, obj, exception) \
-  if (!(exception)) ShenandoahAsserts::assert_not_in_cset(interior_loc, obj, __FILE__, __LINE__);
+  if (!(exception) && ShenandoahAsserts::can_verify_oop(obj)) ShenandoahAsserts::assert_not_in_cset(interior_loc, obj, __FILE__, __LINE__);
 #define shenandoah_assert_not_in_cset(interior_loc, obj) \
+                    if (ShenandoahAsserts::can_verify_oop(obj)) \
                     ShenandoahAsserts::assert_not_in_cset(interior_loc, obj, __FILE__, __LINE__);
 
 #define shenandoah_assert_not_in_cset_loc_if(interior_loc, condition) \
   if (condition)    ShenandoahAsserts::assert_not_in_cset_loc(interior_loc, __FILE__, __LINE__);
 #define shenandoah_assert_not_in_cset_loc_except(interior_loc, exception) \