src/share/vm/oops/klass.cpp

rev 12906 : [mq]: gc_interface

*** 34,51 ****
  #include "memory/oopFactory.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/instanceKlass.hpp"
  #include "oops/klass.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/atomic.hpp"
  #include "runtime/orderAccess.inline.hpp"
  #include "trace/traceMacros.hpp"
  #include "utilities/macros.hpp"
  #include "utilities/stack.inline.hpp"
- #if INCLUDE_ALL_GCS
- #include "gc/g1/g1SATBCardTableModRefBS.hpp"
- #endif // INCLUDE_ALL_GCS
  
  bool Klass::is_cloneable() const {
    return _access_flags.is_cloneable_fast() ||
           is_subtype_of(SystemDictionary::Cloneable_klass());
  }
--- 34,49 ----
  #include "memory/oopFactory.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/instanceKlass.hpp"
  #include "oops/klass.inline.hpp"
  #include "oops/oop.inline.hpp"
+ #include "runtime/access.inline.hpp"
  #include "runtime/atomic.hpp"
  #include "runtime/orderAccess.inline.hpp"
  #include "trace/traceMacros.hpp"
  #include "utilities/macros.hpp"
  #include "utilities/stack.inline.hpp"
  
  bool Klass::is_cloneable() const {
    return _access_flags.is_cloneable_fast() ||
           is_subtype_of(SystemDictionary::Cloneable_klass());
  }
*** 438,486 ****
        }
      }
    }
  }
  
! void Klass::klass_update_barrier_set(oop v) {
!   record_modified_oops();
! }
! 
! // This barrier is used by G1 to remember the old oop values, so
! // that we don't forget any objects that were live at the snapshot at
! // the beginning. This function is only used when we write oops into Klasses.
! void Klass::klass_update_barrier_set_pre(oop* p, oop v) {
! #if INCLUDE_ALL_GCS
!   if (UseG1GC) {
!     oop obj = *p;
!     if (obj != NULL) {
!       G1SATBCardTableModRefBS::enqueue(obj);
!     }
!   }
! #endif
! }
! 
! void Klass::klass_oop_store(oop* p, oop v) {
!   assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
!   assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
! 
!   // do the store
!   if (always_do_update_barrier) {
!     klass_oop_store((volatile oop*)p, v);
!   } else {
!     klass_update_barrier_set_pre(p, v);
!     *p = v;
!     klass_update_barrier_set(v);
!   }
! }
! 
! void Klass::klass_oop_store(volatile oop* p, oop v) {
!   assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
!   assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
! 
!   klass_update_barrier_set_pre((oop*)p, v); // Cast away volatile.
!   OrderAccess::release_store_ptr(p, v);
!   klass_update_barrier_set(v);
  }
  
  void Klass::oops_do(OopClosure* cl) {
    cl->do_oop(&_java_mirror);
  }
--- 436,447 ----
        }
      }
    }
  }
  
! void Klass::set_java_mirror(oop m) {
!   KlassAccess<MO_RELEASE>::oop_store_at(this, in_bytes(java_mirror_offset()), m);
  }
  
  void Klass::oops_do(OopClosure* cl) {
    cl->do_oop(&_java_mirror);
  }
*** 565,574 ****
--- 526,543 ----
    return NULL;
  }
  
  oop Klass::class_loader() const       { return class_loader_data()->class_loader(); }
  
+ oop* Klass::klass_holder_addr() const {
+   return class_loader_data()->class_loader_addr();
+ }
+ 
+ oop Klass::klass_holder() const {
+   return RootAccess<GC_ACCESS_ON_PHANTOM>::oop_load(klass_holder_addr());
+ }
+ 
  // In product mode, this function doesn't have virtual function calls so
  // there might be some performance advantage to handling InstanceKlass here.
  const char* Klass::external_name() const {
    if (is_instance_klass()) {
      const InstanceKlass* ik = static_cast<const InstanceKlass*>(this);