hotspot/src/share/vm/prims/jni.cpp
changeset 19545 409c50cf1e5d
parent 18683 a6418e038255
child 19547 0f52d3bfe28c
equal deleted inserted replaced
19544:8f3ad1962aef 19545:409c50cf1e5d
  3232   DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
  3232   DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
  3233 #else /* USDT2 */
  3233 #else /* USDT2 */
  3234  HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(
  3234  HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(
  3235                                   env, string, (uintptr_t *) isCopy);
  3235                                   env, string, (uintptr_t *) isCopy);
  3236 #endif /* USDT2 */
  3236 #endif /* USDT2 */
  3237   //%note jni_5
       
  3238   if (isCopy != NULL) {
       
  3239     *isCopy = JNI_TRUE;
       
  3240   }
       
  3241   oop s = JNIHandles::resolve_non_null(string);
  3237   oop s = JNIHandles::resolve_non_null(string);
  3242   int s_len = java_lang_String::length(s);
  3238   int s_len = java_lang_String::length(s);
  3243   typeArrayOop s_value = java_lang_String::value(s);
  3239   typeArrayOop s_value = java_lang_String::value(s);
  3244   int s_offset = java_lang_String::offset(s);
  3240   int s_offset = java_lang_String::offset(s);
  3245   jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1, mtInternal);  // add one for zero termination
  3241   jchar* buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal);  // add one for zero termination
  3246   if (s_len > 0) {
  3242   /* JNI Specification states return NULL on OOM */
  3247     memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len);
  3243   if (buf != NULL) {
  3248   }
  3244     if (s_len > 0) {
  3249   buf[s_len] = 0;
  3245       memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len);
       
  3246     }
       
  3247     buf[s_len] = 0;
       
  3248     //%note jni_5
       
  3249     if (isCopy != NULL) {
       
  3250       *isCopy = JNI_TRUE;
       
  3251     }
       
  3252   }
  3250 #ifndef USDT2
  3253 #ifndef USDT2
  3251   DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
  3254   DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
  3252 #else /* USDT2 */
  3255 #else /* USDT2 */
  3253   HOTSPOT_JNI_GETSTRINGCHARS_RETURN(
  3256   HOTSPOT_JNI_GETSTRINGCHARS_RETURN(
  3254                                     buf);
  3257                                     buf);
  3333  HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(
  3336  HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(
  3334                                      env, string, (uintptr_t *) isCopy);
  3337                                      env, string, (uintptr_t *) isCopy);
  3335 #endif /* USDT2 */
  3338 #endif /* USDT2 */
  3336   oop java_string = JNIHandles::resolve_non_null(string);
  3339   oop java_string = JNIHandles::resolve_non_null(string);
  3337   size_t length = java_lang_String::utf8_length(java_string);
  3340   size_t length = java_lang_String::utf8_length(java_string);
  3338   char* result = AllocateHeap(length + 1, mtInternal);
  3341   /* JNI Specification states return NULL on OOM */
  3339   java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
  3342   char* result = AllocateHeap(length + 1, mtInternal, 0, AllocFailStrategy::RETURN_NULL);
  3340   if (isCopy != NULL) *isCopy = JNI_TRUE;
  3343   if (result != NULL) {
       
  3344     java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
       
  3345     if (isCopy != NULL) {
       
  3346       *isCopy = JNI_TRUE;
       
  3347     }
       
  3348   }
  3341 #ifndef USDT2
  3349 #ifndef USDT2
  3342   DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
  3350   DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
  3343 #else /* USDT2 */
  3351 #else /* USDT2 */
  3344  HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(
  3352  HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(
  3345                                       result);
  3353                                       result);
  3589     /* Empty array: legal but useless, can't return NULL. \
  3597     /* Empty array: legal but useless, can't return NULL. \
  3590      * Return a pointer to something useless. \
  3598      * Return a pointer to something useless. \
  3591      * Avoid asserts in typeArrayOop. */ \
  3599      * Avoid asserts in typeArrayOop. */ \
  3592     result = (ElementType*)get_bad_address(); \
  3600     result = (ElementType*)get_bad_address(); \
  3593   } else { \
  3601   } else { \
  3594     result = NEW_C_HEAP_ARRAY(ElementType, len, mtInternal); \
  3602     /* JNI Specification states return NULL on OOM */                    \
  3595     /* copy the array to the c chunk */ \
  3603     result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
  3596     memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
  3604     if (result != NULL) {                                                \
       
  3605       /* copy the array to the c chunk */                                \
       
  3606       memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len);      \
       
  3607       if (isCopy) {                                                      \
       
  3608         *isCopy = JNI_TRUE;                                              \
       
  3609       }                                                                  \
       
  3610     }                                                                    \
  3597   } \
  3611   } \
  3598   if (isCopy) *isCopy = JNI_TRUE; \
       
  3599   DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
  3612   DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
  3600   return result; \
  3613   return result; \
  3601 JNI_END
  3614 JNI_END
  3602 
  3615 
  3603 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
  3616 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
  3626     /* Empty array: legal but useless, can't return NULL. \
  3639     /* Empty array: legal but useless, can't return NULL. \
  3627      * Return a pointer to something useless. \
  3640      * Return a pointer to something useless. \
  3628      * Avoid asserts in typeArrayOop. */ \
  3641      * Avoid asserts in typeArrayOop. */ \
  3629     result = (ElementType*)get_bad_address(); \
  3642     result = (ElementType*)get_bad_address(); \
  3630   } else { \
  3643   } else { \
  3631     result = NEW_C_HEAP_ARRAY(ElementType, len, mtInternal); \
  3644     /* JNI Specification states return NULL on OOM */                    \
  3632     /* copy the array to the c chunk */ \
  3645     result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
  3633     memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
  3646     if (result != NULL) {                                                \
       
  3647       /* copy the array to the c chunk */                                \
       
  3648       memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len);      \
       
  3649       if (isCopy) {                                                      \
       
  3650         *isCopy = JNI_TRUE;                                              \
       
  3651       }                                                                  \
       
  3652     }                                                                    \
  3634   } \
  3653   } \
  3635   if (isCopy) *isCopy = JNI_TRUE; \
       
  3636   ReturnProbe; \
  3654   ReturnProbe; \
  3637   return result; \
  3655   return result; \
  3638 JNI_END
  3656 JNI_END
  3639 
  3657 
  3640 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
  3658 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool