jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceRefKlass.cpp

equal deleted inserted replaced

-:aa8c9eb6d900
+:d67be49a5beb
 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
 #include "oops/oop.pcgc.inline.hpp"
 #endif
 template <class T>
-void specialized_oop_follow_contents(instanceRefKlass* ref, oop obj) {
+void specialized_oop_follow_contents(InstanceRefKlass* ref, oop obj) {
 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
 T heap_oop = oopDesc::load_heap_oop(referent_addr);
 debug_only(
 if(TraceReferenceGC && PrintGCDetails) {
-gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
+gclog_or_tty->print_cr("InstanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
 }
 )
 if (!oopDesc::is_null(heap_oop)) {
 oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
 if (!referent->is_gc_marked() &&
 )
 MarkSweep::mark_and_push(next_addr);
 ref->InstanceKlass::oop_follow_contents(obj);
 }
-void instanceRefKlass::oop_follow_contents(oop obj) {
+void InstanceRefKlass::oop_follow_contents(oop obj) {
 if (UseCompressedOops) {
 specialized_oop_follow_contents<narrowOop>(this, obj);
 } else {
 specialized_oop_follow_contents<oop>(this, obj);
 }
 }
 #ifndef SERIALGC
 template <class T>
-void specialized_oop_follow_contents(instanceRefKlass* ref,
+void specialized_oop_follow_contents(InstanceRefKlass* ref,
 ParCompactionManager* cm,
 oop obj) {
 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
 T heap_oop = oopDesc::load_heap_oop(referent_addr);
 debug_only(
 if(TraceReferenceGC && PrintGCDetails) {
-gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
+gclog_or_tty->print_cr("InstanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
 }
 )
 if (!oopDesc::is_null(heap_oop)) {
 oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
 if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
 }
 PSParallelCompact::mark_and_push(cm, next_addr);
 ref->InstanceKlass::oop_follow_contents(cm, obj);
 }
-void instanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
+void InstanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
 oop obj) {
 if (UseCompressedOops) {
 specialized_oop_follow_contents<narrowOop>(this, cm, obj);
 } else {
 specialized_oop_follow_contents<oop>(this, cm, obj);
 (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL);
 }
 }
 #endif
-template <class T> void specialized_oop_adjust_pointers(instanceRefKlass *ref, oop obj) {
+template <class T> void specialized_oop_adjust_pointers(InstanceRefKlass *ref, oop obj) {
 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
 MarkSweep::adjust_pointer(referent_addr);
 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
 MarkSweep::adjust_pointer(next_addr);
 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
 MarkSweep::adjust_pointer(discovered_addr);
-debug_only(trace_reference_gc("instanceRefKlass::oop_adjust_pointers", obj,
+debug_only(trace_reference_gc("InstanceRefKlass::oop_adjust_pointers", obj,
 referent_addr, next_addr, discovered_addr);)
 }
-int instanceRefKlass::oop_adjust_pointers(oop obj) {
+int InstanceRefKlass::oop_adjust_pointers(oop obj) {
 int size = size_helper();
 InstanceKlass::oop_adjust_pointers(obj);
 if (UseCompressedOops) {
 specialized_oop_adjust_pointers<narrowOop>(this, obj);
 return size;                                                                  \
 template <class T> bool contains(T *t) { return true; }
-// Macro to define instanceRefKlass::oop_oop_iterate for virtual/nonvirtual for
+// Macro to define InstanceRefKlass::oop_oop_iterate for virtual/nonvirtual for
 // all closures.  Macros calling macros above for each oop size.
 #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)        \
 \
-int instanceRefKlass::                                                          \
+int InstanceRefKlass::                                                          \
 oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) {                  \
 /* Get size before changing pointers */                                       \
 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
 \
 int size = InstanceKlass::oop_oop_iterate##nv_suffix(obj, closure);           \
 }
 #ifndef SERIALGC
 #define InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
 \
-int instanceRefKlass::                                                          \
+int InstanceRefKlass::                                                          \
 oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) {        \
 /* Get size before changing pointers */                                       \
 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
 \
 int size = InstanceKlass::oop_oop_iterate_backwards##nv_suffix(obj, closure); \
 #endif // !SERIALGC
 #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)      \
 \
-int instanceRefKlass::                                                          \
+int InstanceRefKlass::                                                          \
 oop_oop_iterate##nv_suffix##_m(oop obj,                                         \
 OopClosureType* closure,                         \
 MemRegion mr) {                                  \
 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
 \
 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
 #ifndef SERIALGC
 template <class T>
-void specialized_oop_push_contents(instanceRefKlass *ref,
+void specialized_oop_push_contents(InstanceRefKlass *ref,
 PSPromotionManager* pm, oop obj) {
 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
 if (PSScavenge::should_scavenge(referent_addr)) {
 ReferenceProcessor* rp = PSScavenge::reference_processor();
 if (rp->discover_reference(obj, ref->reference_type())) {
 pm->claim_or_forward_depth(next_addr);
 }
 ref->InstanceKlass::oop_push_contents(pm, obj);
 }
-void instanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
+void InstanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
 if (UseCompressedOops) {
 specialized_oop_push_contents<narrowOop>(this, pm, obj);
 } else {
 specialized_oop_push_contents<oop>(this, pm, obj);
 }
 }
 template <class T>
-void specialized_oop_update_pointers(instanceRefKlass *ref,
+void specialized_oop_update_pointers(InstanceRefKlass *ref,
 ParCompactionManager* cm, oop obj) {
 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
 PSParallelCompact::adjust_pointer(referent_addr);
 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
 PSParallelCompact::adjust_pointer(next_addr);
 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
 PSParallelCompact::adjust_pointer(discovered_addr);
-debug_only(trace_reference_gc("instanceRefKlass::oop_update_ptrs", obj,
+debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
 referent_addr, next_addr, discovered_addr);)
 }
-int instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
+int InstanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
 InstanceKlass::oop_update_pointers(cm, obj);
 if (UseCompressedOops) {
 specialized_oop_update_pointers<narrowOop>(this, cm, obj);
 } else {
 specialized_oop_update_pointers<oop>(this, cm, obj);
 }
 return size_helper();
 }
 #endif // SERIALGC
-void instanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
+void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
 // Clear the nonstatic oop-map entries corresponding to referent
 // and nextPending field.  They are treated specially by the
 // garbage collector.
 // The discovered field is used only by the garbage collector
 // and is also treated specially.
 }
 // Verification
-void instanceRefKlass::oop_verify_on(oop obj, outputStream* st) {
+void InstanceRefKlass::oop_verify_on(oop obj, outputStream* st) {
 InstanceKlass::oop_verify_on(obj, st);
 // Verify referent field
 oop referent = java_lang_ref_Reference::referent(obj);
 // We should make this general to all heaps
 guarantee(next->is_oop(), "next field verify failed");
 guarantee(next->is_instanceRef(), "next field verify failed");
 }
 }
-bool instanceRefKlass::owns_pending_list_lock(JavaThread* thread) {
+bool InstanceRefKlass::owns_pending_list_lock(JavaThread* thread) {
 if (java_lang_ref_Reference::pending_list_lock() == NULL) return false;
 Handle h_lock(thread, java_lang_ref_Reference::pending_list_lock());
 return ObjectSynchronizer::current_thread_holds_lock(thread, h_lock);
 }
-void instanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {
+void InstanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {
 // we may enter this with pending exception set
 PRESERVE_EXCEPTION_MARK;  // exceptions are never thrown, needed for TRAPS argument
 // Create a HandleMark in case we retry a GC multiple times.
 // Each time we attempt the GC, we allocate the handle below
 JavaThread::current(), h_lock),
 "Locking should have succeeded");
 if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;
 }
-void instanceRefKlass::release_and_notify_pending_list_lock(
+void InstanceRefKlass::release_and_notify_pending_list_lock(
 BasicLock *pending_list_basic_lock) {
 // we may enter this with pending exception set
 PRESERVE_EXCEPTION_MARK;  // exceptions are never thrown, needed for TRAPS argument
 // Create a HandleMark in case we retry a GC multiple times.

changeset 13738	d67be49a5beb
parent 13728	882756847a04
child 15482	470d0b0c09f1