4567 ClassLoaderData* const defining_loader_data = defined_klass->class_loader_data();
4568 if (defining_loader_data->is_the_null_class_loader_data()) {
4569 // Dependencies to null class loader data are implicit.
4570 return;
4571 } else {
4572 // add super class dependency
4573 Klass* const super = defined_klass->super();
4574 if (super != NULL) {
4575 defining_loader_data->record_dependency(super, CHECK);
4576 }
4577
4578 // add super interface dependencies
4579 const Array<Klass*>* const local_interfaces = defined_klass->local_interfaces();
4580 if (local_interfaces != NULL) {
4581 const int length = local_interfaces->length();
4582 for (int i = 0; i < length; i++) {
4583 defining_loader_data->record_dependency(local_interfaces->at(i), CHECK);
4584 }
4585 }
4586
4587 for (FieldStream st((InstanceKlass*)defined_klass, false, false); !st.eos(); st.next()) {
4588 Symbol* signature = st.signature();
4589 if (signature->starts_with("Q")) {
4590 Klass* klass = SystemDictionary::resolve_or_fail(signature,
4591 Handle(THREAD, defined_klass->class_loader()),
4592 Handle(THREAD, defined_klass->protection_domain()), true, CHECK);
4593 assert(klass != NULL, "Sanity check");
4594 assert(klass->access_flags().is_value_type(), "Value type expected");
4595 defining_loader_data->record_dependency(klass, CHECK);
4596 }
4597 }
4598 }
4599 }
4600
4601 // utility methods for appending an array with check for duplicates
4602
4603 static void append_interfaces(GrowableArray<Klass*>* result,
4604 const Array<Klass*>* const ifs) {
4605 // iterate over new interfaces
4606 for (int i = 0; i < ifs->length(); i++) {
4607 Klass* const e = ifs->at(i);
4608 assert(e->is_klass() && InstanceKlass::cast(e)->is_interface(), "just checking");
4609 // add new interface
4610 result->append_if_missing(e);
4611 }
4612 }
4613
4614 static Array<Klass*>* compute_transitive_interfaces(const InstanceKlass* super,
5723 ValueKlass* vk = ValueKlass::cast(ik);
5724 vk->set_if_bufferable();
5725 vk->initialize_calling_convention();
5726 }
5727
5728 // Valhalla shady value type conversion
5729 if (_parsed_annotations->is_value_capable_class()) {
5730 ik->create_value_capable_class(Handle(THREAD, _loader_data->class_loader()),
5731 _protection_domain, CHECK);
5732 }
5733
5734 // Add read edges to the unnamed modules of the bootstrap and app class loaders.
5735 if (changed_by_loadhook && !module_handle.is_null() && module_entry->is_named() &&
5736 !module_entry->has_default_read_edges()) {
5737 if (!module_entry->set_has_default_read_edges()) {
5738 // We won a potential race
5739 JvmtiExport::add_default_read_edges(module_handle, THREAD);
5740 }
5741 }
5742
5743 // Update the loader_data graph.
5744 record_defined_class_dependencies(ik, CHECK);
5745
5746 for(int i = 0; i < ik->java_fields_count(); i++) {
5747 if (ik->field_signature(i)->starts_with("Q")) {
5748 Klass* klass = SystemDictionary::resolve_or_fail(ik->field_signature(i),
5749 Handle(THREAD, ik->class_loader()),
5750 Handle(THREAD, ik->protection_domain()), true, CHECK);
5751 assert(klass != NULL, "Sanity check");
5752 assert(klass->access_flags().is_value_type(), "Value type expected");
5753 ik->set_value_field_klass(i, klass);
5754 }
5755 }
5756
5757 ClassLoadingService::notify_class_loaded(ik, false /* not shared class */);
5758
5759 if (!is_internal()) {
5760 if (log_is_enabled(Info, class, load)) {
5761 ResourceMark rm;
5762 const char* module_name = (module_entry->name() == NULL) ? UNNAMED_MODULE : module_entry->name()->as_C_string();
5763 ik->print_class_load_logging(_loader_data, module_name, _stream);
5764 }
5765
5766 if (log_is_enabled(Debug, class, resolve)) {
5767 ResourceMark rm;
5768 // print out the superclass.
5769 const char * from = ik->external_name();
5770 if (ik->java_super() != NULL) {
5771 log_debug(class, resolve)("%s %s (super)",
5772 from,
5773 ik->java_super()->external_name());
5774 }
5775 // print out each of the interface classes referred to by this class.
|
4567 ClassLoaderData* const defining_loader_data = defined_klass->class_loader_data();
4568 if (defining_loader_data->is_the_null_class_loader_data()) {
4569 // Dependencies to null class loader data are implicit.
4570 return;
4571 } else {
4572 // add super class dependency
4573 Klass* const super = defined_klass->super();
4574 if (super != NULL) {
4575 defining_loader_data->record_dependency(super, CHECK);
4576 }
4577
4578 // add super interface dependencies
4579 const Array<Klass*>* const local_interfaces = defined_klass->local_interfaces();
4580 if (local_interfaces != NULL) {
4581 const int length = local_interfaces->length();
4582 for (int i = 0; i < length; i++) {
4583 defining_loader_data->record_dependency(local_interfaces->at(i), CHECK);
4584 }
4585 }
4586
4587 for(int i = 0; i < defined_klass->java_fields_count(); i++) {
4588 if (defined_klass->field_signature(i)->starts_with("Q") && (((defined_klass->field_access_flags(i) & JVM_ACC_STATIC)) == 0)) {
4589 const Klass* klass = defined_klass->get_value_field_klass(i);
4590 defining_loader_data->record_dependency(klass, CHECK);
4591 }
4592 }
4593 }
4594 }
4595
4596 // utility methods for appending an array with check for duplicates
4597
4598 static void append_interfaces(GrowableArray<Klass*>* result,
4599 const Array<Klass*>* const ifs) {
4600 // iterate over new interfaces
4601 for (int i = 0; i < ifs->length(); i++) {
4602 Klass* const e = ifs->at(i);
4603 assert(e->is_klass() && InstanceKlass::cast(e)->is_interface(), "just checking");
4604 // add new interface
4605 result->append_if_missing(e);
4606 }
4607 }
4608
4609 static Array<Klass*>* compute_transitive_interfaces(const InstanceKlass* super,
5718 ValueKlass* vk = ValueKlass::cast(ik);
5719 vk->set_if_bufferable();
5720 vk->initialize_calling_convention();
5721 }
5722
5723 // Valhalla shady value type conversion
5724 if (_parsed_annotations->is_value_capable_class()) {
5725 ik->create_value_capable_class(Handle(THREAD, _loader_data->class_loader()),
5726 _protection_domain, CHECK);
5727 }
5728
5729 // Add read edges to the unnamed modules of the bootstrap and app class loaders.
5730 if (changed_by_loadhook && !module_handle.is_null() && module_entry->is_named() &&
5731 !module_entry->has_default_read_edges()) {
5732 if (!module_entry->set_has_default_read_edges()) {
5733 // We won a potential race
5734 JvmtiExport::add_default_read_edges(module_handle, THREAD);
5735 }
5736 }
5737
5738 for(int i = 0; i < ik->java_fields_count(); i++) {
5739 if (ik->field_signature(i)->starts_with("Q") && (((ik->field_access_flags(i) & JVM_ACC_STATIC)) == 0)) {
5740 Klass* klass = SystemDictionary::resolve_or_fail(ik->field_signature(i),
5741 Handle(THREAD, ik->class_loader()),
5742 Handle(THREAD, ik->protection_domain()), true, CHECK);
5743 assert(klass != NULL, "Sanity check");
5744 assert(klass->access_flags().is_value_type(), "Value type expected");
5745 ik->set_value_field_klass(i, klass);
5746 }
5747 }
5748
5749 // Update the loader_data graph.
5750 record_defined_class_dependencies(ik, CHECK);
5751
5752 ClassLoadingService::notify_class_loaded(ik, false /* not shared class */);
5753
5754 if (!is_internal()) {
5755 if (log_is_enabled(Info, class, load)) {
5756 ResourceMark rm;
5757 const char* module_name = (module_entry->name() == NULL) ? UNNAMED_MODULE : module_entry->name()->as_C_string();
5758 ik->print_class_load_logging(_loader_data, module_name, _stream);
5759 }
5760
5761 if (log_is_enabled(Debug, class, resolve)) {
5762 ResourceMark rm;
5763 // print out the superclass.
5764 const char * from = ik->external_name();
5765 if (ik->java_super() != NULL) {
5766 log_debug(class, resolve)("%s %s (super)",
5767 from,
5768 ik->java_super()->external_name());
5769 }
5770 // print out each of the interface classes referred to by this class.
|