src/share/vm/prims/jvm.cpp

Print this page




 856   }
 857 
 858   ResourceMark rm(THREAD);
 859   ClassFileStream st((u1*) buf, len, (char *)source);
 860   Handle class_loader (THREAD, JNIHandles::resolve(loader));
 861   if (UsePerfData) {
 862     is_lock_held_by_thread(class_loader,
 863                            ClassLoader::sync_JVMDefineClassLockFreeCounter(),
 864                            THREAD);
 865   }
 866   Handle protection_domain (THREAD, JNIHandles::resolve(pd));
 867   klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader,
 868                                                      protection_domain, &st,
 869                                                      verify != 0,
 870                                                      CHECK_NULL);
 871 
 872   if (TraceClassResolution && k != NULL) {
 873     trace_class_resolution(k);
 874   }
 875 














 876   return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
 877 }
 878 
 879 
 880 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
 881   JVMWrapper2("JVM_DefineClass %s", name);
 882 
 883   return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD);
 884 JVM_END
 885 
 886 
 887 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
 888   JVMWrapper2("JVM_DefineClassWithSource %s", name);
 889 
 890   return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD);
 891 JVM_END
 892 
 893 JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name,
 894                                                 jobject loader, const jbyte *buf,
 895                                                 jsize len, jobject pd,


3300 
3301   if (k->klass_part()->oop_is_typeArray()) {
3302     // typeArray
3303     result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
3304   } else if (k->klass_part()->oop_is_objArray()) {
3305     // objArray
3306     objArrayKlassHandle oak(THREAD, k);
3307     oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
3308     result = oak->allocate(length, CHECK_NULL);
3309   } else {
3310     THROW_0(vmSymbols::java_lang_InvalidClassException());
3311   }
3312   return JNIHandles::make_local(env, result);
3313 JVM_END
3314 
3315 
3316 // Return the first non-null class loader up the execution stack, or null
3317 // if only code from the null class loader is on the stack.
3318 
3319 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))







3320   for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3321     // UseNewReflection
3322     vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
3323     klassOop holder = vfst.method()->method_holder();
3324     oop loader = instanceKlass::cast(holder)->class_loader();
3325     if (loader != NULL) {



3326       return JNIHandles::make_local(env, loader);
3327     }
3328   }
3329   return NULL;
3330 JVM_END
3331 
3332 
3333 // Load a class relative to the most recent class on the stack  with a non-null
3334 // classloader.
3335 // This function has been deprecated and should not be considered part of the
3336 // specified JVM interface.
3337 
3338 JVM_ENTRY(jclass, JVM_LoadClass0(JNIEnv *env, jobject receiver,
3339                                  jclass currClass, jstring currClassName))
3340   JVMWrapper("JVM_LoadClass0");
3341   // Receiver is not used
3342   ResourceMark rm(THREAD);
3343 
3344   // Class name argument is not guaranteed to be in internal format
3345   Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName));




 856   }
 857 
 858   ResourceMark rm(THREAD);
 859   ClassFileStream st((u1*) buf, len, (char *)source);
 860   Handle class_loader (THREAD, JNIHandles::resolve(loader));
 861   if (UsePerfData) {
 862     is_lock_held_by_thread(class_loader,
 863                            ClassLoader::sync_JVMDefineClassLockFreeCounter(),
 864                            THREAD);
 865   }
 866   Handle protection_domain (THREAD, JNIHandles::resolve(pd));
 867   klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader,
 868                                                      protection_domain, &st,
 869                                                      verify != 0,
 870                                                      CHECK_NULL);
 871 
 872   if (TraceClassResolution && k != NULL) {
 873     trace_class_resolution(k);
 874   }
 875 
 876   if (UsePrimordialLoaderCache) {
 877     // Skip caching the reflection loader and the extension loader
 878     instanceKlass* loader_klass = instanceKlass::cast((JNIHandles::resolve(loader))->klass());
 879     const char* loader_name = loader_klass->external_name();
 880     bool  is_reflection_loader = strncmp(loader_name, "sun.reflect", 11) == 0 ? true : false;
 881     bool  is_ext_loader = strncmp(loader_name, "sun.misc.Launcher$ExtClassLoader", 32) == 0 ? true : false;
 882 #ifdef ASSERT      
 883     tty->print("NEW LDR TYPE is %s for %s, %1x\n", loader_name, name, is_reflection_loader);
 884 #endif
 885     if ((!is_reflection_loader) && (!is_ext_loader)) {
 886       Universe::check_or_set_cached_loader(*(class_loader.raw_value()));
 887     }
 888   }
 889   
 890   return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
 891 }
 892 
 893 
 894 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
 895   JVMWrapper2("JVM_DefineClass %s", name);
 896 
 897   return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD);
 898 JVM_END
 899 
 900 
 901 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
 902   JVMWrapper2("JVM_DefineClassWithSource %s", name);
 903 
 904   return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD);
 905 JVM_END
 906 
 907 JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name,
 908                                                 jobject loader, const jbyte *buf,
 909                                                 jsize len, jobject pd,


3314 
3315   if (k->klass_part()->oop_is_typeArray()) {
3316     // typeArray
3317     result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
3318   } else if (k->klass_part()->oop_is_objArray()) {
3319     // objArray
3320     objArrayKlassHandle oak(THREAD, k);
3321     oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
3322     result = oak->allocate(length, CHECK_NULL);
3323   } else {
3324     THROW_0(vmSymbols::java_lang_InvalidClassException());
3325   }
3326   return JNIHandles::make_local(env, result);
3327 JVM_END
3328 
3329 
3330 // Return the first non-null class loader up the execution stack, or null
3331 // if only code from the null class loader is on the stack.
3332 
3333 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
3334   if (UsePrimordialLoaderCache) {      
3335     oop cachedLoader = Universe::get_cached_loader();
3336     if (cachedLoader != NULL && (oop)cachedLoader != (oop)-1) {
3337       return JNIHandles::make_local(env, cachedLoader);
3338     }
3339   }
3340 
3341   for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3342     // UseNewReflection
3343     vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
3344     klassOop holder = vfst.method()->method_holder();
3345     oop loader = instanceKlass::cast(holder)->class_loader();
3346     if (loader != NULL) {
3347       if (UsePrimordialLoaderCache) {      
3348         Universe::check_or_set_cached_loader(loader);
3349       }
3350       return JNIHandles::make_local(env, loader);
3351     }
3352   }
3353   return NULL;
3354 JVM_END
3355 
3356 
3357 // Load a class relative to the most recent class on the stack  with a non-null
3358 // classloader.
3359 // This function has been deprecated and should not be considered part of the
3360 // specified JVM interface.
3361 
3362 JVM_ENTRY(jclass, JVM_LoadClass0(JNIEnv *env, jobject receiver,
3363                                  jclass currClass, jstring currClassName))
3364   JVMWrapper("JVM_LoadClass0");
3365   // Receiver is not used
3366   ResourceMark rm(THREAD);
3367 
3368   // Class name argument is not guaranteed to be in internal format
3369   Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName));