< prev index next >

src/hotspot/share/prims/jni.cpp

Print this page




 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))
 764   JNIWrapper("DeleteGlobalRef");
 765 
 766   HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
 767 
 768   JNIHandles::destroy_global(ref);
 769 
 770   HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
 771 JNI_END
 772 
 773 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
 774   JNIWrapper("DeleteLocalRef");
 775 
 776   HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);


 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;


3033 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
3034   JNIWrapper("ReleaseStringCritical");
3035   HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
3036   // The str and chars arguments are ignored for UTF16 strings
3037   oop s = JNIHandles::resolve_non_null(str);
3038   bool is_latin1 = java_lang_String::is_latin1(s);
3039   if (is_latin1) {
3040     // For latin1 string, free jchar array allocated by earlier call to GetStringCritical.
3041     // This assumes that ReleaseStringCritical bookends GetStringCritical.
3042     FREE_C_HEAP_ARRAY(jchar, chars);
3043   }
3044   unlock_gc_or_unpin_object(thread, str);
3045 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
3046 JNI_END
3047 
3048 
3049 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
3050   JNIWrapper("jni_NewWeakGlobalRef");
3051  HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
3052   Handle ref_handle(thread, JNIHandles::resolve(ref));
3053   jweak ret = JNIHandles::make_weak_global(ref_handle);



3054  HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
3055   return ret;
3056 JNI_END
3057 
3058 // Must be JNI_ENTRY (with HandleMark)
3059 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
3060   JNIWrapper("jni_DeleteWeakGlobalRef");
3061   HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
3062   JNIHandles::destroy_weak_global(ref);
3063   HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
3064 JNI_END
3065 
3066 
3067 JNI_ENTRY_NO_PRESERVE(jboolean, jni_ExceptionCheck(JNIEnv *env))
3068   JNIWrapper("jni_ExceptionCheck");
3069  HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
3070   jni_check_async_exceptions(thread);
3071   jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
3072  HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
3073   return ret;


3109   return true;
3110 }
3111 JNI_END
3112 
3113 
3114 static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
3115   if (directBufferSupportInitializeFailed) {
3116     return false;
3117   }
3118 
3119   if (Atomic::cmpxchg(&directBufferSupportInitializeStarted, 0, 1) == 0) {
3120     if (!lookupDirectBufferClasses(env)) {
3121       directBufferSupportInitializeFailed = 1;
3122       return false;
3123     }
3124 
3125     // Make global references for these
3126     bufferClass           = (jclass) env->NewGlobalRef(bufferClass);
3127     directBufferClass     = (jclass) env->NewGlobalRef(directBufferClass);
3128     directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);






3129 
3130     // Get needed field and method IDs
3131     directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
3132     if (env->ExceptionCheck()) {
3133       env->ExceptionClear();
3134       directBufferSupportInitializeFailed = 1;
3135       return false;
3136     }
3137     directBufferAddressField    = env->GetFieldID(bufferClass, "address", "J");
3138     if (env->ExceptionCheck()) {
3139       env->ExceptionClear();
3140       directBufferSupportInitializeFailed = 1;
3141       return false;
3142     }
3143     bufferCapacityField         = env->GetFieldID(bufferClass, "capacity", "I");
3144     if (env->ExceptionCheck()) {
3145       env->ExceptionClear();
3146       directBufferSupportInitializeFailed = 1;
3147       return false;
3148     }




 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, AllocFailStrategy::RETURN_NULL);
 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))
 764   JNIWrapper("DeleteGlobalRef");
 765 
 766   HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
 767 
 768   JNIHandles::destroy_global(ref);
 769 
 770   HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
 771 JNI_END
 772 
 773 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
 774   JNIWrapper("DeleteLocalRef");
 775 
 776   HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);


 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                                        AllocFailStrategy::RETURN_NULL);
 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;


3034 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
3035   JNIWrapper("ReleaseStringCritical");
3036   HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
3037   // The str and chars arguments are ignored for UTF16 strings
3038   oop s = JNIHandles::resolve_non_null(str);
3039   bool is_latin1 = java_lang_String::is_latin1(s);
3040   if (is_latin1) {
3041     // For latin1 string, free jchar array allocated by earlier call to GetStringCritical.
3042     // This assumes that ReleaseStringCritical bookends GetStringCritical.
3043     FREE_C_HEAP_ARRAY(jchar, chars);
3044   }
3045   unlock_gc_or_unpin_object(thread, str);
3046 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
3047 JNI_END
3048 
3049 
3050 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
3051   JNIWrapper("jni_NewWeakGlobalRef");
3052   HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
3053   Handle ref_handle(thread, JNIHandles::resolve(ref));
3054   jweak ret = JNIHandles::make_weak_global(ref_handle, AllocFailStrategy::RETURN_NULL);
3055   if (ret == NULL) {
3056     THROW_OOP_(Universe::out_of_memory_error_c_heap(), NULL);
3057   }
3058   HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
3059   return ret;
3060 JNI_END
3061 
3062 // Must be JNI_ENTRY (with HandleMark)
3063 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
3064   JNIWrapper("jni_DeleteWeakGlobalRef");
3065   HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
3066   JNIHandles::destroy_weak_global(ref);
3067   HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
3068 JNI_END
3069 
3070 
3071 JNI_ENTRY_NO_PRESERVE(jboolean, jni_ExceptionCheck(JNIEnv *env))
3072   JNIWrapper("jni_ExceptionCheck");
3073  HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
3074   jni_check_async_exceptions(thread);
3075   jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
3076  HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
3077   return ret;


3113   return true;
3114 }
3115 JNI_END
3116 
3117 
3118 static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
3119   if (directBufferSupportInitializeFailed) {
3120     return false;
3121   }
3122 
3123   if (Atomic::cmpxchg(&directBufferSupportInitializeStarted, 0, 1) == 0) {
3124     if (!lookupDirectBufferClasses(env)) {
3125       directBufferSupportInitializeFailed = 1;
3126       return false;
3127     }
3128 
3129     // Make global references for these
3130     bufferClass           = (jclass) env->NewGlobalRef(bufferClass);
3131     directBufferClass     = (jclass) env->NewGlobalRef(directBufferClass);
3132     directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
3133 
3134     // Global refs will be NULL if out-of-memory (no exception is pending)
3135     if (bufferClass == NULL || directBufferClass == NULL || directByteBufferClass == NULL) {
3136       directBufferSupportInitializeFailed = 1;
3137       return false;
3138     }
3139 
3140     // Get needed field and method IDs
3141     directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
3142     if (env->ExceptionCheck()) {
3143       env->ExceptionClear();
3144       directBufferSupportInitializeFailed = 1;
3145       return false;
3146     }
3147     directBufferAddressField    = env->GetFieldID(bufferClass, "address", "J");
3148     if (env->ExceptionCheck()) {
3149       env->ExceptionClear();
3150       directBufferSupportInitializeFailed = 1;
3151       return false;
3152     }
3153     bufferCapacityField         = env->GetFieldID(bufferClass, "capacity", "I");
3154     if (env->ExceptionCheck()) {
3155       env->ExceptionClear();
3156       directBufferSupportInitializeFailed = 1;
3157       return false;
3158     }


< prev index next >