src/hotspot/share/classfile/classLoaderDataGraph.cpp

*** 228,270 ****
    MutexLocker ml(ClassLoaderDataGraph_lock);
    ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);
    return loader_data;
  }
  
- void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
-   assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
-   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
-     cl->do_cld(cld);
-   }
- }
- 
  void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
    for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cl->do_cld(cld);
    }
  }
  
  void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
    for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
      CLDClosure* closure = cld->keep_alive() ? strong : weak;
      if (closure != NULL) {
        closure->do_cld(cld);
      }
    }
  }
  
! void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
    if (ClassUnloading) {
      roots_cld_do(cl, NULL);
    } else {
!     cld_do(cl);
    }
  }
  
  // Closure for locking and iterating through classes.
  LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {
--- 228,272 ----
    MutexLocker ml(ClassLoaderDataGraph_lock);
    ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);
    return loader_data;
  }
  
  void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
    // Only walk the head until any clds not purged from prior unloading
    // (CMS doesn't purge right away).
    for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
      assert(cld->is_unloading(), "invariant");
      cl->do_cld(cld);
    }
  }
  
+ // These are functions called by the GC, which require all of the CLDs, including the
+ // unloading ones.
+ void ClassLoaderDataGraph::cld_oops_do(CLDClosure* cl) {
+   assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
+   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
+     cl->do_cld(cld);
+   }
+ }
+ 
  void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
    for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
      CLDClosure* closure = cld->keep_alive() ? strong : weak;
      if (closure != NULL) {
        closure->do_cld(cld);
      }
    }
  }
  
! void ClassLoaderDataGraph::always_strong_cld_oops_do(CLDClosure* cl) {
    assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
    if (ClassUnloading) {
      roots_cld_do(cl, NULL);
    } else {
!     cld_oops_do(cl);
    }
  }
  
  // Closure for locking and iterating through classes.
  LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {
*** 284,296 ****
  class ClassLoaderDataGraphIterator : public StackObj {
    ClassLoaderData* _next;
    HandleMark       _hm;  // clean up handles when this is done.
    Handle           _holder;
    Thread*          _thread;
  
  public:
!   ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head) {
      _thread = Thread::current();
      assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    }
  
    ClassLoaderData* get_next() {
--- 286,301 ----
  class ClassLoaderDataGraphIterator : public StackObj {
    ClassLoaderData* _next;
    HandleMark       _hm;  // clean up handles when this is done.
    Handle           _holder;
    Thread*          _thread;
+   NoSafepointVerifier _nsv; // No safepoints allowed in this scope
+                             // unless verifying at a safepoint.
  
  public:
!   ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head),
!      _nsv(true, !SafepointSynchronize::is_at_safepoint()) {
      _thread = Thread::current();
      assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
    }
  
    ClassLoaderData* get_next() {
*** 306,318 ****
      } else {
        _next = NULL;
      }
      return cld;
    }
  
  
! };
  
  // These functions assume that the caller has locked the ClassLoaderDataGraph_lock
  // if they are not calling the function from a safepoint.
  void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
    ClassLoaderDataGraphIterator iter;
--- 311,339 ----
      } else {
        _next = NULL;
      }
      return cld;
    }
+ };
  
+ void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
+   ClassLoaderDataGraphIterator iter;
+   while (ClassLoaderData* cld = iter.get_next()) {
+     cl->do_cld(cld);
+   }
+ }
  
! void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
!   assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
!   if (ClassUnloading) {
!     // The keep_alive bits are only so GC doesn't unload the classes prematurely,
!     // not for tools to find.
!     cl->do_cld(ClassLoaderData::the_null_class_loader_data());
!   } else {
!     cld_do(cl);
!   }
! }
  
  // These functions assume that the caller has locked the ClassLoaderDataGraph_lock
  // if they are not calling the function from a safepoint.
  void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
    ClassLoaderDataGraphIterator iter;