void InstanceMirrorKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) { InstanceKlass::oop_pc_follow_contents(obj, cm); // Follow the klass field in the mirror. Klass* klass = java_lang_Class::as_Klass(obj); if (klass != NULL) { // An anonymous class doesn't have its own class loader, so the call // to follow_klass will mark and push its java mirror instead of the // class loader. When handling the java mirror for an anonymous class // we need to make sure its class loader data is claimed, this is done // by calling follow_class_loader explicitly. For non-anonymous classes // the call to follow_class_loader is made when the class loader itself // is handled. if (klass->is_instance_klass() && InstanceKlass::cast(klass)->is_anonymous()) { cm->follow_class_loader(klass->class_loader_data()); } else { cm->follow_klass(klass); } } else { // If klass is NULL then this a mirror for a primitive type. // We don't have to follow them, since they are handled as strong // roots in Universe::oops_do. assert(java_lang_Class::is_primitive(obj), "Sanity check"); } ParCompactionManager::MarkAndPushClosure cl(cm); oop_oop_iterate_statics<true>(obj, &cl); }
void ClassLoaderData::verify() { oop cl = class_loader(); guarantee(this == class_loader_data(cl) || is_anonymous(), "Must be the same"); guarantee(cl != NULL || this == ClassLoaderData::the_null_class_loader_data() || is_anonymous(), "must be"); // Verify the integrity of the allocated space. if (metaspace_or_null() != NULL) { metaspace_or_null()->verify(); } for (Klass* k = _klasses; k != NULL; k = k->next_link()) { guarantee(k->class_loader_data() == this, "Must be the same"); k->verify(); assert(k != k->next_link(), "no loops!"); } }