3132 static bool is_trusted_frame(JavaThread* jthread, vframeStream* vfst) {

  3133   assert(jthread->is_Java_thread(), "must be a Java thread");

  3134   if (jthread->privileged_stack_top() == NULL) return false;

  3135   if (jthread->privileged_stack_top()->frame_id() == vfst->frame_id()) {

  3136     oop loader = jthread->privileged_stack_top()->class_loader();

  3137     if (loader == NULL) return true;

  3138     bool trusted = java_lang_ClassLoader::is_trusted_loader(loader);

  3139     if (trusted) return true;

  3140   }

  3141   return false;

  3142 }

  3143 

  3144 JVM_ENTRY(jclass, JVM_CurrentLoadedClass(JNIEnv *env))

  3145   JVMWrapper("JVM_CurrentLoadedClass");

  3146   ResourceMark rm(THREAD);

  3147 

  3148   for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {

  3149     // if a method in a class in a trusted loader is in a doPrivileged, return NULL

  3150     bool trusted = is_trusted_frame(thread, &vfst);

  3151     if (trusted) return NULL;

  3152 

  3153     Method* m = vfst.method();

  3154     if (!m->is_native()) {

  3155       InstanceKlass* holder = m->method_holder();

  3156       oop loader = holder->class_loader();

  3157       if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {

  3158         return (jclass) JNIHandles::make_local(env, holder->java_mirror());

  3159       }

  3160     }

  3161   }

  3162   return NULL;

  3163 JVM_END

  3164 

  3165 

  3166 JVM_ENTRY(jobject, JVM_CurrentClassLoader(JNIEnv *env))

  3167   JVMWrapper("JVM_CurrentClassLoader");

  3168   ResourceMark rm(THREAD);

  3169 

  3170   for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {

  3171 

  3172     // if a method in a class in a trusted loader is in a doPrivileged, return NULL

  3173     bool trusted = is_trusted_frame(thread, &vfst);

  3174     if (trusted) return NULL;

  3175 

  3176     Method* m = vfst.method();

  3177     if (!m->is_native()) {

  3178       InstanceKlass* holder = m->method_holder();

  3179       assert(holder->is_klass(), "just checking");

  3180       oop loader = holder->class_loader();

  3181       if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {

  3182         return JNIHandles::make_local(env, loader);

  3183       }

  3184     }

  3185   }

  3186   return NULL;

  3187 JVM_END

  3188 

  3189 

  3226 JVM_END

  3227 

  3228 

  3229 JVM_ENTRY(jint, JVM_ClassDepth(JNIEnv *env, jstring name))

  3230   JVMWrapper("JVM_ClassDepth");

  3231   ResourceMark rm(THREAD);

  3232   Handle h_name (THREAD, JNIHandles::resolve_non_null(name));

  3233   Handle class_name_str = java_lang_String::internalize_classname(h_name, CHECK_0);

  3234 

  3235   const char* str = java_lang_String::as_utf8_string(class_name_str());

  3236   TempNewSymbol class_name_sym = SymbolTable::probe(str, (int)strlen(str));

  3237   if (class_name_sym == NULL) {

  3238     return -1;

  3239   }

  3240 

  3241   int depth = 0;

  3242 

  3243   for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {

  3244     if (!vfst.method()->is_native()) {

  3245       InstanceKlass* holder = vfst.method()->method_holder();

  3246       assert(holder->is_klass(), "just checking");

  3247       if (holder->name() == class_name_sym) {

  3248         return depth;

  3249       }

  3250       depth++;

  3251     }

  3252   }

  3253   return -1;

  3254 JVM_END

  3255 

  3256 

  3257 JVM_ENTRY(jint, JVM_ClassLoaderDepth(JNIEnv *env))

  3258   JVMWrapper("JVM_ClassLoaderDepth");

  3259   ResourceMark rm(THREAD);

  3260   int depth = 0;

  3261   for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {

  3262     // if a method in a class in a trusted loader is in a doPrivileged, return -1

  3263     bool trusted = is_trusted_frame(thread, &vfst);

  3264     if (trusted) return -1;

  3265 

  3266     Method* m = vfst.method();

  3267     if (!m->is_native()) {

  3268       InstanceKlass* holder = m->method_holder();

  3269       assert(holder->is_klass(), "just checking");

  3270       oop loader = holder->class_loader();

  3271       if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {

  3272         return depth;

  3273       }

  3274       depth++;

  3275     }

  3276   }

  3277   return -1;