src/hotspot/share/classfile/classFileParser.cpp
changeset 53338 5afdd1100a20
parent 53023 6879069d9d94
parent 53333 fd6de53a0d6e
child 53435 ea254e9fc587
child 54553 62771002a1cb
equal deleted inserted replaced
53305:d193d58ae79d 53338:5afdd1100a20
  4484     const jint lh = Klass::instance_layout_helper(ik->size_helper(), true);
  4484     const jint lh = Klass::instance_layout_helper(ik->size_helper(), true);
  4485     ik->set_layout_helper(lh);
  4485     ik->set_layout_helper(lh);
  4486   }
  4486   }
  4487 }
  4487 }
  4488 
  4488 
  4489 // Attach super classes and interface classes to class loader data
       
  4490 static void record_defined_class_dependencies(const InstanceKlass* defined_klass,
       
  4491                                               TRAPS) {
       
  4492   assert(defined_klass != NULL, "invariant");
       
  4493 
       
  4494   ClassLoaderData* const defining_loader_data = defined_klass->class_loader_data();
       
  4495   if (defining_loader_data->is_the_null_class_loader_data()) {
       
  4496       // Dependencies to null class loader data are implicit.
       
  4497       return;
       
  4498   } else {
       
  4499     // add super class dependency
       
  4500     Klass* const super = defined_klass->super();
       
  4501     if (super != NULL) {
       
  4502       defining_loader_data->record_dependency(super);
       
  4503     }
       
  4504 
       
  4505     // add super interface dependencies
       
  4506     const Array<InstanceKlass*>* const local_interfaces = defined_klass->local_interfaces();
       
  4507     if (local_interfaces != NULL) {
       
  4508       const int length = local_interfaces->length();
       
  4509       for (int i = 0; i < length; i++) {
       
  4510         defining_loader_data->record_dependency(local_interfaces->at(i));
       
  4511       }
       
  4512     }
       
  4513   }
       
  4514 }
       
  4515 
       
  4516 // utility methods for appending an array with check for duplicates
  4489 // utility methods for appending an array with check for duplicates
  4517 
  4490 
  4518 static void append_interfaces(GrowableArray<InstanceKlass*>* result,
  4491 static void append_interfaces(GrowableArray<InstanceKlass*>* result,
  4519                               const Array<InstanceKlass*>* const ifs) {
  4492                               const Array<InstanceKlass*>* const ifs) {
  4520   // iterate over new interfaces
  4493   // iterate over new interfaces
  5716     if (!module_entry->set_has_default_read_edges()) {
  5689     if (!module_entry->set_has_default_read_edges()) {
  5717       // We won a potential race
  5690       // We won a potential race
  5718       JvmtiExport::add_default_read_edges(module_handle, THREAD);
  5691       JvmtiExport::add_default_read_edges(module_handle, THREAD);
  5719     }
  5692     }
  5720   }
  5693   }
  5721 
       
  5722   // Update the loader_data graph.
       
  5723   record_defined_class_dependencies(ik, CHECK);
       
  5724 
  5694 
  5725   ClassLoadingService::notify_class_loaded(ik, false /* not shared class */);
  5695   ClassLoadingService::notify_class_loaded(ik, false /* not shared class */);
  5726 
  5696 
  5727   if (!is_internal()) {
  5697   if (!is_internal()) {
  5728     if (log_is_enabled(Info, class, load)) {
  5698     if (log_is_enabled(Info, class, load)) {