< prev index next >

src/hotspot/share/classfile/klassFactory.cpp

Print this page




  66     JvmtiExport::post_class_file_load_hook(class_name,
  67                                            class_loader,
  68                                            protection_domain,
  69                                            &ptr,
  70                                            &end_ptr,
  71                                            &cached_class_file);
  72     if (old_ptr != ptr) {
  73       // JVMTI agent has modified class file data.
  74       // Set new class file stream using JVMTI agent modified class file data.
  75       ClassLoaderData* loader_data =
  76         ClassLoaderData::class_loader_data(class_loader());
  77       int path_index = ik->shared_classpath_index();
  78       ClassFileStream* stream = new ClassFileStream(ptr,
  79                                                     end_ptr - ptr,
  80                                                     cfs->source(),
  81                                                     ClassFileStream::verify);
  82       ClassFileParser parser(stream,
  83                              class_name,
  84                              loader_data,
  85                              protection_domain,
  86                              NULL,
  87                              NULL,


  88                              ClassFileParser::BROADCAST, // publicity level
  89                              CHECK_NULL);
  90       InstanceKlass* new_ik = parser.create_instance_klass(true /* changed_by_loadhook */,


  91                                                            CHECK_NULL);

  92       if (cached_class_file != NULL) {
  93         new_ik->set_cached_class_file(cached_class_file);
  94       }
  95 
  96       if (class_loader.is_null()) {
  97         ResourceMark rm;
  98         ClassLoader::add_package(class_name->as_C_string(), path_index, THREAD);
  99       }
 100 
 101       return new_ik;
 102     }
 103   }
 104 #endif
 105 
 106   return NULL;
 107 }
 108 
 109 
 110 static ClassFileStream* check_class_file_load_hook(ClassFileStream* stream,
 111                                                    Symbol* name,


 152     if (ptr != stream->buffer()) {
 153       // JVMTI agent has modified class file data.
 154       // Set new class file stream using JVMTI agent modified class file data.
 155       stream = new ClassFileStream(ptr,
 156                                    end_ptr - ptr,
 157                                    stream->source(),
 158                                    stream->need_verify());
 159     }
 160   }
 161 
 162   return stream;
 163 }
 164 
 165 
 166 InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
 167                                                 Symbol* name,
 168                                                 ClassLoaderData* loader_data,
 169                                                 Handle protection_domain,
 170                                                 const InstanceKlass* unsafe_anonymous_host,
 171                                                 GrowableArray<Handle>* cp_patches,




 172                                                 TRAPS) {
 173   assert(stream != NULL, "invariant");
 174   assert(loader_data != NULL, "invariant");
 175   assert(THREAD->is_Java_thread(), "must be a JavaThread");
 176 
 177   ResourceMark rm;
 178   HandleMark hm;
 179 
 180   JvmtiCachedClassFileData* cached_class_file = NULL;
 181 
 182   ClassFileStream* old_stream = stream;
 183 
 184   // increment counter
 185   THREAD->statistical_info().incr_define_class_count();
 186 
 187   // Skip this processing for VM anonymous classes
 188   if (unsafe_anonymous_host == NULL) {



 189     stream = check_class_file_load_hook(stream,
 190                                         name,
 191                                         loader_data,
 192                                         protection_domain,
 193                                         &cached_class_file,
 194                                         CHECK_NULL);
 195   }
 196 
 197   ClassFileParser parser(stream,
 198                          name,
 199                          loader_data,
 200                          protection_domain,
 201                          unsafe_anonymous_host,
 202                          cp_patches,


 203                          ClassFileParser::BROADCAST, // publicity level
 204                          CHECK_NULL);
 205 
 206   InstanceKlass* result = parser.create_instance_klass(old_stream != stream, CHECK_NULL);
 207   assert(result == parser.create_instance_klass(old_stream != stream, THREAD), "invariant");
 208 
 209   if (result == NULL) {
 210     return NULL;
 211   }
 212 
 213   if (cached_class_file != NULL) {
 214     // JVMTI: we have an InstanceKlass now, tell it about the cached bytes
 215     result->set_cached_class_file(cached_class_file);
 216   }
 217 
 218   JFR_ONLY(ON_KLASS_CREATION(result, parser, THREAD);)
 219 
 220 #if INCLUDE_CDS
 221   if (DumpSharedSpaces) {
 222     ClassLoader::record_result(result, stream, THREAD);
 223   }
 224 #endif // INCLUDE_CDS
 225 
 226   return result;
 227 }


  66     JvmtiExport::post_class_file_load_hook(class_name,
  67                                            class_loader,
  68                                            protection_domain,
  69                                            &ptr,
  70                                            &end_ptr,
  71                                            &cached_class_file);
  72     if (old_ptr != ptr) {
  73       // JVMTI agent has modified class file data.
  74       // Set new class file stream using JVMTI agent modified class file data.
  75       ClassLoaderData* loader_data =
  76         ClassLoaderData::class_loader_data(class_loader());
  77       int path_index = ik->shared_classpath_index();
  78       ClassFileStream* stream = new ClassFileStream(ptr,
  79                                                     end_ptr - ptr,
  80                                                     cfs->source(),
  81                                                     ClassFileStream::verify);
  82       ClassFileParser parser(stream,
  83                              class_name,
  84                              loader_data,
  85                              protection_domain,
  86                              NULL,  // unsafe_anonymous_host
  87                              NULL,  // cp_patches
  88                              false, // is_nonfindable
  89                              false, // can_access_vm_annotations
  90                              ClassFileParser::BROADCAST, // publicity level
  91                              CHECK_NULL);
  92       InstanceKlass* new_ik = parser.create_instance_klass(true, // changed_by_loadhook
  93                                                            NULL,  // dynamic_nest_host
  94                                                            Handle(), // classData
  95                                                            CHECK_NULL);
  96 
  97       if (cached_class_file != NULL) {
  98         new_ik->set_cached_class_file(cached_class_file);
  99       }
 100 
 101       if (class_loader.is_null()) {
 102         ResourceMark rm;
 103         ClassLoader::add_package(class_name->as_C_string(), path_index, THREAD);
 104       }
 105 
 106       return new_ik;
 107     }
 108   }
 109 #endif
 110 
 111   return NULL;
 112 }
 113 
 114 
 115 static ClassFileStream* check_class_file_load_hook(ClassFileStream* stream,
 116                                                    Symbol* name,


 157     if (ptr != stream->buffer()) {
 158       // JVMTI agent has modified class file data.
 159       // Set new class file stream using JVMTI agent modified class file data.
 160       stream = new ClassFileStream(ptr,
 161                                    end_ptr - ptr,
 162                                    stream->source(),
 163                                    stream->need_verify());
 164     }
 165   }
 166 
 167   return stream;
 168 }
 169 
 170 
 171 InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
 172                                                 Symbol* name,
 173                                                 ClassLoaderData* loader_data,
 174                                                 Handle protection_domain,
 175                                                 const InstanceKlass* unsafe_anonymous_host,
 176                                                 GrowableArray<Handle>* cp_patches,
 177                                                 const bool is_nonfindable,
 178                                                 const bool can_access_vm_annotations,
 179                                                 InstanceKlass* dynamic_nest_host,
 180                                                 Handle classData,
 181                                                 TRAPS) {
 182   assert(stream != NULL, "invariant");
 183   assert(loader_data != NULL, "invariant");
 184   assert(THREAD->is_Java_thread(), "must be a JavaThread");
 185 
 186   ResourceMark rm;
 187   HandleMark hm;
 188 
 189   JvmtiCachedClassFileData* cached_class_file = NULL;
 190 
 191   ClassFileStream* old_stream = stream;
 192 
 193   // increment counter
 194   THREAD->statistical_info().incr_define_class_count();
 195 
 196   assert(!(is_nonfindable && (unsafe_anonymous_host != NULL)),
 197          "nonFindable class has an anonymous host");
 198 
 199   // Skip this processing for VM nonfindable or anonymous classes
 200   if (!is_nonfindable && (unsafe_anonymous_host == NULL)) {
 201     stream = check_class_file_load_hook(stream,
 202                                         name,
 203                                         loader_data,
 204                                         protection_domain,
 205                                         &cached_class_file,
 206                                         CHECK_NULL);
 207   }
 208 
 209   ClassFileParser parser(stream,
 210                          name,
 211                          loader_data,
 212                          protection_domain,
 213                          unsafe_anonymous_host,
 214                          cp_patches,
 215                          is_nonfindable,
 216                          can_access_vm_annotations,
 217                          ClassFileParser::BROADCAST, // publicity level
 218                          CHECK_NULL);
 219 
 220   InstanceKlass* result = parser.create_instance_klass(old_stream != stream, dynamic_nest_host, classData, CHECK_NULL);
 221   assert(result == parser.create_instance_klass(old_stream != stream, NULL, classData, THREAD), "invariant");
 222 
 223   if (result == NULL) {
 224     return NULL;
 225   }
 226 
 227   if (cached_class_file != NULL) {
 228     // JVMTI: we have an InstanceKlass now, tell it about the cached bytes
 229     result->set_cached_class_file(cached_class_file);
 230   }
 231 
 232   JFR_ONLY(ON_KLASS_CREATION(result, parser, THREAD);)
 233 
 234 #if INCLUDE_CDS
 235   if (DumpSharedSpaces) {
 236     ClassLoader::record_result(result, stream, THREAD);
 237   }
 238 #endif // INCLUDE_CDS
 239 
 240   return result;
 241 }
< prev index next >