327
328 if (UsePerfData && !class_loader.is_null()) {
329 // check whether the current caller thread holds the lock or not.
330 // If not, increment the corresponding counter
331 if (ObjectSynchronizer::
332 query_lock_ownership((JavaThread*)THREAD, class_loader) !=
333 ObjectSynchronizer::owner_self) {
334 ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();
335 }
336 }
337 Klass* k = SystemDictionary::resolve_from_stream(class_name,
338 class_loader,
339 Handle(),
340 &st,
341 CHECK_NULL);
342
343 if (log_is_enabled(Debug, class, resolve) && k != NULL) {
344 trace_class_resolution(k);
345 }
346
347 cls = (jclass)JNIHandles::make_local(
348 env, k->java_mirror());
349 return cls;
350 JNI_END
351
352
353
354 DT_RETURN_MARK_DECL(FindClass, jclass
355 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
356
357 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
358 JNIWrapper("FindClass");
359
360 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
361
362 jclass result = NULL;
363 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
364
365 // This should be ClassNotFoundException imo.
366 TempNewSymbol class_name =
367 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(),
368 CHECK_NULL);
484
485 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
486 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
487
488 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
489 JNIWrapper("ToReflectedMethod");
490
491 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
492
493 jobject ret = NULL;
494 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
495
496 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
497 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
498 oop reflection_method;
499 if (m->is_initializer()) {
500 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
501 } else {
502 reflection_method = Reflection::new_method(m, false, CHECK_NULL);
503 }
504 ret = JNIHandles::make_local(env, reflection_method);
505 return ret;
506 JNI_END
507
508 DT_RETURN_MARK_DECL(GetSuperclass, jclass
509 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
510
511 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
512 JNIWrapper("GetSuperclass");
513
514 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
515
516 jclass obj = NULL;
517 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
518
519 oop mirror = JNIHandles::resolve_non_null(sub);
520 // primitive classes return NULL
521 if (java_lang_Class::is_primitive(mirror)) return NULL;
522
523 // Rules of Class.getSuperClass as implemented by KLass::java_super:
524 // arrays return Object
606 // exception in ExceptionOccurred and ExceptionCheck calls, since
607 // delivering an async exception in other places won't change the native
608 // code's control flow and would be harmful when native code further calls
609 // JNI functions with a pending exception. Async exception is also checked
610 // during the call, so ExceptionOccurred/ExceptionCheck won't return
611 // false but deliver the async exception at the very end during
612 // state transition.
613
614 static void jni_check_async_exceptions(JavaThread *thread) {
615 assert(thread == Thread::current(), "must be itself");
616 thread->check_and_handle_async_exceptions();
617 }
618
619 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
620 JNIWrapper("ExceptionOccurred");
621
622 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
623
624 jni_check_async_exceptions(thread);
625 oop exception = thread->pending_exception();
626 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
627
628 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
629 return ret;
630 JNI_END
631
632
633 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
634 JNIWrapper("ExceptionDescribe");
635
636 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
637
638 if (thread->has_pending_exception()) {
639 Handle ex(thread, thread->pending_exception());
640 thread->clear_pending_exception();
641 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
642 // Don't print anything if we are being killed.
643 } else {
644 jio_fprintf(defaultStream::error_stream(), "Exception ");
645 if (thread != NULL && thread->threadObj() != NULL) {
646 ResourceMark rm(THREAD);
724 JNI_END
725
726
727 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
728 JNIWrapper("PopLocalFrame");
729
730 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
731
732 //%note jni_11
733 Handle result_handle(thread, JNIHandles::resolve(result));
734 JNIHandleBlock* old_handles = thread->active_handles();
735 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
736 if (new_handles != NULL) {
737 // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL.
738 // This way code will still work if PopLocalFrame is called without a corresponding
739 // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise
740 // the release_block call will release the blocks.
741 thread->set_active_handles(new_handles);
742 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
743 JNIHandleBlock::release_block(old_handles, thread); // may block
744 result = JNIHandles::make_local(thread, result_handle());
745 }
746 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
747 return result;
748 JNI_END
749
750
751 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
752 JNIWrapper("NewGlobalRef");
753
754 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
755
756 Handle ref_handle(thread, JNIHandles::resolve(ref));
757 jobject ret = JNIHandles::make_global(ref_handle);
758
759 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
760 return ret;
761 JNI_END
762
763 // Must be JNI_ENTRY (with HandleMark)
764 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
781 HOTSPOT_JNI_DELETELOCALREF_RETURN();
782 JNI_END
783
784 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
785 JNIWrapper("IsSameObject");
786
787 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
788
789 jboolean ret = JNIHandles::is_same_object(r1, r2) ? JNI_TRUE : JNI_FALSE;
790
791 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
792 return ret;
793 JNI_END
794
795
796 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
797 JNIWrapper("NewLocalRef");
798
799 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
800
801 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
802
803 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
804 return ret;
805 JNI_END
806
807 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
808 JNIWrapper("EnsureLocalCapacity");
809
810 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
811
812 jint ret;
813 if (capacity >= 0 &&
814 ((MaxJNILocalCapacity <= 0) || (capacity <= MaxJNILocalCapacity))) {
815 ret = JNI_OK;
816 } else {
817 ret = JNI_ERR;
818 }
819
820 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
821 return ret;
959 methodHandle method(THREAD, Method::resolve_jmethod_id(method_id));
960
961 // Create object to hold arguments for the JavaCall, and associate it with
962 // the jni parser
963 ResourceMark rm(THREAD);
964 int number_of_parameters = method->size_of_parameters();
965 JavaCallArguments java_args(number_of_parameters);
966
967 assert(method->is_static(), "method should be static");
968
969 // Fill out JavaCallArguments object
970 args->push_arguments_on(&java_args);
971 // Initialize result type
972 result->set_type(args->return_type());
973
974 // Invoke the method. Result is returned as oop.
975 JavaCalls::call(result, method, &java_args, CHECK);
976
977 // Convert result
978 if (is_reference_type(result->get_type())) {
979 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
980 }
981 }
982
983
984 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
985 oop recv = JNIHandles::resolve(receiver);
986 if (recv == NULL) {
987 THROW(vmSymbols::java_lang_NullPointerException());
988 }
989 Handle h_recv(THREAD, recv);
990
991 int number_of_parameters;
992 Method* selected_method;
993 {
994 Method* m = Method::resolve_jmethod_id(method_id);
995 number_of_parameters = m->size_of_parameters();
996 Klass* holder = m->method_holder();
997 if (call_type != JNI_VIRTUAL) {
998 selected_method = m;
999 } else if (!m->has_itable_index()) {
1021
1022 // Create object to hold arguments for the JavaCall, and associate it with
1023 // the jni parser
1024 ResourceMark rm(THREAD);
1025 JavaCallArguments java_args(number_of_parameters);
1026
1027 // handle arguments
1028 assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
1029 java_args.push_oop(h_recv); // Push jobject handle
1030
1031 // Fill out JavaCallArguments object
1032 args->push_arguments_on(&java_args);
1033 // Initialize result type
1034 result->set_type(args->return_type());
1035
1036 // Invoke the method. Result is returned as oop.
1037 JavaCalls::call(result, method, &java_args, CHECK);
1038
1039 // Convert result
1040 if (is_reference_type(result->get_type())) {
1041 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
1042 }
1043 }
1044
1045 DT_RETURN_MARK_DECL(AllocObject, jobject
1046 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1047
1048 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1049 JNIWrapper("AllocObject");
1050
1051 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
1052
1053 jobject ret = NULL;
1054 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1055
1056 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1057 ret = JNIHandles::make_local(env, i);
1058 return ret;
1059 JNI_END
1060
1061 DT_RETURN_MARK_DECL(NewObjectA, jobject
1062 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1063
1064 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
1065 JNIWrapper("NewObjectA");
1066
1067 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
1068
1069 jobject obj = NULL;
1070 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
1071
1072 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1073 obj = JNIHandles::make_local(env, i);
1074 JavaValue jvalue(T_VOID);
1075 JNI_ArgumentPusherArray ap(methodID, args);
1076 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1077 return obj;
1078 JNI_END
1079
1080
1081 DT_RETURN_MARK_DECL(NewObjectV, jobject
1082 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1083
1084 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
1085 JNIWrapper("NewObjectV");
1086
1087 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
1088
1089 jobject obj = NULL;
1090 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
1091
1092 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1093 obj = JNIHandles::make_local(env, i);
1094 JavaValue jvalue(T_VOID);
1095 JNI_ArgumentPusherVaArg ap(methodID, args);
1096 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1097 return obj;
1098 JNI_END
1099
1100
1101 DT_RETURN_MARK_DECL(NewObject, jobject
1102 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1103
1104 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1105 JNIWrapper("NewObject");
1106
1107 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
1108
1109 jobject obj = NULL;
1110 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1111
1112 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1113 obj = JNIHandles::make_local(env, i);
1114 va_list args;
1115 va_start(args, methodID);
1116 JavaValue jvalue(T_VOID);
1117 JNI_ArgumentPusherVaArg ap(methodID, args);
1118 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1119 va_end(args);
1120 return obj;
1121 JNI_END
1122
1123
1124 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1125 JNIWrapper("GetObjectClass");
1126
1127 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
1128
1129 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1130 jclass ret =
1131 (jclass) JNIHandles::make_local(env, k->java_mirror());
1132
1133 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1134 return ret;
1135 JNI_END
1136
1137 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1138 JNIWrapper("IsInstanceOf");
1139
1140 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
1141
1142 jboolean ret = JNI_TRUE;
1143 if (obj != NULL) {
1144 ret = JNI_FALSE;
1145 Klass* k = java_lang_Class::as_Klass(
1146 JNIHandles::resolve_non_null(clazz));
1147 if (k != NULL) {
1148 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
1149 }
1150 }
1151
1893
1894 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
1895 // It may also have hash bits for k, if VerifyJNIFields is turned on.
1896 ret = jfieldIDWorkaround::to_instance_jfieldID(k, fd.offset());
1897 return ret;
1898 JNI_END
1899
1900
1901 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
1902 JNIWrapper("GetObjectField");
1903 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
1904 oop o = JNIHandles::resolve_non_null(obj);
1905 Klass* k = o->klass();
1906 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
1907 // Keep JVMTI addition small and only check enabled flag here.
1908 // jni_GetField_probe() assumes that is okay to create handles.
1909 if (JvmtiExport::should_post_field_access()) {
1910 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
1911 }
1912 oop loaded_obj = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(o, offset);
1913 jobject ret = JNIHandles::make_local(env, loaded_obj);
1914 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
1915 return ret;
1916 JNI_END
1917
1918
1919
1920 #define DEFINE_GETFIELD(Return,Fieldname,Result \
1921 , EntryProbe, ReturnProbe) \
1922 \
1923 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
1924 , ReturnProbe); \
1925 \
1926 JNI_ENTRY_NO_PRESERVE(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
1927 JNIWrapper("Get" XSTR(Result) "Field"); \
1928 \
1929 EntryProbe; \
1930 Return ret = 0;\
1931 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
1932 \
1933 oop o = JNIHandles::resolve_non_null(obj); \
2073 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
2074
2075 fieldDescriptor fd;
2076 bool found = false;
2077 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2078
2079 assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
2080
2081 if (isStatic) {
2082 // Static field. The fieldID a JNIid specifying the field holder and the offset within the Klass*.
2083 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2084 assert(id->is_static_field_id(), "invalid static field id");
2085 found = id->find_local_field(&fd);
2086 } else {
2087 // Non-static field. The fieldID is really the offset of the field within the instanceOop.
2088 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2089 found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
2090 }
2091 assert(found, "bad fieldID passed into jni_ToReflectedField");
2092 oop reflected = Reflection::new_field(&fd, CHECK_NULL);
2093 ret = JNIHandles::make_local(env, reflected);
2094 return ret;
2095 JNI_END
2096
2097
2098 //
2099 // Accessing Static Fields
2100 //
2101 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2102 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2103
2104 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2105 const char *name, const char *sig))
2106 JNIWrapper("GetStaticFieldID");
2107 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2108 jfieldID ret = NULL;
2109 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2110
2111 // The class should have been loaded (we have an instance of the class
2112 // passed in) so the field and signature should already be in the symbol
2113 // table. If they're not there, the field doesn't exist.
2260 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
2261 DEFINE_SETSTATICFIELD(jdouble, double, Double, JVM_SIGNATURE_DOUBLE, d
2262 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
2263 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
2264
2265 //
2266 // String Operations
2267 //
2268
2269 // Unicode Interface
2270
2271 DT_RETURN_MARK_DECL(NewString, jstring
2272 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
2273
2274 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
2275 JNIWrapper("NewString");
2276 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
2277 jstring ret = NULL;
2278 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
2279 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
2280 ret = (jstring) JNIHandles::make_local(env, string);
2281 return ret;
2282 JNI_END
2283
2284
2285 JNI_ENTRY_NO_PRESERVE(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
2286 JNIWrapper("GetStringLength");
2287 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
2288 jsize ret = 0;
2289 oop s = JNIHandles::resolve_non_null(string);
2290 ret = java_lang_String::length(s);
2291 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
2292 return ret;
2293 JNI_END
2294
2295
2296 JNI_ENTRY_NO_PRESERVE(const jchar*, jni_GetStringChars(
2297 JNIEnv *env, jstring string, jboolean *isCopy))
2298 JNIWrapper("GetStringChars");
2299 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
2300 jchar* buf = NULL;
2336 // Since String objects are supposed to be immutable, don't copy any
2337 // new data back. A bad user will have to go after the char array.
2338 FreeHeap((void*) chars);
2339 }
2340 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
2341 JNI_END
2342
2343
2344 // UTF Interface
2345
2346 DT_RETURN_MARK_DECL(NewStringUTF, jstring
2347 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
2348
2349 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
2350 JNIWrapper("NewStringUTF");
2351 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
2352 jstring ret;
2353 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
2354
2355 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
2356 ret = (jstring) JNIHandles::make_local(env, result);
2357 return ret;
2358 JNI_END
2359
2360
2361 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
2362 JNIWrapper("GetStringUTFLength");
2363 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
2364 oop java_string = JNIHandles::resolve_non_null(string);
2365 jsize ret = java_lang_String::utf8_length(java_string);
2366 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
2367 return ret;
2368 JNI_END
2369
2370
2371 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
2372 JNIWrapper("GetStringUTFChars");
2373 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
2374 char* result = NULL;
2375 oop java_string = JNIHandles::resolve_non_null(string);
2376 typeArrayOop s_value = java_lang_String::value(java_string);
2416 //
2417
2418 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
2419 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
2420
2421 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
2422 JNIWrapper("NewObjectArray");
2423 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
2424 jobjectArray ret = NULL;
2425 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
2426 Klass* ek = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass));
2427 Klass* ak = ek->array_klass(CHECK_NULL);
2428 ObjArrayKlass::cast(ak)->initialize(CHECK_NULL);
2429 objArrayOop result = ObjArrayKlass::cast(ak)->allocate(length, CHECK_NULL);
2430 oop initial_value = JNIHandles::resolve(initialElement);
2431 if (initial_value != NULL) { // array already initialized with NULL
2432 for (int index = 0; index < length; index++) {
2433 result->obj_at_put(index, initial_value);
2434 }
2435 }
2436 ret = (jobjectArray) JNIHandles::make_local(env, result);
2437 return ret;
2438 JNI_END
2439
2440 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
2441 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
2442
2443 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
2444 JNIWrapper("GetObjectArrayElement");
2445 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
2446 jobject ret = NULL;
2447 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
2448 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2449 if (a->is_within_bounds(index)) {
2450 ret = JNIHandles::make_local(env, a->obj_at(index));
2451 return ret;
2452 } else {
2453 ResourceMark rm(THREAD);
2454 stringStream ss;
2455 ss.print("Index %d out of bounds for length %d", index, a->length());
2456 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2457 }
2458 JNI_END
2459
2460 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
2461 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
2462
2463 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
2464 JNIWrapper("SetObjectArrayElement");
2465 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
2466 DT_VOID_RETURN_MARK(SetObjectArrayElement);
2467
2468 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2469 oop v = JNIHandles::resolve(value);
2470 if (a->is_within_bounds(index)) {
2490 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2491 }
2492 JNI_END
2493
2494
2495
2496 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
2497 ,EntryProbe,ReturnProbe) \
2498 \
2499 DT_RETURN_MARK_DECL(New##Result##Array, Return \
2500 , ReturnProbe); \
2501 \
2502 JNI_ENTRY(Return, \
2503 jni_New##Result##Array(JNIEnv *env, jsize len)) \
2504 JNIWrapper("New" XSTR(Result) "Array"); \
2505 EntryProbe; \
2506 Return ret = NULL;\
2507 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
2508 \
2509 oop obj= oopFactory::Allocator(len, CHECK_NULL); \
2510 ret = (Return) JNIHandles::make_local(env, obj); \
2511 return ret;\
2512 JNI_END
2513
2514 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean,
2515 HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len),
2516 HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref))
2517 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte,
2518 HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len),
2519 HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref))
2520 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short,
2521 HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len),
2522 HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref))
2523 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char,
2524 HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len),
2525 HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref))
2526 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int,
2527 HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len),
2528 HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref))
2529 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long,
2530 HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
|
327
328 if (UsePerfData && !class_loader.is_null()) {
329 // check whether the current caller thread holds the lock or not.
330 // If not, increment the corresponding counter
331 if (ObjectSynchronizer::
332 query_lock_ownership((JavaThread*)THREAD, class_loader) !=
333 ObjectSynchronizer::owner_self) {
334 ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();
335 }
336 }
337 Klass* k = SystemDictionary::resolve_from_stream(class_name,
338 class_loader,
339 Handle(),
340 &st,
341 CHECK_NULL);
342
343 if (log_is_enabled(Debug, class, resolve) && k != NULL) {
344 trace_class_resolution(k);
345 }
346
347 cls = (jclass)JNIHandles::make_local(THREAD, k->java_mirror());
348 return cls;
349 JNI_END
350
351
352
353 DT_RETURN_MARK_DECL(FindClass, jclass
354 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
355
356 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
357 JNIWrapper("FindClass");
358
359 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
360
361 jclass result = NULL;
362 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
363
364 // This should be ClassNotFoundException imo.
365 TempNewSymbol class_name =
366 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(),
367 CHECK_NULL);
483
484 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
485 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
486
487 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
488 JNIWrapper("ToReflectedMethod");
489
490 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
491
492 jobject ret = NULL;
493 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
494
495 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
496 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
497 oop reflection_method;
498 if (m->is_initializer()) {
499 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
500 } else {
501 reflection_method = Reflection::new_method(m, false, CHECK_NULL);
502 }
503 ret = JNIHandles::make_local(THREAD, reflection_method);
504 return ret;
505 JNI_END
506
507 DT_RETURN_MARK_DECL(GetSuperclass, jclass
508 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
509
510 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
511 JNIWrapper("GetSuperclass");
512
513 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
514
515 jclass obj = NULL;
516 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
517
518 oop mirror = JNIHandles::resolve_non_null(sub);
519 // primitive classes return NULL
520 if (java_lang_Class::is_primitive(mirror)) return NULL;
521
522 // Rules of Class.getSuperClass as implemented by KLass::java_super:
523 // arrays return Object
605 // exception in ExceptionOccurred and ExceptionCheck calls, since
606 // delivering an async exception in other places won't change the native
607 // code's control flow and would be harmful when native code further calls
608 // JNI functions with a pending exception. Async exception is also checked
609 // during the call, so ExceptionOccurred/ExceptionCheck won't return
610 // false but deliver the async exception at the very end during
611 // state transition.
612
613 static void jni_check_async_exceptions(JavaThread *thread) {
614 assert(thread == Thread::current(), "must be itself");
615 thread->check_and_handle_async_exceptions();
616 }
617
618 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
619 JNIWrapper("ExceptionOccurred");
620
621 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
622
623 jni_check_async_exceptions(thread);
624 oop exception = thread->pending_exception();
625 jthrowable ret = (jthrowable) JNIHandles::make_local(THREAD, exception);
626
627 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
628 return ret;
629 JNI_END
630
631
632 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
633 JNIWrapper("ExceptionDescribe");
634
635 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
636
637 if (thread->has_pending_exception()) {
638 Handle ex(thread, thread->pending_exception());
639 thread->clear_pending_exception();
640 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
641 // Don't print anything if we are being killed.
642 } else {
643 jio_fprintf(defaultStream::error_stream(), "Exception ");
644 if (thread != NULL && thread->threadObj() != NULL) {
645 ResourceMark rm(THREAD);
723 JNI_END
724
725
726 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
727 JNIWrapper("PopLocalFrame");
728
729 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
730
731 //%note jni_11
732 Handle result_handle(thread, JNIHandles::resolve(result));
733 JNIHandleBlock* old_handles = thread->active_handles();
734 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
735 if (new_handles != NULL) {
736 // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL.
737 // This way code will still work if PopLocalFrame is called without a corresponding
738 // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise
739 // the release_block call will release the blocks.
740 thread->set_active_handles(new_handles);
741 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
742 JNIHandleBlock::release_block(old_handles, thread); // may block
743 result = JNIHandles::make_local(THREAD, result_handle());
744 }
745 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
746 return result;
747 JNI_END
748
749
750 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
751 JNIWrapper("NewGlobalRef");
752
753 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
754
755 Handle ref_handle(thread, JNIHandles::resolve(ref));
756 jobject ret = JNIHandles::make_global(ref_handle);
757
758 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
759 return ret;
760 JNI_END
761
762 // Must be JNI_ENTRY (with HandleMark)
763 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
780 HOTSPOT_JNI_DELETELOCALREF_RETURN();
781 JNI_END
782
783 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
784 JNIWrapper("IsSameObject");
785
786 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
787
788 jboolean ret = JNIHandles::is_same_object(r1, r2) ? JNI_TRUE : JNI_FALSE;
789
790 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
791 return ret;
792 JNI_END
793
794
795 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
796 JNIWrapper("NewLocalRef");
797
798 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
799
800 jobject ret = JNIHandles::make_local(THREAD, JNIHandles::resolve(ref));
801
802 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
803 return ret;
804 JNI_END
805
806 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
807 JNIWrapper("EnsureLocalCapacity");
808
809 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
810
811 jint ret;
812 if (capacity >= 0 &&
813 ((MaxJNILocalCapacity <= 0) || (capacity <= MaxJNILocalCapacity))) {
814 ret = JNI_OK;
815 } else {
816 ret = JNI_ERR;
817 }
818
819 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
820 return ret;
958 methodHandle method(THREAD, Method::resolve_jmethod_id(method_id));
959
960 // Create object to hold arguments for the JavaCall, and associate it with
961 // the jni parser
962 ResourceMark rm(THREAD);
963 int number_of_parameters = method->size_of_parameters();
964 JavaCallArguments java_args(number_of_parameters);
965
966 assert(method->is_static(), "method should be static");
967
968 // Fill out JavaCallArguments object
969 args->push_arguments_on(&java_args);
970 // Initialize result type
971 result->set_type(args->return_type());
972
973 // Invoke the method. Result is returned as oop.
974 JavaCalls::call(result, method, &java_args, CHECK);
975
976 // Convert result
977 if (is_reference_type(result->get_type())) {
978 result->set_jobject(JNIHandles::make_local(THREAD, (oop) result->get_jobject()));
979 }
980 }
981
982
983 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
984 oop recv = JNIHandles::resolve(receiver);
985 if (recv == NULL) {
986 THROW(vmSymbols::java_lang_NullPointerException());
987 }
988 Handle h_recv(THREAD, recv);
989
990 int number_of_parameters;
991 Method* selected_method;
992 {
993 Method* m = Method::resolve_jmethod_id(method_id);
994 number_of_parameters = m->size_of_parameters();
995 Klass* holder = m->method_holder();
996 if (call_type != JNI_VIRTUAL) {
997 selected_method = m;
998 } else if (!m->has_itable_index()) {
1020
1021 // Create object to hold arguments for the JavaCall, and associate it with
1022 // the jni parser
1023 ResourceMark rm(THREAD);
1024 JavaCallArguments java_args(number_of_parameters);
1025
1026 // handle arguments
1027 assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
1028 java_args.push_oop(h_recv); // Push jobject handle
1029
1030 // Fill out JavaCallArguments object
1031 args->push_arguments_on(&java_args);
1032 // Initialize result type
1033 result->set_type(args->return_type());
1034
1035 // Invoke the method. Result is returned as oop.
1036 JavaCalls::call(result, method, &java_args, CHECK);
1037
1038 // Convert result
1039 if (is_reference_type(result->get_type())) {
1040 result->set_jobject(JNIHandles::make_local(THREAD, (oop) result->get_jobject()));
1041 }
1042 }
1043
1044 DT_RETURN_MARK_DECL(AllocObject, jobject
1045 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1046
1047 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1048 JNIWrapper("AllocObject");
1049
1050 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
1051
1052 jobject ret = NULL;
1053 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1054
1055 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1056 ret = JNIHandles::make_local(THREAD, i);
1057 return ret;
1058 JNI_END
1059
1060 DT_RETURN_MARK_DECL(NewObjectA, jobject
1061 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1062
1063 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
1064 JNIWrapper("NewObjectA");
1065
1066 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
1067
1068 jobject obj = NULL;
1069 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
1070
1071 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1072 obj = JNIHandles::make_local(THREAD, i);
1073 JavaValue jvalue(T_VOID);
1074 JNI_ArgumentPusherArray ap(methodID, args);
1075 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1076 return obj;
1077 JNI_END
1078
1079
1080 DT_RETURN_MARK_DECL(NewObjectV, jobject
1081 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1082
1083 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
1084 JNIWrapper("NewObjectV");
1085
1086 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
1087
1088 jobject obj = NULL;
1089 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
1090
1091 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1092 obj = JNIHandles::make_local(THREAD, i);
1093 JavaValue jvalue(T_VOID);
1094 JNI_ArgumentPusherVaArg ap(methodID, args);
1095 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1096 return obj;
1097 JNI_END
1098
1099
1100 DT_RETURN_MARK_DECL(NewObject, jobject
1101 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1102
1103 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1104 JNIWrapper("NewObject");
1105
1106 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
1107
1108 jobject obj = NULL;
1109 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1110
1111 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1112 obj = JNIHandles::make_local(THREAD, i);
1113 va_list args;
1114 va_start(args, methodID);
1115 JavaValue jvalue(T_VOID);
1116 JNI_ArgumentPusherVaArg ap(methodID, args);
1117 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1118 va_end(args);
1119 return obj;
1120 JNI_END
1121
1122
1123 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1124 JNIWrapper("GetObjectClass");
1125
1126 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
1127
1128 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1129 jclass ret =
1130 (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
1131
1132 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1133 return ret;
1134 JNI_END
1135
1136 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1137 JNIWrapper("IsInstanceOf");
1138
1139 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
1140
1141 jboolean ret = JNI_TRUE;
1142 if (obj != NULL) {
1143 ret = JNI_FALSE;
1144 Klass* k = java_lang_Class::as_Klass(
1145 JNIHandles::resolve_non_null(clazz));
1146 if (k != NULL) {
1147 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
1148 }
1149 }
1150
1892
1893 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
1894 // It may also have hash bits for k, if VerifyJNIFields is turned on.
1895 ret = jfieldIDWorkaround::to_instance_jfieldID(k, fd.offset());
1896 return ret;
1897 JNI_END
1898
1899
1900 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
1901 JNIWrapper("GetObjectField");
1902 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
1903 oop o = JNIHandles::resolve_non_null(obj);
1904 Klass* k = o->klass();
1905 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
1906 // Keep JVMTI addition small and only check enabled flag here.
1907 // jni_GetField_probe() assumes that is okay to create handles.
1908 if (JvmtiExport::should_post_field_access()) {
1909 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
1910 }
1911 oop loaded_obj = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(o, offset);
1912 jobject ret = JNIHandles::make_local(THREAD, loaded_obj);
1913 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
1914 return ret;
1915 JNI_END
1916
1917
1918
1919 #define DEFINE_GETFIELD(Return,Fieldname,Result \
1920 , EntryProbe, ReturnProbe) \
1921 \
1922 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
1923 , ReturnProbe); \
1924 \
1925 JNI_ENTRY_NO_PRESERVE(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
1926 JNIWrapper("Get" XSTR(Result) "Field"); \
1927 \
1928 EntryProbe; \
1929 Return ret = 0;\
1930 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
1931 \
1932 oop o = JNIHandles::resolve_non_null(obj); \
2072 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
2073
2074 fieldDescriptor fd;
2075 bool found = false;
2076 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2077
2078 assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
2079
2080 if (isStatic) {
2081 // Static field. The fieldID a JNIid specifying the field holder and the offset within the Klass*.
2082 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2083 assert(id->is_static_field_id(), "invalid static field id");
2084 found = id->find_local_field(&fd);
2085 } else {
2086 // Non-static field. The fieldID is really the offset of the field within the instanceOop.
2087 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2088 found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
2089 }
2090 assert(found, "bad fieldID passed into jni_ToReflectedField");
2091 oop reflected = Reflection::new_field(&fd, CHECK_NULL);
2092 ret = JNIHandles::make_local(THREAD, reflected);
2093 return ret;
2094 JNI_END
2095
2096
2097 //
2098 // Accessing Static Fields
2099 //
2100 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2101 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2102
2103 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2104 const char *name, const char *sig))
2105 JNIWrapper("GetStaticFieldID");
2106 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2107 jfieldID ret = NULL;
2108 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2109
2110 // The class should have been loaded (we have an instance of the class
2111 // passed in) so the field and signature should already be in the symbol
2112 // table. If they're not there, the field doesn't exist.
2259 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
2260 DEFINE_SETSTATICFIELD(jdouble, double, Double, JVM_SIGNATURE_DOUBLE, d
2261 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
2262 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
2263
2264 //
2265 // String Operations
2266 //
2267
2268 // Unicode Interface
2269
2270 DT_RETURN_MARK_DECL(NewString, jstring
2271 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
2272
2273 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
2274 JNIWrapper("NewString");
2275 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
2276 jstring ret = NULL;
2277 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
2278 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
2279 ret = (jstring) JNIHandles::make_local(THREAD, string);
2280 return ret;
2281 JNI_END
2282
2283
2284 JNI_ENTRY_NO_PRESERVE(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
2285 JNIWrapper("GetStringLength");
2286 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
2287 jsize ret = 0;
2288 oop s = JNIHandles::resolve_non_null(string);
2289 ret = java_lang_String::length(s);
2290 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
2291 return ret;
2292 JNI_END
2293
2294
2295 JNI_ENTRY_NO_PRESERVE(const jchar*, jni_GetStringChars(
2296 JNIEnv *env, jstring string, jboolean *isCopy))
2297 JNIWrapper("GetStringChars");
2298 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
2299 jchar* buf = NULL;
2335 // Since String objects are supposed to be immutable, don't copy any
2336 // new data back. A bad user will have to go after the char array.
2337 FreeHeap((void*) chars);
2338 }
2339 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
2340 JNI_END
2341
2342
2343 // UTF Interface
2344
2345 DT_RETURN_MARK_DECL(NewStringUTF, jstring
2346 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
2347
2348 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
2349 JNIWrapper("NewStringUTF");
2350 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
2351 jstring ret;
2352 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
2353
2354 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
2355 ret = (jstring) JNIHandles::make_local(THREAD, result);
2356 return ret;
2357 JNI_END
2358
2359
2360 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
2361 JNIWrapper("GetStringUTFLength");
2362 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
2363 oop java_string = JNIHandles::resolve_non_null(string);
2364 jsize ret = java_lang_String::utf8_length(java_string);
2365 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
2366 return ret;
2367 JNI_END
2368
2369
2370 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
2371 JNIWrapper("GetStringUTFChars");
2372 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
2373 char* result = NULL;
2374 oop java_string = JNIHandles::resolve_non_null(string);
2375 typeArrayOop s_value = java_lang_String::value(java_string);
2415 //
2416
2417 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
2418 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
2419
2420 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
2421 JNIWrapper("NewObjectArray");
2422 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
2423 jobjectArray ret = NULL;
2424 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
2425 Klass* ek = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass));
2426 Klass* ak = ek->array_klass(CHECK_NULL);
2427 ObjArrayKlass::cast(ak)->initialize(CHECK_NULL);
2428 objArrayOop result = ObjArrayKlass::cast(ak)->allocate(length, CHECK_NULL);
2429 oop initial_value = JNIHandles::resolve(initialElement);
2430 if (initial_value != NULL) { // array already initialized with NULL
2431 for (int index = 0; index < length; index++) {
2432 result->obj_at_put(index, initial_value);
2433 }
2434 }
2435 ret = (jobjectArray) JNIHandles::make_local(THREAD, result);
2436 return ret;
2437 JNI_END
2438
2439 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
2440 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
2441
2442 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
2443 JNIWrapper("GetObjectArrayElement");
2444 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
2445 jobject ret = NULL;
2446 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
2447 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2448 if (a->is_within_bounds(index)) {
2449 ret = JNIHandles::make_local(THREAD, a->obj_at(index));
2450 return ret;
2451 } else {
2452 ResourceMark rm(THREAD);
2453 stringStream ss;
2454 ss.print("Index %d out of bounds for length %d", index, a->length());
2455 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2456 }
2457 JNI_END
2458
2459 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
2460 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
2461
2462 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
2463 JNIWrapper("SetObjectArrayElement");
2464 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
2465 DT_VOID_RETURN_MARK(SetObjectArrayElement);
2466
2467 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2468 oop v = JNIHandles::resolve(value);
2469 if (a->is_within_bounds(index)) {
2489 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2490 }
2491 JNI_END
2492
2493
2494
2495 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
2496 ,EntryProbe,ReturnProbe) \
2497 \
2498 DT_RETURN_MARK_DECL(New##Result##Array, Return \
2499 , ReturnProbe); \
2500 \
2501 JNI_ENTRY(Return, \
2502 jni_New##Result##Array(JNIEnv *env, jsize len)) \
2503 JNIWrapper("New" XSTR(Result) "Array"); \
2504 EntryProbe; \
2505 Return ret = NULL;\
2506 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
2507 \
2508 oop obj= oopFactory::Allocator(len, CHECK_NULL); \
2509 ret = (Return) JNIHandles::make_local(THREAD, obj); \
2510 return ret;\
2511 JNI_END
2512
2513 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean,
2514 HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len),
2515 HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref))
2516 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte,
2517 HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len),
2518 HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref))
2519 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short,
2520 HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len),
2521 HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref))
2522 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char,
2523 HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len),
2524 HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref))
2525 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int,
2526 HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len),
2527 HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref))
2528 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long,
2529 HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
|