src/hotspot/share/classfile/classLoaderDataGraph.cpp

*** 228,254 ****
    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) {
--- 228,256 ----
    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_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) {
*** 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,319 ****
      } 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;
    while (ClassLoaderData* cld = iter.get_next()) {
--- 311,329 ----
      } else {
        _next = NULL;
      }
      return cld;
    }
  };
  
+ void ClassLoaderDataGraph::loaded_cld_do(CLDClosure* cl) {
+   ClassLoaderDataGraphIterator iter;
+   while (ClassLoaderData* cld = iter.get_next()) {
+     cl->do_cld(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;
    while (ClassLoaderData* cld = iter.get_next()) {