jdk-sandbox: comparison src/hotspot/share/prims/jvm.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "gc/shared/collectedHeap.inline.hpp"
 #include "interpreter/bytecode.hpp"
+#include "interpreter/bytecodeUtils.hpp"
 #include "jfr/jfrEvents.hpp"
 #include "logging/log.hpp"
 #include "memory/heapShared.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/referenceType.hpp"
 // java.lang.Throwable //////////////////////////////////////////////////////
 JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))
 JVMWrapper("JVM_FillInStackTrace");
 Handle exception(thread, JNIHandles::resolve_non_null(receiver));
 java_lang_Throwable::fill_in_stack_trace(exception);
 JVM_END
+// java.lang.NullPointerException ///////////////////////////////////////////
+JVM_ENTRY(jstring, JVM_GetExtendedNPEMessage(JNIEnv *env, jthrowable throwable))
+if (!ShowCodeDetailsInExceptionMessages) return NULL;
+oop exc = JNIHandles::resolve_non_null(throwable);
+Method* method;
+int bci;
+if (!java_lang_Throwable::get_top_method_and_bci(exc, &method, &bci)) {
+return NULL;
+}
+if (method->is_native()) {
+return NULL;
+}
+stringStream ss;
+bool ok = BytecodeUtils::get_NPE_message_at(&ss, method, bci);
+if (ok) {
+oop result = java_lang_String::create_oop_from_str(ss.base(), CHECK_0);
+return (jstring) JNIHandles::make_local(env, result);
+} else {
+return NULL;
+}
+JVM_END
 // java.lang.StackTraceElement //////////////////////////////////////////////
 JVM_ENTRY(void, JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject throwable))
 JVM_END
 // Misc. class handling ///////////////////////////////////////////////////////////
+JVM_ENTRY(void, JVM_LinkClass(JNIEnv* env, jclass classClass, jclass arg))
+JVMWrapper("JVM_LinkClass");
+oop r = JNIHandles::resolve(arg);
+Klass* klass = java_lang_Class::as_Klass(r);
+if (!ClassForNameDeferLinking && klass->is_instance_klass()) {
+InstanceKlass::cast(klass)->link_class(CHECK);
+}
+JVM_END
 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env))
 JVMWrapper("JVM_GetCallerClass");
 // Getting the class of the caller frame.
 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
 JVMWrapper("JVM_FindPrimitiveClass");
 oop mirror = NULL;
 BasicType t = name2type(utf);
-if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) {
+if (t != T_ILLEGAL && !is_reference_type(t)) {
 mirror = Universe::java_mirror(t);
 }
 if (mirror == NULL) {
 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);
 } else {
 protection_domain = java_lang_Class::as_Klass(from_class)->protection_domain();
 }
 Handle h_loader(THREAD, loader_oop);
 Handle h_prot(THREAD, protection_domain);
-jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
+jboolean link = !ClassForNameDeferLinking;
+jclass result = find_class_from_class_loader(env, h_name, init, link, h_loader,
 h_prot, false, THREAD);
 if (log_is_enabled(Debug, class, resolve) && result != NULL) {
 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
 }
 return result;
 JVM_END
 class_loader = from_class->class_loader();
 protection_domain = from_class->protection_domain();
 }
 Handle h_loader(THREAD, class_loader);
 Handle h_prot  (THREAD, protection_domain);
-jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
+jclass result = find_class_from_class_loader(env, h_name, init, false, h_loader,
 h_prot, true, thread);
 if (log_is_enabled(Debug, class, resolve) && result != NULL) {
 // this function is generally only used for class loading during verification.
 ResourceMark rm;
 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
 JVMWrapper("JVM_FindLoadedClass");
 ResourceMark rm(THREAD);
 Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
-Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL);
+char* str = java_lang_String::as_utf8_string(h_name());
-const char* str   = java_lang_String::as_utf8_string(string());
 // Sanity check, don't expect null
 if (str == NULL) return NULL;
-const int str_len = (int)strlen(str);
+// Internalize the string, converting '.' to '/' in string.
+char* p = (char*)str;
+while (*p != '\0') {
+if (*p == '.') {
+*p = '/';
+}
+p++;
+}
+const int str_len = (int)(p - str);
 if (str_len > Symbol::max_length()) {
 // It's impossible to create this class;  the name cannot fit
 // into the constant pool.
 return NULL;
 }
 }
 return (jobjectArray) JNIHandles::make_local(env, result());
 JVM_END
-JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
+JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_IsInterface");
 oop mirror = JNIHandles::resolve_non_null(cls);
 if (java_lang_Class::is_primitive(mirror)) {
 return JNI_FALSE;
 }
 protection_domain  = caller_klass->protection_domain();
 } else {
 protection_domain = method->method_holder()->protection_domain();
 }
-if ((!oopDesc::equals(previous_protection_domain, protection_domain)) && (protection_domain != NULL)) {
+if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) {
 local_array->push(protection_domain);
 previous_protection_domain = protection_domain;
 }
 if (is_privileged) break;
 return JNIHandles::make_local(env, result);
 JVM_END
-JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
+JVM_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_IsArrayClass");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 return (k != NULL) && k->is_array_klass() ? true : false;
 JVM_END
-JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
+JVM_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_IsPrimitiveClass");
 oop mirror = JNIHandles::resolve_non_null(cls);
 return (jboolean) java_lang_Class::is_primitive(mirror);
 JVM_END
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 return k->name()->as_utf8();
 JVM_END
-JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
+JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
 JVMWrapper("JVM_GetClassCPTypes");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 // types will have length zero if this is not an InstanceKlass
 // (length is determined by call to JVM_GetClassCPEntriesCount)
 }
 }
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
+JVM_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassCPEntriesCount");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->constants()->length();
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
+JVM_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassFieldsCount");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->java_fields_count();
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
+JVM_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassMethodsCount");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->methods()->length();
 JVM_END
 // The following methods, used for the verifier, are never called with
 // array klasses, so a direct cast to InstanceKlass is safe.
 // Typically, these methods are called in a loop with bounds determined
 // by the results of JVM_GetClass{Fields,Methods}Count, which return
 // zero for arrays.
-JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))
+JVM_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))
 JVMWrapper("JVM_GetMethodIxExceptionIndexes");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 int length = method->checked_exceptions_length();
 }
 }
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))
 JVMWrapper("JVM_GetMethodIxExceptionsCount");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->checked_exceptions_length();
 JVM_END
-JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))
+JVM_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))
 JVMWrapper("JVM_GetMethodIxByteCode");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 memcpy(code, method->code_base(), method->code_size());
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))
 JVMWrapper("JVM_GetMethodIxByteCodeLength");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->code_size();
 JVM_END
-JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))
+JVM_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))
 JVMWrapper("JVM_GetMethodIxExceptionTableEntry");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 ExceptionTable extable(method);
 entry->handler_pc = extable.handler_pc(entry_index);
 entry->catchType  = extable.catch_type_index(entry_index);
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_GetMethodIxExceptionTableLength");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->exception_table_length();
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_GetMethodIxModifiers");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))
+JVM_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))
 JVMWrapper("JVM_GetFieldIxModifiers");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 return InstanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS;
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_GetMethodIxLocalsCount");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->max_locals();
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_GetMethodIxArgsSize");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->size_of_parameters();
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_GetMethodIxMaxStack");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->verifier_max_stack();
 JVM_END
-JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_IsConstructorIx");
 ResourceMark rm(THREAD);
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 return method->name() == vmSymbols::object_initializer_name();
 JVM_END
-JVM_QUICK_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
+JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
 JVMWrapper("JVM_IsVMGeneratedMethodIx");
 ResourceMark rm(THREAD);
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
 ShouldNotReachHere();
 return 0;
 JVM_END
-JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
+JVM_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
 JVMWrapper("JVM_GetCPMethodModifiers");
 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
 Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
 k        = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
 if (millis < 0) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
-if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {
+if (thread->is_interrupted(true) && !HAS_PENDING_EXCEPTION) {
 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
 }
 // Save current thread state and restore it at the end of this block.
 // And set new thread state to SLEEPING.
 if (millis == 0) {
 os::naked_yield();
 } else {
 ThreadState old_state = thread->osthread()->get_state();
 thread->osthread()->set_state(SLEEPING);
-if (os::sleep(thread, millis, true) == OS_INTRPT) {
+if (!thread->sleep(millis)) { // interrupted
 // An asynchronous exception (e.g., ThreadDeathException) could have been thrown on
 // us while we were sleeping. We do not overwrite those.
 if (!HAS_PENDING_EXCEPTION) {
 if (event.should_commit()) {
 post_thread_sleep_event(&event, millis);
 ThreadsListHandle tlh(thread);
 JavaThread* receiver = NULL;
 bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, NULL);
 if (is_alive) {
 // jthread refers to a live JavaThread.
-Thread::interrupt(receiver);
+receiver->interrupt();
 }
 JVM_END
-JVM_QUICK_ENTRY(jboolean, JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted))
+JVM_ENTRY(jboolean, JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted))
 JVMWrapper("JVM_IsInterrupted");
 ThreadsListHandle tlh(thread);
 JavaThread* receiver = NULL;
 bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, NULL);
 if (is_alive) {
 // jthread refers to a live JavaThread.
-return (jboolean) Thread::is_interrupted(receiver, clear_interrupted != 0);
+return (jboolean) receiver->is_interrupted(clear_interrupted != 0);
 } else {
 return JNI_FALSE;
 }
 JVM_END
 oop result = StringTable::intern(string, CHECK_NULL);
 return (jstring) JNIHandles::make_local(env, result);
 JVM_END
-// Raw monitor support //////////////////////////////////////////////////////////////////////
+// VM Raw monitor support //////////////////////////////////////////////////////////////////////
-// The lock routine below calls lock_without_safepoint_check in order to get a raw lock
+// VM Raw monitors (not to be confused with JvmtiRawMonitors) are a simple mutual exclusion
-// without interfering with the safepoint mechanism. The routines are not JVM_LEAF because
+// lock (not actually monitors: no wait/notify) that is exported by the VM for use by JDK
-// they might be called by non-java threads. The JVM_LEAF installs a NoHandleMark check
+// library code. They may be used by JavaThreads and non-JavaThreads and do not participate
-// that only works with java threads.
+// in the safepoint protocol, thread suspension, thread interruption, or anything of that
+// nature. JavaThreads will be "in native" when using this API from JDK code.
 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void) {
 VM_Exit::block_if_vm_exited();
 JVMWrapper("JVM_RawMonitorCreate");
-return new Mutex(Mutex::native, "JVM_RawMonitorCreate");
+return new os::PlatformMutex();
 }
 JNIEXPORT void JNICALL  JVM_RawMonitorDestroy(void *mon) {
 VM_Exit::block_if_vm_exited();
 JVMWrapper("JVM_RawMonitorDestroy");
-delete ((Mutex*) mon);
+delete ((os::PlatformMutex*) mon);
 }
 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon) {
 VM_Exit::block_if_vm_exited();
 JVMWrapper("JVM_RawMonitorEnter");
-((Mutex*) mon)->jvm_raw_lock();
+((os::PlatformMutex*) mon)->lock();
 return 0;
 }
 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon) {
 VM_Exit::block_if_vm_exited();
 JVMWrapper("JVM_RawMonitorExit");
-((Mutex*) mon)->jvm_raw_unlock();
+((os::PlatformMutex*) mon)->unlock();
 }
 // Shared JNI/JVM entry points //////////////////////////////////////////////////////////////
-jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
+jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, jboolean link,
 Handle loader, Handle protection_domain,
 jboolean throwError, TRAPS) {
+// Initialization also implies linking - check for coherent args
+assert((init && link) || !init, "incorrect use of init/link arguments");
 // Security Note:
 //   The Java level wrapper will perform the necessary security check allowing
 //   us to pass the NULL as the initiating class loader.  The VM is responsible for
 //   the checkPackageAccess relative to the initiating class loader via the
 //   protection_domain. The protection_domain is passed as NULL by the java code
 //   if there is no security manager in 3-arg Class.forName().
 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
-// Check if we should initialize the class
+// Check if we should initialize the class (which implies linking), or just link it
 if (init && klass->is_instance_klass()) {
 klass->initialize(CHECK_NULL);
+} else if (link && klass->is_instance_klass()) {
+InstanceKlass::cast(klass)->link_class(CHECK_NULL);
 }
 return (jclass) JNIHandles::make_local(env, klass->java_mirror());
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54957	b6b02a503d02
child 58679	9c3209ff7550