jdk8-mips64-public/hotspot: comparison src/share/vm/oops/klass.cpp

-:882004b9e7e1
+:2c6ef90f030a
 #include "runtime/orderAccess.inline.hpp"
 #include "trace/traceMacros.hpp"
 #include "utilities/stack.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_ALL_GCS
+#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
 #endif // INCLUDE_ALL_GCS
 set_secondary_supers(NULL);
 set_secondary_super_cache(NULL);
 _primary_supers[0] = k;
 set_super_check_offset(in_bytes(primary_supers_offset()));
-set_java_mirror(NULL);
+// The constructor is used from init_self_patching_vtbl_list,
+// which doesn't zero out the memory before calling the constructor.
+// Need to set the field explicitly to not hit an assert that the field
+// should be NULL before setting it.
+_java_mirror = NULL;
 set_modifier_flags(0);
 set_layout_helper(Klass::_lh_neutral_value);
 set_name(NULL);
 AccessFlags af;
 af.set_flags(0);
 assert(!mirror_alive || loader_alive, "loader must be alive if the mirror is"
 " but not the other way around with anonymous classes");
 return mirror_alive;
 }
-void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive) {
+void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive, bool clean_alive_klasses) {
 if (!ClassUnloading) {
 return;
 }
 Klass* root = SystemDictionary::Object_klass();
 if (sibling != NULL) {
 stack.push(sibling);
 }
 // Clean the implementors list and method data.
-if (current->oop_is_instance()) {
+if (clean_alive_klasses && current->oop_is_instance()) {
 InstanceKlass* ik = InstanceKlass::cast(current);
 ik->clean_implementors_list(is_alive);
 ik->clean_method_data(is_alive);
 }
 }
 void Klass::klass_update_barrier_set(oop v) {
 record_modified_oops();
 }
-void Klass::klass_update_barrier_set_pre(void* p, oop v) {
+// This barrier is used by G1 to remember the old oop values, so
-// This barrier used by G1, where it's used remember the old oop values,
+// that we don't forget any objects that were live at the snapshot at
-// 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.
-// the beginning. This function is only used when we write oops into
+void Klass::klass_update_barrier_set_pre(oop* p, oop v) {
-// Klasses. Since the Klasses are used as roots in G1, we don't have to
+#if INCLUDE_ALL_GCS
-// do anything here.
+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((void*)p, v);
+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((void*)p, v);
+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) {

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/oops/klass.cpp

src/share/vm/oops/klass.cpp