< prev index next >

src/hotspot/share/classfile/klassFactory.cpp

Print this page




  85           pathname = (const char*)(mod_entry->location()->as_C_string());
  86         } else {
  87           pathname = "";
  88         }
  89       } else {
  90         SharedClassPathEntry* ent =
  91           (SharedClassPathEntry*)FileMapInfo::shared_path(path_index);
  92         pathname = ent == NULL ? NULL : ent->name();
  93       }
  94       ClassFileStream* stream = new ClassFileStream(ptr,
  95                                                     end_ptr - ptr,
  96                                                     pathname,
  97                                                     ClassFileStream::verify);
  98       ClassFileParser parser(stream,
  99                              class_name,
 100                              loader_data,
 101                              protection_domain,
 102                              NULL,  // unsafe_anonymous_host
 103                              NULL,  // cp_patches
 104                              false, // is_nonfindable

 105                              ClassFileParser::BROADCAST, // publicity level
 106                              CHECK_NULL);
 107       InstanceKlass* new_ik = parser.create_instance_klass(true /* changed_by_loadhook */,
 108                                                            CHECK_NULL);
 109       if (cached_class_file != NULL) {
 110         new_ik->set_cached_class_file(cached_class_file);
 111       }
 112 
 113       if (class_loader.is_null()) {
 114         ResourceMark rm;
 115         ClassLoader::add_package(class_name->as_C_string(), path_index, THREAD);
 116       }
 117 
 118       return new_ik;
 119     }
 120   }
 121 #endif
 122 
 123   return NULL;
 124 }


 169     if (ptr != stream->buffer()) {
 170       // JVMTI agent has modified class file data.
 171       // Set new class file stream using JVMTI agent modified class file data.
 172       stream = new ClassFileStream(ptr,
 173                                    end_ptr - ptr,
 174                                    stream->source(),
 175                                    stream->need_verify());
 176     }
 177   }
 178 
 179   return stream;
 180 }
 181 
 182 
 183 InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
 184                                                 Symbol* name,
 185                                                 ClassLoaderData* loader_data,
 186                                                 Handle protection_domain,
 187                                                 const InstanceKlass* unsafe_anonymous_host,
 188                                                 GrowableArray<Handle>* cp_patches,
 189                                                 bool is_nonfindable,

 190                                                 TRAPS) {
 191   assert(stream != NULL, "invariant");
 192   assert(loader_data != NULL, "invariant");
 193   assert(THREAD->is_Java_thread(), "must be a JavaThread");
 194 
 195   ResourceMark rm;
 196   HandleMark hm;
 197 
 198   JvmtiCachedClassFileData* cached_class_file = NULL;
 199 
 200   ClassFileStream* old_stream = stream;
 201 
 202   // increment counter
 203   THREAD->statistical_info().incr_define_class_count();
 204 
 205   // Skip this processing for VM nonfindable or anonymous classes
 206   if (is_nonfindable || (unsafe_anonymous_host == NULL)) {
 207     stream = check_class_file_load_hook(stream,
 208                                         name,
 209                                         loader_data,
 210                                         protection_domain,
 211                                         &cached_class_file,
 212                                         CHECK_NULL);
 213   }
 214 
 215   ClassFileParser parser(stream,
 216                          name,
 217                          loader_data,
 218                          protection_domain,
 219                          unsafe_anonymous_host,
 220                          cp_patches,
 221                          is_nonfindable,

 222                          ClassFileParser::BROADCAST, // publicity level
 223                          CHECK_NULL);
 224 
 225   InstanceKlass* result = parser.create_instance_klass(old_stream != stream, CHECK_NULL);
 226   assert(result == parser.create_instance_klass(old_stream != stream, THREAD), "invariant");
 227 
 228   if (result == NULL) {
 229     return NULL;
 230   }
 231 
 232   if (cached_class_file != NULL) {
 233     // JVMTI: we have an InstanceKlass now, tell it about the cached bytes
 234     result->set_cached_class_file(cached_class_file);
 235   }
 236 
 237   if (result->should_store_fingerprint()) {
 238     result->store_fingerprint(stream->compute_fingerprint());
 239   }
 240 
 241   JFR_ONLY(ON_KLASS_CREATION(result, parser, THREAD);)




  85           pathname = (const char*)(mod_entry->location()->as_C_string());
  86         } else {
  87           pathname = "";
  88         }
  89       } else {
  90         SharedClassPathEntry* ent =
  91           (SharedClassPathEntry*)FileMapInfo::shared_path(path_index);
  92         pathname = ent == NULL ? NULL : ent->name();
  93       }
  94       ClassFileStream* stream = new ClassFileStream(ptr,
  95                                                     end_ptr - ptr,
  96                                                     pathname,
  97                                                     ClassFileStream::verify);
  98       ClassFileParser parser(stream,
  99                              class_name,
 100                              loader_data,
 101                              protection_domain,
 102                              NULL,  // unsafe_anonymous_host
 103                              NULL,  // cp_patches
 104                              false, // is_nonfindable
 105                              false, // can_access_vm_annotations
 106                              ClassFileParser::BROADCAST, // publicity level
 107                              CHECK_NULL);
 108       InstanceKlass* new_ik = parser.create_instance_klass(true /* changed_by_loadhook */,
 109                                                            CHECK_NULL);
 110       if (cached_class_file != NULL) {
 111         new_ik->set_cached_class_file(cached_class_file);
 112       }
 113 
 114       if (class_loader.is_null()) {
 115         ResourceMark rm;
 116         ClassLoader::add_package(class_name->as_C_string(), path_index, THREAD);
 117       }
 118 
 119       return new_ik;
 120     }
 121   }
 122 #endif
 123 
 124   return NULL;
 125 }


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


< prev index next >