Mercurial > hg > graal-jvmci-8

comparison src/share/vm/prims/jni.cpp @ 14380:e6195383bcaf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8034080: Remove the USDT1 dtrace code from Hotspot Reviewed-by: dholmes, coleenp
author sla
date Tue, 18 Feb 2014 09:15:40 +0100
parents c66479743828
children 3f406218c511
comparison
equal deleted inserted replaced
14379:c66479743828 14380:e6195383bcaf
112 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value); 112 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
113 // foo(CHECK_0) 113 // foo(CHECK_0)
114 // return_value = 5; 114 // return_value = 5;
115 // return return_value; 115 // return return_value;
116 // JNI_END 116 // JNI_END
117 #ifndef USDT2
118 #define DT_RETURN_MARK_DECL(name, type) \
119 HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \
120 DTRACE_ONLY( \
121 class DTraceReturnProbeMark_##name { \
122 public: \
123 const type& _ret_ref; \
124 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \
125 ~DTraceReturnProbeMark_##name() { \
126 HS_DTRACE_PROBE1(hotspot_jni, name##__return, _ret_ref); \
127 } \
128 } \
129 )
130 // Void functions are simpler since there's no return value
131 #define DT_VOID_RETURN_MARK_DECL(name) \
132 HS_DTRACE_PROBE_DECL0(hotspot_jni, name##__return); \
133 DTRACE_ONLY( \
134 class DTraceReturnProbeMark_##name { \
135 public: \
136 ~DTraceReturnProbeMark_##name() { \
137 HS_DTRACE_PROBE0(hotspot_jni, name##__return); \
138 } \
139 } \
140 )
141
142 #else /* USDT2 */
143
144 #define DT_RETURN_MARK_DECL(name, type, probe) \ 117 #define DT_RETURN_MARK_DECL(name, type, probe) \
145 DTRACE_ONLY( \ 118 DTRACE_ONLY( \
146 class DTraceReturnProbeMark_##name { \ 119 class DTraceReturnProbeMark_##name { \
147 public: \ 120 public: \
148 const type& _ret_ref; \ 121 const type& _ret_ref; \
160 ~DTraceReturnProbeMark_##name() { \ 133 ~DTraceReturnProbeMark_##name() { \
161 probe; \ 134 probe; \
162 } \ 135 } \
163 } \ 136 } \
164 ) 137 )
165 #endif /* USDT2 */
166 138
167 // Place these macros in the function to mark the return. Non-void 139 // Place these macros in the function to mark the return. Non-void
168 // functions need the type and address of the return value. 140 // functions need the type and address of the return value.
169 #define DT_RETURN_MARK(name, type, ref) \ 141 #define DT_RETURN_MARK(name, type, ref) \
170 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) ) 142 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
189 161
190 #define COMMA , 162 #define COMMA ,
191 163
192 // Choose DT_RETURN_MARK macros based on the type: float/double -> void 164 // Choose DT_RETURN_MARK macros based on the type: float/double -> void
193 // (dtrace doesn't do FP yet) 165 // (dtrace doesn't do FP yet)
194 #ifndef USDT2
195 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \
196 FP_SELECT(TypeName, \
197 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) )
198 #else /* USDT2 */
199 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \ 166 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \
200 FP_SELECT(TypeName, \ 167 FP_SELECT(TypeName, \
201 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) ) 168 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )
202 #endif /* USDT2 */
203 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ 169 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
204 FP_SELECT(TypeName, \ 170 FP_SELECT(TypeName, \
205 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) 171 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
206 172
207 173
356 #endif 322 #endif
357 323
358 324
359 // Implementation of JNI entries 325 // Implementation of JNI entries
360 326
361 #ifndef USDT2
362 DT_RETURN_MARK_DECL(DefineClass, jclass);
363 #else /* USDT2 */
364 DT_RETURN_MARK_DECL(DefineClass, jclass 327 DT_RETURN_MARK_DECL(DefineClass, jclass
365 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref)); 328 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
366 #endif /* USDT2 */
367 329
368 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, 330 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
369 const jbyte *buf, jsize bufLen)) 331 const jbyte *buf, jsize bufLen))
370 JNIWrapper("DefineClass"); 332 JNIWrapper("DefineClass");
371 333
372 #ifndef USDT2
373 DTRACE_PROBE5(hotspot_jni, DefineClass__entry,
374 env, name, loaderRef, buf, bufLen);
375 #else /* USDT2 */
376 HOTSPOT_JNI_DEFINECLASS_ENTRY( 334 HOTSPOT_JNI_DEFINECLASS_ENTRY(
377 env, (char*) name, loaderRef, (char*) buf, bufLen); 335 env, (char*) name, loaderRef, (char*) buf, bufLen);
378 #endif /* USDT2 */ 336
379 jclass cls = NULL; 337 jclass cls = NULL;
380 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); 338 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
381 339
382 TempNewSymbol class_name = NULL; 340 TempNewSymbol class_name = NULL;
383 // Since exceptions can be thrown, class initialization can take place 341 // Since exceptions can be thrown, class initialization can take place
419 377
420 378
421 379
422 static bool first_time_FindClass = true; 380 static bool first_time_FindClass = true;
423 381
424 #ifndef USDT2
425 DT_RETURN_MARK_DECL(FindClass, jclass);
426 #else /* USDT2 */
427 DT_RETURN_MARK_DECL(FindClass, jclass 382 DT_RETURN_MARK_DECL(FindClass, jclass
428 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref)); 383 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
429 #endif /* USDT2 */
430 384
431 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name)) 385 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
432 JNIWrapper("FindClass"); 386 JNIWrapper("FindClass");
433 #ifndef USDT2 387
434 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);
435 #else /* USDT2 */
436 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name); 388 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
437 #endif /* USDT2 */
438 389
439 jclass result = NULL; 390 jclass result = NULL;
440 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result); 391 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
441 392
442 // Remember if we are the first invocation of jni_FindClass 393 // Remember if we are the first invocation of jni_FindClass
496 CompilationPolicy::completed_vm_startup(); 447 CompilationPolicy::completed_vm_startup();
497 448
498 return result; 449 return result;
499 JNI_END 450 JNI_END
500 451
501 #ifndef USDT2
502 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID);
503 #else /* USDT2 */
504 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID 452 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
505 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref)); 453 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
506 #endif /* USDT2 */
507 454
508 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method)) 455 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
509 JNIWrapper("FromReflectedMethod"); 456 JNIWrapper("FromReflectedMethod");
510 #ifndef USDT2 457
511 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method);
512 #else /* USDT2 */
513 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method); 458 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
514 #endif /* USDT2 */ 459
515 jmethodID ret = NULL; 460 jmethodID ret = NULL;
516 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret); 461 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
517 462
518 // method is a handle to a java.lang.reflect.Method object 463 // method is a handle to a java.lang.reflect.Method object
519 oop reflected = JNIHandles::resolve_non_null(method); 464 oop reflected = JNIHandles::resolve_non_null(method);
536 Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot); 481 Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot);
537 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted 482 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
538 return ret; 483 return ret;
539 JNI_END 484 JNI_END
540 485
541 #ifndef USDT2
542 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID);
543 #else /* USDT2 */
544 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID 486 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
545 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref)); 487 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
546 #endif /* USDT2 */
547 488
548 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field)) 489 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
549 JNIWrapper("FromReflectedField"); 490 JNIWrapper("FromReflectedField");
550 #ifndef USDT2 491
551 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field);
552 #else /* USDT2 */
553 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field); 492 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
554 #endif /* USDT2 */ 493
555 jfieldID ret = NULL; 494 jfieldID ret = NULL;
556 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret); 495 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
557 496
558 // field is a handle to a java.lang.reflect.Field object 497 // field is a handle to a java.lang.reflect.Field object
559 oop reflected = JNIHandles::resolve_non_null(field); 498 oop reflected = JNIHandles::resolve_non_null(field);
584 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); 523 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
585 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); 524 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
586 return ret; 525 return ret;
587 JNI_END 526 JNI_END
588 527
589 #ifndef USDT2 528
590 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject);
591 #else /* USDT2 */
592 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject 529 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
593 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref)); 530 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
594 #endif /* USDT2 */
595 531
596 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) 532 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
597 JNIWrapper("ToReflectedMethod"); 533 JNIWrapper("ToReflectedMethod");
598 #ifndef USDT2 534
599 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);
600 #else /* USDT2 */
601 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic); 535 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
602 #endif /* USDT2 */ 536
603 jobject ret = NULL; 537 jobject ret = NULL;
604 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); 538 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
605 539
606 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id)); 540 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
607 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); 541 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
613 } 547 }
614 ret = JNIHandles::make_local(env, reflection_method); 548 ret = JNIHandles::make_local(env, reflection_method);
615 return ret; 549 return ret;
616 JNI_END 550 JNI_END
617 551
618 #ifndef USDT2
619 DT_RETURN_MARK_DECL(GetSuperclass, jclass);
620 #else /* USDT2 */
621 DT_RETURN_MARK_DECL(GetSuperclass, jclass 552 DT_RETURN_MARK_DECL(GetSuperclass, jclass
622 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref)); 553 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
623 #endif /* USDT2 */
624 554
625 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub)) 555 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
626 JNIWrapper("GetSuperclass"); 556 JNIWrapper("GetSuperclass");
627 #ifndef USDT2 557
628 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub);
629 #else /* USDT2 */
630 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub); 558 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
631 #endif /* USDT2 */ 559
632 jclass obj = NULL; 560 jclass obj = NULL;
633 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj); 561 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
634 562
635 oop mirror = JNIHandles::resolve_non_null(sub); 563 oop mirror = JNIHandles::resolve_non_null(sub);
636 // primitive classes return NULL 564 // primitive classes return NULL
655 return obj; 583 return obj;
656 JNI_END 584 JNI_END
657 585
658 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) 586 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
659 JNIWrapper("IsSubclassOf"); 587 JNIWrapper("IsSubclassOf");
660 #ifndef USDT2 588
661 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super);
662 #else /* USDT2 */
663 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super); 589 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
664 #endif /* USDT2 */ 590
665 oop sub_mirror = JNIHandles::resolve_non_null(sub); 591 oop sub_mirror = JNIHandles::resolve_non_null(sub);
666 oop super_mirror = JNIHandles::resolve_non_null(super); 592 oop super_mirror = JNIHandles::resolve_non_null(super);
667 if (java_lang_Class::is_primitive(sub_mirror) || 593 if (java_lang_Class::is_primitive(sub_mirror) ||
668 java_lang_Class::is_primitive(super_mirror)) { 594 java_lang_Class::is_primitive(super_mirror)) {
669 jboolean ret = (sub_mirror == super_mirror); 595 jboolean ret = (sub_mirror == super_mirror);
670 #ifndef USDT2 596
671 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
672 #else /* USDT2 */
673 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); 597 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
674 #endif /* USDT2 */
675 return ret; 598 return ret;
676 } 599 }
677 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror); 600 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
678 Klass* super_klass = java_lang_Class::as_Klass(super_mirror); 601 Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
679 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); 602 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
680 jboolean ret = sub_klass->is_subtype_of(super_klass) ? 603 jboolean ret = sub_klass->is_subtype_of(super_klass) ?
681 JNI_TRUE : JNI_FALSE; 604 JNI_TRUE : JNI_FALSE;
682 #ifndef USDT2 605
683 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
684 #else /* USDT2 */
685 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); 606 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
686 #endif /* USDT2 */
687 return ret; 607 return ret;
688 JNI_END 608 JNI_END
689 609
690 #ifndef USDT2 610
691 DT_RETURN_MARK_DECL(Throw, jint);
692 #else /* USDT2 */
693 DT_RETURN_MARK_DECL(Throw, jint 611 DT_RETURN_MARK_DECL(Throw, jint
694 , HOTSPOT_JNI_THROW_RETURN(_ret_ref)); 612 , HOTSPOT_JNI_THROW_RETURN(_ret_ref));
695 #endif /* USDT2 */
696 613
697 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) 614 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
698 JNIWrapper("Throw"); 615 JNIWrapper("Throw");
699 #ifndef USDT2 616
700 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj);
701 #else /* USDT2 */
702 HOTSPOT_JNI_THROW_ENTRY(env, obj); 617 HOTSPOT_JNI_THROW_ENTRY(env, obj);
703 #endif /* USDT2 */ 618
704 jint ret = JNI_OK; 619 jint ret = JNI_OK;
705 DT_RETURN_MARK(Throw, jint, (const jint&)ret); 620 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
706 621
707 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); 622 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
708 ShouldNotReachHere(); 623 ShouldNotReachHere();
709 JNI_END 624 JNI_END
710 625
711 #ifndef USDT2 626
712 DT_RETURN_MARK_DECL(ThrowNew, jint);
713 #else /* USDT2 */
714 DT_RETURN_MARK_DECL(ThrowNew, jint 627 DT_RETURN_MARK_DECL(ThrowNew, jint
715 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref)); 628 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
716 #endif /* USDT2 */
717 629
718 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) 630 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
719 JNIWrapper("ThrowNew"); 631 JNIWrapper("ThrowNew");
720 #ifndef USDT2 632
721 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
722 #else /* USDT2 */
723 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message); 633 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
724 #endif /* USDT2 */ 634
725 jint ret = JNI_OK; 635 jint ret = JNI_OK;
726 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); 636 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
727 637
728 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 638 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
729 Symbol* name = k->name(); 639 Symbol* name = k->name();
748 thread->check_and_handle_async_exceptions(); 658 thread->check_and_handle_async_exceptions();
749 } 659 }
750 660
751 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) 661 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
752 JNIWrapper("ExceptionOccurred"); 662 JNIWrapper("ExceptionOccurred");
753 #ifndef USDT2 663
754 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env);
755 #else /* USDT2 */
756 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env); 664 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
757 #endif /* USDT2 */ 665
758 jni_check_async_exceptions(thread); 666 jni_check_async_exceptions(thread);
759 oop exception = thread->pending_exception(); 667 oop exception = thread->pending_exception();
760 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); 668 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
761 #ifndef USDT2 669
762 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret);
763 #else /* USDT2 */
764 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret); 670 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
765 #endif /* USDT2 */
766 return ret; 671 return ret;
767 JNI_END 672 JNI_END
768 673
769 674
770 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) 675 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
771 JNIWrapper("ExceptionDescribe"); 676 JNIWrapper("ExceptionDescribe");
772 #ifndef USDT2 677
773 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env);
774 #else /* USDT2 */
775 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env); 678 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
776 #endif /* USDT2 */ 679
777 if (thread->has_pending_exception()) { 680 if (thread->has_pending_exception()) {
778 Handle ex(thread, thread->pending_exception()); 681 Handle ex(thread, thread->pending_exception());
779 thread->clear_pending_exception(); 682 thread->clear_pending_exception();
780 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { 683 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
781 // Don't print anything if we are being killed. 684 // Don't print anything if we are being killed.
807 ". Uncaught exception of type %s.", 710 ". Uncaught exception of type %s.",
808 ex->klass()->external_name()); 711 ex->klass()->external_name());
809 } 712 }
810 } 713 }
811 } 714 }
812 #ifndef USDT2 715
813 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
814 #else /* USDT2 */
815 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(); 716 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
816 #endif /* USDT2 */
817 JNI_END 717 JNI_END
818 718
819 719
820 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) 720 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
821 JNIWrapper("ExceptionClear"); 721 JNIWrapper("ExceptionClear");
822 #ifndef USDT2 722
823 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env);
824 #else /* USDT2 */
825 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env); 723 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
826 #endif /* USDT2 */
827 724
828 // The jni code might be using this API to clear java thrown exception. 725 // The jni code might be using this API to clear java thrown exception.
829 // So just mark jvmti thread exception state as exception caught. 726 // So just mark jvmti thread exception state as exception caught.
830 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); 727 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
831 if (state != NULL && state->is_exception_detected()) { 728 if (state != NULL && state->is_exception_detected()) {
832 state->set_exception_caught(); 729 state->set_exception_caught();
833 } 730 }
834 thread->clear_pending_exception(); 731 thread->clear_pending_exception();
835 #ifndef USDT2 732
836 DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
837 #else /* USDT2 */
838 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(); 733 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
839 #endif /* USDT2 */
840 JNI_END 734 JNI_END
841 735
842 736
843 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) 737 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
844 JNIWrapper("FatalError"); 738 JNIWrapper("FatalError");
845 #ifndef USDT2 739
846 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg);
847 #else /* USDT2 */
848 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg); 740 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
849 #endif /* USDT2 */ 741
850 tty->print_cr("FATAL ERROR in native method: %s", msg); 742 tty->print_cr("FATAL ERROR in native method: %s", msg);
851 thread->print_stack(); 743 thread->print_stack();
852 os::abort(); // Dump core and abort 744 os::abort(); // Dump core and abort
853 JNI_END 745 JNI_END
854 746
855 747
856 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) 748 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
857 JNIWrapper("PushLocalFrame"); 749 JNIWrapper("PushLocalFrame");
858 #ifndef USDT2 750
859 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity);
860 #else /* USDT2 */
861 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity); 751 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
862 #endif /* USDT2 */ 752
863 //%note jni_11 753 //%note jni_11
864 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) { 754 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) {
865 #ifndef USDT2
866 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR);
867 #else /* USDT2 */
868 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR); 755 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
869 #endif /* USDT2 */
870 return JNI_ERR; 756 return JNI_ERR;
871 } 757 }
872 JNIHandleBlock* old_handles = thread->active_handles(); 758 JNIHandleBlock* old_handles = thread->active_handles();
873 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); 759 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
874 assert(new_handles != NULL, "should not be NULL"); 760 assert(new_handles != NULL, "should not be NULL");
875 new_handles->set_pop_frame_link(old_handles); 761 new_handles->set_pop_frame_link(old_handles);
876 thread->set_active_handles(new_handles); 762 thread->set_active_handles(new_handles);
877 jint ret = JNI_OK; 763 jint ret = JNI_OK;
878 #ifndef USDT2
879 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret);
880 #else /* USDT2 */
881 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret); 764 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
882 #endif /* USDT2 */
883 return ret; 765 return ret;
884 JNI_END 766 JNI_END
885 767
886 768
887 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) 769 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
888 JNIWrapper("PopLocalFrame"); 770 JNIWrapper("PopLocalFrame");
889 #ifndef USDT2 771
890 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result);
891 #else /* USDT2 */
892 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result); 772 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
893 #endif /* USDT2 */ 773
894 //%note jni_11 774 //%note jni_11
895 Handle result_handle(thread, JNIHandles::resolve(result)); 775 Handle result_handle(thread, JNIHandles::resolve(result));
896 JNIHandleBlock* old_handles = thread->active_handles(); 776 JNIHandleBlock* old_handles = thread->active_handles();
897 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); 777 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
898 if (new_handles != NULL) { 778 if (new_handles != NULL) {
903 thread->set_active_handles(new_handles); 783 thread->set_active_handles(new_handles);
904 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below 784 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
905 JNIHandleBlock::release_block(old_handles, thread); // may block 785 JNIHandleBlock::release_block(old_handles, thread); // may block
906 result = JNIHandles::make_local(thread, result_handle()); 786 result = JNIHandles::make_local(thread, result_handle());
907 } 787 }
908 #ifndef USDT2
909 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
910 #else /* USDT2 */
911 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result); 788 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
912 #endif /* USDT2 */
913 return result; 789 return result;
914 JNI_END 790 JNI_END
915 791
916 792
917 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) 793 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
918 JNIWrapper("NewGlobalRef"); 794 JNIWrapper("NewGlobalRef");
919 #ifndef USDT2 795
920 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref);
921 #else /* USDT2 */
922 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref); 796 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
923 #endif /* USDT2 */ 797
924 Handle ref_handle(thread, JNIHandles::resolve(ref)); 798 Handle ref_handle(thread, JNIHandles::resolve(ref));
925 jobject ret = JNIHandles::make_global(ref_handle); 799 jobject ret = JNIHandles::make_global(ref_handle);
926 #ifndef USDT2 800
927 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret);
928 #else /* USDT2 */
929 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret); 801 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
930 #endif /* USDT2 */
931 return ret; 802 return ret;
932 JNI_END 803 JNI_END
933 804
934 // Must be JNI_ENTRY (with HandleMark) 805 // Must be JNI_ENTRY (with HandleMark)
935 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) 806 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
936 JNIWrapper("DeleteGlobalRef"); 807 JNIWrapper("DeleteGlobalRef");
937 #ifndef USDT2 808
938 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref);
939 #else /* USDT2 */
940 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref); 809 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
941 #endif /* USDT2 */ 810
942 JNIHandles::destroy_global(ref); 811 JNIHandles::destroy_global(ref);
943 #ifndef USDT2 812
944 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
945 #else /* USDT2 */
946 HOTSPOT_JNI_DELETEGLOBALREF_RETURN(); 813 HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
947 #endif /* USDT2 */
948 JNI_END 814 JNI_END
949 815
950 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) 816 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
951 JNIWrapper("DeleteLocalRef"); 817 JNIWrapper("DeleteLocalRef");
952 #ifndef USDT2 818
953 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj);
954 #else /* USDT2 */
955 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj); 819 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
956 #endif /* USDT2 */ 820
957 JNIHandles::destroy_local(obj); 821 JNIHandles::destroy_local(obj);
958 #ifndef USDT2 822
959 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
960 #else /* USDT2 */
961 HOTSPOT_JNI_DELETELOCALREF_RETURN(); 823 HOTSPOT_JNI_DELETELOCALREF_RETURN();
962 #endif /* USDT2 */
963 JNI_END 824 JNI_END
964 825
965 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) 826 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
966 JNIWrapper("IsSameObject"); 827 JNIWrapper("IsSameObject");
967 #ifndef USDT2 828
968 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2);
969 #else /* USDT2 */
970 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2); 829 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
971 #endif /* USDT2 */ 830
972 oop a = JNIHandles::resolve(r1); 831 oop a = JNIHandles::resolve(r1);
973 oop b = JNIHandles::resolve(r2); 832 oop b = JNIHandles::resolve(r2);
974 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; 833 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
975 #ifndef USDT2 834
976 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret);
977 #else /* USDT2 */
978 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret); 835 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
979 #endif /* USDT2 */
980 return ret; 836 return ret;
981 JNI_END 837 JNI_END
982 838
983 839
984 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) 840 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
985 JNIWrapper("NewLocalRef"); 841 JNIWrapper("NewLocalRef");
986 #ifndef USDT2 842
987 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref);
988 #else /* USDT2 */
989 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref); 843 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
990 #endif /* USDT2 */ 844
991 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); 845 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
992 #ifndef USDT2 846
993 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret);
994 #else /* USDT2 */
995 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret); 847 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
996 #endif /* USDT2 */
997 return ret; 848 return ret;
998 JNI_END 849 JNI_END
999 850
1000 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) 851 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
1001 JNIWrapper("EnsureLocalCapacity"); 852 JNIWrapper("EnsureLocalCapacity");
1002 #ifndef USDT2 853
1003 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity);
1004 #else /* USDT2 */
1005 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity); 854 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
1006 #endif /* USDT2 */ 855
1007 jint ret; 856 jint ret;
1008 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { 857 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) {
1009 ret = JNI_OK; 858 ret = JNI_OK;
1010 } else { 859 } else {
1011 ret = JNI_ERR; 860 ret = JNI_ERR;
1012 } 861 }
1013 #ifndef USDT2 862
1014 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret);
1015 #else /* USDT2 */
1016 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret); 863 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
1017 #endif /* USDT2 */
1018 return ret; 864 return ret;
1019 JNI_END 865 JNI_END
1020 866
1021 // Return the Handle Type 867 // Return the Handle Type
1022 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) 868 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
1023 JNIWrapper("GetObjectRefType"); 869 JNIWrapper("GetObjectRefType");
1024 #ifndef USDT2 870
1025 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj);
1026 #else /* USDT2 */
1027 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj); 871 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
1028 #endif /* USDT2 */ 872
1029 jobjectRefType ret; 873 jobjectRefType ret;
1030 if (JNIHandles::is_local_handle(thread, obj) || 874 if (JNIHandles::is_local_handle(thread, obj) ||
1031 JNIHandles::is_frame_handle(thread, obj)) 875 JNIHandles::is_frame_handle(thread, obj))
1032 ret = JNILocalRefType; 876 ret = JNILocalRefType;
1033 else if (JNIHandles::is_global_handle(obj)) 877 else if (JNIHandles::is_global_handle(obj))
1034 ret = JNIGlobalRefType; 878 ret = JNIGlobalRefType;
1035 else if (JNIHandles::is_weak_global_handle(obj)) 879 else if (JNIHandles::is_weak_global_handle(obj))
1036 ret = JNIWeakGlobalRefType; 880 ret = JNIWeakGlobalRefType;
1037 else 881 else
1038 ret = JNIInvalidRefType; 882 ret = JNIInvalidRefType;
1039 #ifndef USDT2 883
1040 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
1041 #else /* USDT2 */
1042 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret); 884 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
1043 #endif /* USDT2 */
1044 return ret; 885 return ret;
1045 JNI_END 886 JNI_END
1046 887
1047 888
1048 class JNI_ArgumentPusher : public SignatureIterator { 889 class JNI_ArgumentPusher : public SignatureIterator {
1367 InstanceKlass::cast(k())->initialize(CHECK_NULL); 1208 InstanceKlass::cast(k())->initialize(CHECK_NULL);
1368 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD); 1209 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD);
1369 return ih; 1210 return ih;
1370 } 1211 }
1371 1212
1372 #ifndef USDT2
1373 DT_RETURN_MARK_DECL(AllocObject, jobject);
1374 #else /* USDT2 */
1375 DT_RETURN_MARK_DECL(AllocObject, jobject 1213 DT_RETURN_MARK_DECL(AllocObject, jobject
1376 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref)); 1214 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1377 #endif /* USDT2 */
1378 1215
1379 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) 1216 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1380 JNIWrapper("AllocObject"); 1217 JNIWrapper("AllocObject");
1381 1218
1382 #ifndef USDT2
1383 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
1384 #else /* USDT2 */
1385 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz); 1219 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
1386 #endif /* USDT2 */ 1220
1387 jobject ret = NULL; 1221 jobject ret = NULL;
1388 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); 1222 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1389 1223
1390 instanceOop i = alloc_object(clazz, CHECK_NULL); 1224 instanceOop i = alloc_object(clazz, CHECK_NULL);
1391 ret = JNIHandles::make_local(env, i); 1225 ret = JNIHandles::make_local(env, i);
1392 return ret; 1226 return ret;
1393 JNI_END 1227 JNI_END
1394 1228
1395 #ifndef USDT2
1396 DT_RETURN_MARK_DECL(NewObjectA, jobject);
1397 #else /* USDT2 */
1398 DT_RETURN_MARK_DECL(NewObjectA, jobject 1229 DT_RETURN_MARK_DECL(NewObjectA, jobject
1399 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref)); 1230 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1400 #endif /* USDT2 */
1401 1231
1402 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) 1232 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
1403 JNIWrapper("NewObjectA"); 1233 JNIWrapper("NewObjectA");
1404 #ifndef USDT2 1234
1405 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID);
1406 #else /* USDT2 */
1407 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID); 1235 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
1408 #endif /* USDT2 */ 1236
1409 jobject obj = NULL; 1237 jobject obj = NULL;
1410 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); 1238 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
1411 1239
1412 instanceOop i = alloc_object(clazz, CHECK_NULL); 1240 instanceOop i = alloc_object(clazz, CHECK_NULL);
1413 obj = JNIHandles::make_local(env, i); 1241 obj = JNIHandles::make_local(env, i);
1415 JNI_ArgumentPusherArray ap(methodID, args); 1243 JNI_ArgumentPusherArray ap(methodID, args);
1416 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1244 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1417 return obj; 1245 return obj;
1418 JNI_END 1246 JNI_END
1419 1247
1420 #ifndef USDT2 1248
1421 DT_RETURN_MARK_DECL(NewObjectV, jobject);
1422 #else /* USDT2 */
1423 DT_RETURN_MARK_DECL(NewObjectV, jobject 1249 DT_RETURN_MARK_DECL(NewObjectV, jobject
1424 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref)); 1250 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1425 #endif /* USDT2 */
1426 1251
1427 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) 1252 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
1428 JNIWrapper("NewObjectV"); 1253 JNIWrapper("NewObjectV");
1429 #ifndef USDT2 1254
1430 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID);
1431 #else /* USDT2 */
1432 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID); 1255 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
1433 #endif /* USDT2 */ 1256
1434 jobject obj = NULL; 1257 jobject obj = NULL;
1435 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); 1258 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
1436 1259
1437 instanceOop i = alloc_object(clazz, CHECK_NULL); 1260 instanceOop i = alloc_object(clazz, CHECK_NULL);
1438 obj = JNIHandles::make_local(env, i); 1261 obj = JNIHandles::make_local(env, i);
1440 JNI_ArgumentPusherVaArg ap(methodID, args); 1263 JNI_ArgumentPusherVaArg ap(methodID, args);
1441 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1264 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1442 return obj; 1265 return obj;
1443 JNI_END 1266 JNI_END
1444 1267
1445 #ifndef USDT2 1268
1446 DT_RETURN_MARK_DECL(NewObject, jobject);
1447 #else /* USDT2 */
1448 DT_RETURN_MARK_DECL(NewObject, jobject 1269 DT_RETURN_MARK_DECL(NewObject, jobject
1449 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref)); 1270 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1450 #endif /* USDT2 */
1451 1271
1452 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) 1272 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1453 JNIWrapper("NewObject"); 1273 JNIWrapper("NewObject");
1454 #ifndef USDT2 1274
1455 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID);
1456 #else /* USDT2 */
1457 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID); 1275 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
1458 #endif /* USDT2 */ 1276
1459 jobject obj = NULL; 1277 jobject obj = NULL;
1460 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); 1278 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1461 1279
1462 instanceOop i = alloc_object(clazz, CHECK_NULL); 1280 instanceOop i = alloc_object(clazz, CHECK_NULL);
1463 obj = JNIHandles::make_local(env, i); 1281 obj = JNIHandles::make_local(env, i);
1471 JNI_END 1289 JNI_END
1472 1290
1473 1291
1474 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) 1292 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1475 JNIWrapper("GetObjectClass"); 1293 JNIWrapper("GetObjectClass");
1476 #ifndef USDT2 1294
1477 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
1478 #else /* USDT2 */
1479 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj); 1295 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
1480 #endif /* USDT2 */ 1296
1481 Klass* k = JNIHandles::resolve_non_null(obj)->klass(); 1297 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1482 jclass ret = 1298 jclass ret =
1483 (jclass) JNIHandles::make_local(env, k->java_mirror()); 1299 (jclass) JNIHandles::make_local(env, k->java_mirror());
1484 #ifndef USDT2 1300
1485 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
1486 #else /* USDT2 */
1487 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret); 1301 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1488 #endif /* USDT2 */
1489 return ret; 1302 return ret;
1490 JNI_END 1303 JNI_END
1491 1304
1492 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) 1305 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1493 JNIWrapper("IsInstanceOf"); 1306 JNIWrapper("IsInstanceOf");
1494 #ifndef USDT2 1307
1495 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz);
1496 #else /* USDT2 */
1497 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz); 1308 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
1498 #endif /* USDT2 */ 1309
1499 jboolean ret = JNI_TRUE; 1310 jboolean ret = JNI_TRUE;
1500 if (obj != NULL) { 1311 if (obj != NULL) {
1501 ret = JNI_FALSE; 1312 ret = JNI_FALSE;
1502 Klass* k = java_lang_Class::as_Klass( 1313 Klass* k = java_lang_Class::as_Klass(
1503 JNIHandles::resolve_non_null(clazz)); 1314 JNIHandles::resolve_non_null(clazz));
1504 if (k != NULL) { 1315 if (k != NULL) {
1505 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; 1316 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
1506 } 1317 }
1507 } 1318 }
1508 #ifndef USDT2 1319
1509 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
1510 #else /* USDT2 */
1511 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret); 1320 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
1512 #endif /* USDT2 */
1513 return ret; 1321 return ret;
1514 JNI_END 1322 JNI_END
1515 1323
1516 1324
1517 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, 1325 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
1567 1375
1568 1376
1569 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, 1377 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
1570 const char *name, const char *sig)) 1378 const char *name, const char *sig))
1571 JNIWrapper("GetMethodID"); 1379 JNIWrapper("GetMethodID");
1572 #ifndef USDT2
1573 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig);
1574 #else /* USDT2 */
1575 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig); 1380 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1576 #endif /* USDT2 */
1577 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); 1381 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1578 #ifndef USDT2
1579 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret);
1580 #else /* USDT2 */
1581 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret); 1382 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1582 #endif /* USDT2 */
1583 return ret; 1383 return ret;
1584 JNI_END 1384 JNI_END
1585 1385
1586 1386
1587 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, 1387 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
1588 const char *name, const char *sig)) 1388 const char *name, const char *sig))
1589 JNIWrapper("GetStaticMethodID"); 1389 JNIWrapper("GetStaticMethodID");
1590 #ifndef USDT2
1591 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig);
1592 #else /* USDT2 */
1593 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig); 1390 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
1594 #endif /* USDT2 */
1595 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); 1391 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
1596 #ifndef USDT2
1597 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret);
1598 #else /* USDT2 */
1599 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret); 1392 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
1600 #endif /* USDT2 */
1601 return ret; 1393 return ret;
1602 JNI_END 1394 JNI_END
1603 1395
1604 1396
1605 1397
1606 // 1398 //
1607 // Calling Methods 1399 // Calling Methods
1608 // 1400 //
1609 1401
1610 #ifndef USDT2
1611 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \
1612 \
1613 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\
1614 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\
1615 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\
1616 \
1617 JNI_ENTRY(ResultType, \
1618 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
1619 JNIWrapper("Call" XSTR(Result) "Method"); \
1620 \
1621 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \
1622 ResultType ret = 0;\
1623 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
1624 (const ResultType&)ret);\
1625 \
1626 va_list args; \
1627 va_start(args, methodID); \
1628 JavaValue jvalue(Tag); \
1629 JNI_ArgumentPusherVaArg ap(methodID, args); \
1630 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1631 va_end(args); \
1632 ret = jvalue.get_##ResultType(); \
1633 return ret;\
1634 JNI_END \
1635 \
1636 \
1637 JNI_ENTRY(ResultType, \
1638 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
1639 JNIWrapper("Call" XSTR(Result) "MethodV"); \
1640 \
1641 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID); \
1642 ResultType ret = 0;\
1643 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
1644 (const ResultType&)ret);\
1645 \
1646 JavaValue jvalue(Tag); \
1647 JNI_ArgumentPusherVaArg ap(methodID, args); \
1648 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1649 ret = jvalue.get_##ResultType(); \
1650 return ret;\
1651 JNI_END \
1652 \
1653 \
1654 JNI_ENTRY(ResultType, \
1655 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
1656 JNIWrapper("Call" XSTR(Result) "MethodA"); \
1657 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID); \
1658 ResultType ret = 0;\
1659 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
1660 (const ResultType&)ret);\
1661 \
1662 JavaValue jvalue(Tag); \
1663 JNI_ArgumentPusherArray ap(methodID, args); \
1664 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1665 ret = jvalue.get_##ResultType(); \
1666 return ret;\
1667 JNI_END
1668
1669 // the runtime type of subword integral basic types is integer
1670 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN)
1671 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE)
1672 DEFINE_CALLMETHOD(jchar, Char, T_CHAR)
1673 DEFINE_CALLMETHOD(jshort, Short, T_SHORT)
1674
1675 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT)
1676 DEFINE_CALLMETHOD(jint, Int, T_INT)
1677 DEFINE_CALLMETHOD(jlong, Long, T_LONG)
1678 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT)
1679 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE)
1680
1681 DT_VOID_RETURN_MARK_DECL(CallVoidMethod);
1682 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV);
1683 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA);
1684
1685 #else /* USDT2 */
1686 1402
1687 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \ 1403 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \
1688 , EntryProbe, ReturnProbe) \ 1404 , EntryProbe, ReturnProbe) \
1689 \ 1405 \
1690 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \ 1406 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
1847 1563
1848 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN()); 1564 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
1849 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN()); 1565 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
1850 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN()); 1566 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
1851 1567
1852 #endif /* USDT2 */
1853 1568
1854 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) 1569 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
1855 JNIWrapper("CallVoidMethod"); 1570 JNIWrapper("CallVoidMethod");
1856 #ifndef USDT2
1857 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID);
1858 #else /* USDT2 */
1859 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID); 1571 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
1860 #endif /* USDT2 */
1861 DT_VOID_RETURN_MARK(CallVoidMethod); 1572 DT_VOID_RETURN_MARK(CallVoidMethod);
1862 1573
1863 va_list args; 1574 va_list args;
1864 va_start(args, methodID); 1575 va_start(args, methodID);
1865 JavaValue jvalue(T_VOID); 1576 JavaValue jvalue(T_VOID);
1869 JNI_END 1580 JNI_END
1870 1581
1871 1582
1872 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) 1583 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
1873 JNIWrapper("CallVoidMethodV"); 1584 JNIWrapper("CallVoidMethodV");
1874 #ifndef USDT2
1875 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
1876 #else /* USDT2 */
1877 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID); 1585 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
1878 #endif /* USDT2 */
1879 DT_VOID_RETURN_MARK(CallVoidMethodV); 1586 DT_VOID_RETURN_MARK(CallVoidMethodV);
1880 1587
1881 JavaValue jvalue(T_VOID); 1588 JavaValue jvalue(T_VOID);
1882 JNI_ArgumentPusherVaArg ap(methodID, args); 1589 JNI_ArgumentPusherVaArg ap(methodID, args);
1883 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1590 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1884 JNI_END 1591 JNI_END
1885 1592
1886 1593
1887 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) 1594 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
1888 JNIWrapper("CallVoidMethodA"); 1595 JNIWrapper("CallVoidMethodA");
1889 #ifndef USDT2
1890 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
1891 #else /* USDT2 */
1892 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID); 1596 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
1893 #endif /* USDT2 */
1894 DT_VOID_RETURN_MARK(CallVoidMethodA); 1597 DT_VOID_RETURN_MARK(CallVoidMethodA);
1895 1598
1896 JavaValue jvalue(T_VOID); 1599 JavaValue jvalue(T_VOID);
1897 JNI_ArgumentPusherArray ap(methodID, args); 1600 JNI_ArgumentPusherArray ap(methodID, args);
1898 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1601 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1899 JNI_END 1602 JNI_END
1900 1603
1901 1604
1902 #ifndef USDT2
1903 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \
1904 \
1905 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\
1906 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\
1907 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\
1908 \
1909 JNI_ENTRY(ResultType, \
1910 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
1911 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
1912 \
1913 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\
1914 ResultType ret;\
1915 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
1916 (const ResultType&)ret);\
1917 \
1918 va_list args; \
1919 va_start(args, methodID); \
1920 JavaValue jvalue(Tag); \
1921 JNI_ArgumentPusherVaArg ap(methodID, args); \
1922 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1923 va_end(args); \
1924 ret = jvalue.get_##ResultType(); \
1925 return ret;\
1926 JNI_END \
1927 \
1928 JNI_ENTRY(ResultType, \
1929 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
1930 JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \
1931 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\
1932 ResultType ret;\
1933 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
1934 (const ResultType&)ret);\
1935 \
1936 JavaValue jvalue(Tag); \
1937 JNI_ArgumentPusherVaArg ap(methodID, args); \
1938 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1939 ret = jvalue.get_##ResultType(); \
1940 return ret;\
1941 JNI_END \
1942 \
1943 JNI_ENTRY(ResultType, \
1944 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
1945 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
1946 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\
1947 ResultType ret;\
1948 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
1949 (const ResultType&)ret);\
1950 \
1951 JavaValue jvalue(Tag); \
1952 JNI_ArgumentPusherArray ap(methodID, args); \
1953 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1954 ret = jvalue.get_##ResultType(); \
1955 return ret;\
1956 JNI_END
1957
1958 // the runtime type of subword integral basic types is integer
1959 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN)
1960 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE)
1961 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR)
1962 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT)
1963
1964 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT)
1965 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT)
1966 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG)
1967 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT)
1968 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE)
1969
1970
1971 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod);
1972 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV);
1973 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA);
1974
1975 #else /* USDT2 */
1976 1605
1977 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \ 1606 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
1978 , EntryProbe, ReturnProbe) \ 1607 , EntryProbe, ReturnProbe) \
1979 \ 1608 \
1980 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \ 1609 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
2140 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()); 1769 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
2141 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV 1770 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
2142 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()); 1771 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
2143 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA 1772 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
2144 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()); 1773 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
2145 #endif /* USDT2 */
2146 1774
2147 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) 1775 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
2148 JNIWrapper("CallNonvirtualVoidMethod"); 1776 JNIWrapper("CallNonvirtualVoidMethod");
2149 1777
2150 #ifndef USDT2
2151 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
2152 env, obj, cls, methodID);
2153 #else /* USDT2 */
2154 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID); 1778 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
2155 #endif /* USDT2 */
2156 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); 1779 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
2157 1780
2158 va_list args; 1781 va_list args;
2159 va_start(args, methodID); 1782 va_start(args, methodID);
2160 JavaValue jvalue(T_VOID); 1783 JavaValue jvalue(T_VOID);
2165 1788
2166 1789
2167 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) 1790 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
2168 JNIWrapper("CallNonvirtualVoidMethodV"); 1791 JNIWrapper("CallNonvirtualVoidMethodV");
2169 1792
2170 #ifndef USDT2
2171 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry,
2172 env, obj, cls, methodID);
2173 #else /* USDT2 */
2174 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY( 1793 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
2175 env, obj, cls, (uintptr_t) methodID); 1794 env, obj, cls, (uintptr_t) methodID);
2176 #endif /* USDT2 */
2177 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); 1795 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
2178 1796
2179 JavaValue jvalue(T_VOID); 1797 JavaValue jvalue(T_VOID);
2180 JNI_ArgumentPusherVaArg ap(methodID, args); 1798 JNI_ArgumentPusherVaArg ap(methodID, args);
2181 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 1799 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
2182 JNI_END 1800 JNI_END
2183 1801
2184 1802
2185 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) 1803 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
2186 JNIWrapper("CallNonvirtualVoidMethodA"); 1804 JNIWrapper("CallNonvirtualVoidMethodA");
2187 #ifndef USDT2
2188 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry,
2189 env, obj, cls, methodID);
2190 #else /* USDT2 */
2191 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY( 1805 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
2192 env, obj, cls, (uintptr_t) methodID); 1806 env, obj, cls, (uintptr_t) methodID);
2193 #endif /* USDT2 */
2194 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); 1807 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
2195 JavaValue jvalue(T_VOID); 1808 JavaValue jvalue(T_VOID);
2196 JNI_ArgumentPusherArray ap(methodID, args); 1809 JNI_ArgumentPusherArray ap(methodID, args);
2197 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 1810 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
2198 JNI_END 1811 JNI_END
2199 1812
2200 1813
2201 #ifndef USDT2
2202 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \
2203 \
2204 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\
2205 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\
2206 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\
2207 \
2208 JNI_ENTRY(ResultType, \
2209 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
2210 JNIWrapper("CallStatic" XSTR(Result) "Method"); \
2211 \
2212 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\
2213 ResultType ret = 0;\
2214 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
2215 (const ResultType&)ret);\
2216 \
2217 va_list args; \
2218 va_start(args, methodID); \
2219 JavaValue jvalue(Tag); \
2220 JNI_ArgumentPusherVaArg ap(methodID, args); \
2221 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2222 va_end(args); \
2223 ret = jvalue.get_##ResultType(); \
2224 return ret;\
2225 JNI_END \
2226 \
2227 JNI_ENTRY(ResultType, \
2228 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
2229 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
2230 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\
2231 ResultType ret = 0;\
2232 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
2233 (const ResultType&)ret);\
2234 \
2235 JavaValue jvalue(Tag); \
2236 JNI_ArgumentPusherVaArg ap(methodID, args); \
2237 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2238 ret = jvalue.get_##ResultType(); \
2239 return ret;\
2240 JNI_END \
2241 \
2242 JNI_ENTRY(ResultType, \
2243 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
2244 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
2245 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\
2246 ResultType ret = 0;\
2247 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
2248 (const ResultType&)ret);\
2249 \
2250 JavaValue jvalue(Tag); \
2251 JNI_ArgumentPusherArray ap(methodID, args); \
2252 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2253 ret = jvalue.get_##ResultType(); \
2254 return ret;\
2255 JNI_END
2256
2257 // the runtime type of subword integral basic types is integer
2258 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN)
2259 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE)
2260 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR)
2261 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT)
2262
2263 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT)
2264 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT)
2265 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG)
2266 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT)
2267 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE)
2268
2269
2270 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod);
2271 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV);
2272 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA);
2273
2274 #else /* USDT2 */
2275 1814
2276 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \ 1815 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
2277 , EntryProbe, ResultProbe) \ 1816 , EntryProbe, ResultProbe) \
2278 \ 1817 \
2279 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \ 1818 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
2443 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()); 1982 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
2444 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV 1983 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
2445 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()); 1984 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
2446 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA 1985 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
2447 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()); 1986 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
2448 #endif /* USDT2 */
2449 1987
2450 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) 1988 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
2451 JNIWrapper("CallStaticVoidMethod"); 1989 JNIWrapper("CallStaticVoidMethod");
2452 #ifndef USDT2
2453 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID);
2454 #else /* USDT2 */
2455 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID); 1990 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
2456 #endif /* USDT2 */
2457 DT_VOID_RETURN_MARK(CallStaticVoidMethod); 1991 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
2458 1992
2459 va_list args; 1993 va_list args;
2460 va_start(args, methodID); 1994 va_start(args, methodID);
2461 JavaValue jvalue(T_VOID); 1995 JavaValue jvalue(T_VOID);
2465 JNI_END 1999 JNI_END
2466 2000
2467 2001
2468 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) 2002 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
2469 JNIWrapper("CallStaticVoidMethodV"); 2003 JNIWrapper("CallStaticVoidMethodV");
2470 #ifndef USDT2
2471 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
2472 #else /* USDT2 */
2473 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID); 2004 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
2474 #endif /* USDT2 */
2475 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); 2005 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
2476 2006
2477 JavaValue jvalue(T_VOID); 2007 JavaValue jvalue(T_VOID);
2478 JNI_ArgumentPusherVaArg ap(methodID, args); 2008 JNI_ArgumentPusherVaArg ap(methodID, args);
2479 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 2009 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2480 JNI_END 2010 JNI_END
2481 2011
2482 2012
2483 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) 2013 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
2484 JNIWrapper("CallStaticVoidMethodA"); 2014 JNIWrapper("CallStaticVoidMethodA");
2485 #ifndef USDT2
2486 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
2487 #else /* USDT2 */
2488 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID); 2015 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
2489 #endif /* USDT2 */
2490 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); 2016 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
2491 2017
2492 JavaValue jvalue(T_VOID); 2018 JavaValue jvalue(T_VOID);
2493 JNI_ArgumentPusherArray ap(methodID, args); 2019 JNI_ArgumentPusherArray ap(methodID, args);
2494 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 2020 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2498 // 2024 //
2499 // Accessing Fields 2025 // Accessing Fields
2500 // 2026 //
2501 2027
2502 2028
2503 #ifndef USDT2
2504 DT_RETURN_MARK_DECL(GetFieldID, jfieldID);
2505 #else /* USDT2 */
2506 DT_RETURN_MARK_DECL(GetFieldID, jfieldID 2029 DT_RETURN_MARK_DECL(GetFieldID, jfieldID
2507 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref)); 2030 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
2508 #endif /* USDT2 */
2509 2031
2510 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz, 2032 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
2511 const char *name, const char *sig)) 2033 const char *name, const char *sig))
2512 JNIWrapper("GetFieldID"); 2034 JNIWrapper("GetFieldID");
2513 #ifndef USDT2
2514 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig);
2515 #else /* USDT2 */
2516 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig); 2035 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2517 #endif /* USDT2 */
2518 jfieldID ret = 0; 2036 jfieldID ret = 0;
2519 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret); 2037 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
2520 2038
2521 // The class should have been loaded (we have an instance of the class 2039 // The class should have been loaded (we have an instance of the class
2522 // passed in) so the field and signature should already be in the symbol 2040 // passed in) so the field and signature should already be in the symbol
2544 JNI_END 2062 JNI_END
2545 2063
2546 2064
2547 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)) 2065 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
2548 JNIWrapper("GetObjectField"); 2066 JNIWrapper("GetObjectField");
2549 #ifndef USDT2
2550 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID);
2551 #else /* USDT2 */
2552 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID); 2067 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
2553 #endif /* USDT2 */
2554 oop o = JNIHandles::resolve_non_null(obj); 2068 oop o = JNIHandles::resolve_non_null(obj);
2555 Klass* k = o->klass(); 2069 Klass* k = o->klass();
2556 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 2070 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2557 // Keep JVMTI addition small and only check enabled flag here. 2071 // Keep JVMTI addition small and only check enabled flag here.
2558 // jni_GetField_probe() assumes that is okay to create handles. 2072 // jni_GetField_probe() assumes that is okay to create handles.
2578 oop referent = JNIHandles::resolve(ret); 2092 oop referent = JNIHandles::resolve(ret);
2579 G1SATBCardTableModRefBS::enqueue(referent); 2093 G1SATBCardTableModRefBS::enqueue(referent);
2580 } 2094 }
2581 } 2095 }
2582 #endif // INCLUDE_ALL_GCS 2096 #endif // INCLUDE_ALL_GCS
2583 #ifndef USDT2
2584 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
2585 #else /* USDT2 */
2586 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret); 2097 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
2587 #endif /* USDT2 */
2588 return ret; 2098 return ret;
2589 JNI_END 2099 JNI_END
2590 2100
2591 2101
2592 #ifndef USDT2
2593 #define DEFINE_GETFIELD(Return,Fieldname,Result) \
2594 \
2595 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\
2596 \
2597 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
2598 JNIWrapper("Get" XSTR(Result) "Field"); \
2599 \
2600 DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\
2601 Return ret = 0;\
2602 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
2603 \
2604 oop o = JNIHandles::resolve_non_null(obj); \
2605 Klass* k = o->klass(); \
2606 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2607 /* Keep JVMTI addition small and only check enabled flag here. */ \
2608 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
2609 /* and creates a ResetNoHandleMark. */ \
2610 if (JvmtiExport::should_post_field_access()) { \
2611 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
2612 } \
2613 ret = o->Fieldname##_field(offset); \
2614 return ret; \
2615 JNI_END
2616
2617 DEFINE_GETFIELD(jboolean, bool, Boolean)
2618 DEFINE_GETFIELD(jbyte, byte, Byte)
2619 DEFINE_GETFIELD(jchar, char, Char)
2620 DEFINE_GETFIELD(jshort, short, Short)
2621 DEFINE_GETFIELD(jint, int, Int)
2622 DEFINE_GETFIELD(jlong, long, Long)
2623 DEFINE_GETFIELD(jfloat, float, Float)
2624 DEFINE_GETFIELD(jdouble, double, Double)
2625
2626 #else /* USDT2 */
2627 2102
2628 #define DEFINE_GETFIELD(Return,Fieldname,Result \ 2103 #define DEFINE_GETFIELD(Return,Fieldname,Result \
2629 , EntryProbe, ReturnProbe) \ 2104 , EntryProbe, ReturnProbe) \
2630 \ 2105 \
2631 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \ 2106 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
2674 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2149 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2675 HOTSPOT_JNI_GETFLOATFIELD_RETURN()) 2150 HOTSPOT_JNI_GETFLOATFIELD_RETURN())
2676 DEFINE_GETFIELD(jdouble, double, Double 2151 DEFINE_GETFIELD(jdouble, double, Double
2677 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2152 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2678 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN()) 2153 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
2679 #endif /* USDT2 */
2680 2154
2681 address jni_GetBooleanField_addr() { 2155 address jni_GetBooleanField_addr() {
2682 return (address)jni_GetBooleanField; 2156 return (address)jni_GetBooleanField;
2683 } 2157 }
2684 address jni_GetByteField_addr() { 2158 address jni_GetByteField_addr() {
2703 return (address)jni_GetDoubleField; 2177 return (address)jni_GetDoubleField;
2704 } 2178 }
2705 2179
2706 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)) 2180 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
2707 JNIWrapper("SetObjectField"); 2181 JNIWrapper("SetObjectField");
2708 #ifndef USDT2
2709 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value);
2710 #else /* USDT2 */
2711 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value); 2182 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
2712 #endif /* USDT2 */
2713 oop o = JNIHandles::resolve_non_null(obj); 2183 oop o = JNIHandles::resolve_non_null(obj);
2714 Klass* k = o->klass(); 2184 Klass* k = o->klass();
2715 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 2185 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2716 // Keep JVMTI addition small and only check enabled flag here. 2186 // Keep JVMTI addition small and only check enabled flag here.
2717 // jni_SetField_probe_nh() assumes that is not okay to create handles 2187 // jni_SetField_probe_nh() assumes that is not okay to create handles
2720 jvalue field_value; 2190 jvalue field_value;
2721 field_value.l = value; 2191 field_value.l = value;
2722 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); 2192 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
2723 } 2193 }
2724 o->obj_field_put(offset, JNIHandles::resolve(value)); 2194 o->obj_field_put(offset, JNIHandles::resolve(value));
2725 #ifndef USDT2
2726 DTRACE_PROBE(hotspot_jni, SetObjectField__return);
2727 #else /* USDT2 */
2728 HOTSPOT_JNI_SETOBJECTFIELD_RETURN(); 2195 HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
2729 #endif /* USDT2 */ 2196 JNI_END
2730 JNI_END 2197
2731
2732 #ifndef USDT2
2733 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
2734 \
2735 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
2736 JNIWrapper("Set" XSTR(Result) "Field"); \
2737 \
2738 FP_SELECT_##Result( \
2739 DTRACE_PROBE4(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID, value), \
2740 DTRACE_PROBE3(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID)); \
2741 \
2742 oop o = JNIHandles::resolve_non_null(obj); \
2743 Klass* k = o->klass(); \
2744 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2745 /* Keep JVMTI addition small and only check enabled flag here. */ \
2746 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
2747 /* and creates a ResetNoHandleMark. */ \
2748 if (JvmtiExport::should_post_field_modification()) { \
2749 jvalue field_value; \
2750 field_value.unionType = value; \
2751 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
2752 } \
2753 o->Fieldname##_field_put(offset, value); \
2754 DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\
2755 JNI_END
2756
2757 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z)
2758 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b)
2759 DEFINE_SETFIELD(jchar, char, Char, 'C', c)
2760 DEFINE_SETFIELD(jshort, short, Short, 'S', s)
2761 DEFINE_SETFIELD(jint, int, Int, 'I', i)
2762 DEFINE_SETFIELD(jlong, long, Long, 'J', j)
2763 DEFINE_SETFIELD(jfloat, float, Float, 'F', f)
2764 DEFINE_SETFIELD(jdouble, double, Double, 'D', d)
2765
2766 #else /* USDT2 */
2767 2198
2768 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \ 2199 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
2769 , EntryProbe, ReturnProbe) \ 2200 , EntryProbe, ReturnProbe) \
2770 \ 2201 \
2771 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ 2202 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
2811 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2242 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2812 HOTSPOT_JNI_SETFLOATFIELD_RETURN()) 2243 HOTSPOT_JNI_SETFLOATFIELD_RETURN())
2813 DEFINE_SETFIELD(jdouble, double, Double, 'D', d 2244 DEFINE_SETFIELD(jdouble, double, Double, 'D', d
2814 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2245 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2815 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()) 2246 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
2816 #endif /* USDT2 */ 2247
2817
2818 #ifndef USDT2
2819 DT_RETURN_MARK_DECL(ToReflectedField, jobject);
2820 #else /* USDT2 */
2821 DT_RETURN_MARK_DECL(ToReflectedField, jobject 2248 DT_RETURN_MARK_DECL(ToReflectedField, jobject
2822 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref)); 2249 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
2823 #endif /* USDT2 */
2824 2250
2825 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) 2251 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
2826 JNIWrapper("ToReflectedField"); 2252 JNIWrapper("ToReflectedField");
2827 #ifndef USDT2
2828 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
2829 env, cls, fieldID, isStatic);
2830 #else /* USDT2 */
2831 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic); 2253 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
2832 #endif /* USDT2 */
2833 jobject ret = NULL; 2254 jobject ret = NULL;
2834 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); 2255 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
2835 2256
2836 fieldDescriptor fd; 2257 fieldDescriptor fd;
2837 bool found = false; 2258 bool found = false;
2857 2278
2858 2279
2859 // 2280 //
2860 // Accessing Static Fields 2281 // Accessing Static Fields
2861 // 2282 //
2862 #ifndef USDT2
2863 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID);
2864 #else /* USDT2 */
2865 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID 2283 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2866 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref)); 2284 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2867 #endif /* USDT2 */
2868 2285
2869 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, 2286 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2870 const char *name, const char *sig)) 2287 const char *name, const char *sig))
2871 JNIWrapper("GetStaticFieldID"); 2288 JNIWrapper("GetStaticFieldID");
2872 #ifndef USDT2
2873 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig);
2874 #else /* USDT2 */
2875 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig); 2289 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2876 #endif /* USDT2 */
2877 jfieldID ret = NULL; 2290 jfieldID ret = NULL;
2878 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); 2291 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2879 2292
2880 // The class should have been loaded (we have an instance of the class 2293 // The class should have been loaded (we have an instance of the class
2881 // passed in) so the field and signature should already be in the symbol 2294 // passed in) so the field and signature should already be in the symbol
2907 JNI_END 2320 JNI_END
2908 2321
2909 2322
2910 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)) 2323 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2911 JNIWrapper("GetStaticObjectField"); 2324 JNIWrapper("GetStaticObjectField");
2912 #ifndef USDT2
2913 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID);
2914 #else /* USDT2 */
2915 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID); 2325 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
2916 #endif /* USDT2 */
2917 #if INCLUDE_JNI_CHECK 2326 #if INCLUDE_JNI_CHECK
2918 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);) 2327 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2919 #endif // INCLUDE_JNI_CHECK 2328 #endif // INCLUDE_JNI_CHECK
2920 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 2329 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2921 assert(id->is_static_field_id(), "invalid static field id"); 2330 assert(id->is_static_field_id(), "invalid static field id");
2923 // jni_GetField_probe() assumes that is okay to create handles. 2332 // jni_GetField_probe() assumes that is okay to create handles.
2924 if (JvmtiExport::should_post_field_access()) { 2333 if (JvmtiExport::should_post_field_access()) {
2925 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); 2334 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
2926 } 2335 }
2927 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); 2336 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
2928 #ifndef USDT2
2929 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret);
2930 #else /* USDT2 */
2931 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret); 2337 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
2932 #endif /* USDT2 */
2933 return ret; 2338 return ret;
2934 JNI_END 2339 JNI_END
2935 2340
2936 #ifndef USDT2
2937 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \
2938 \
2939 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\
2940 \
2941 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
2942 JNIWrapper("GetStatic" XSTR(Result) "Field"); \
2943 DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\
2944 Return ret = 0;\
2945 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
2946 (const Return&)ret);\
2947 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
2948 assert(id->is_static_field_id(), "invalid static field id"); \
2949 /* Keep JVMTI addition small and only check enabled flag here. */ \
2950 /* jni_GetField_probe() assumes that is okay to create handles. */ \
2951 if (JvmtiExport::should_post_field_access()) { \
2952 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
2953 } \
2954 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
2955 return ret;\
2956 JNI_END
2957
2958 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean)
2959 DEFINE_GETSTATICFIELD(jbyte, byte, Byte)
2960 DEFINE_GETSTATICFIELD(jchar, char, Char)
2961 DEFINE_GETSTATICFIELD(jshort, short, Short)
2962 DEFINE_GETSTATICFIELD(jint, int, Int)
2963 DEFINE_GETSTATICFIELD(jlong, long, Long)
2964 DEFINE_GETSTATICFIELD(jfloat, float, Float)
2965 DEFINE_GETSTATICFIELD(jdouble, double, Double)
2966
2967 #else /* USDT2 */
2968 2341
2969 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \ 2342 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
2970 , EntryProbe, ReturnProbe) \ 2343 , EntryProbe, ReturnProbe) \
2971 \ 2344 \
2972 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \ 2345 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
3004 // Float and double probes don't return value because dtrace doesn't currently support it 2377 // Float and double probes don't return value because dtrace doesn't currently support it
3005 DEFINE_GETSTATICFIELD(jfloat, float, Float 2378 DEFINE_GETSTATICFIELD(jfloat, float, Float
3006 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() ) 2379 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() )
3007 DEFINE_GETSTATICFIELD(jdouble, double, Double 2380 DEFINE_GETSTATICFIELD(jdouble, double, Double
3008 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() ) 2381 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() )
3009 #endif /* USDT2 */
3010 2382
3011 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) 2383 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
3012 JNIWrapper("SetStaticObjectField"); 2384 JNIWrapper("SetStaticObjectField");
3013 #ifndef USDT2
3014 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value);
3015 #else /* USDT2 */
3016 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value); 2385 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
3017 #endif /* USDT2 */
3018 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 2386 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
3019 assert(id->is_static_field_id(), "invalid static field id"); 2387 assert(id->is_static_field_id(), "invalid static field id");
3020 // Keep JVMTI addition small and only check enabled flag here. 2388 // Keep JVMTI addition small and only check enabled flag here.
3021 // jni_SetField_probe() assumes that is okay to create handles. 2389 // jni_SetField_probe() assumes that is okay to create handles.
3022 if (JvmtiExport::should_post_field_modification()) { 2390 if (JvmtiExport::should_post_field_modification()) {
3023 jvalue field_value; 2391 jvalue field_value;
3024 field_value.l = value; 2392 field_value.l = value;
3025 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); 2393 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
3026 } 2394 }
3027 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); 2395 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
3028 #ifndef USDT2
3029 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return);
3030 #else /* USDT2 */
3031 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN(); 2396 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
3032 #endif /* USDT2 */ 2397 JNI_END
3033 JNI_END 2398
3034 2399
3035
3036 #ifndef USDT2
3037 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \
3038 \
3039 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
3040 JNIWrapper("SetStatic" XSTR(Result) "Field"); \
3041 FP_SELECT_##Result( \
3042 DTRACE_PROBE4(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID, value), \
3043 DTRACE_PROBE3(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID)); \
3044 \
3045 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3046 assert(id->is_static_field_id(), "invalid static field id"); \
3047 /* Keep JVMTI addition small and only check enabled flag here. */ \
3048 /* jni_SetField_probe() assumes that is okay to create handles. */ \
3049 if (JvmtiExport::should_post_field_modification()) { \
3050 jvalue field_value; \
3051 field_value.unionType = value; \
3052 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
3053 } \
3054 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
3055 DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\
3056 JNI_END
3057
3058 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z)
3059 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b)
3060 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c)
3061 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s)
3062 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i)
3063 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j)
3064 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f)
3065 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d)
3066
3067 #else /* USDT2 */
3068 2400
3069 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \ 2401 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
3070 , EntryProbe, ReturnProbe) \ 2402 , EntryProbe, ReturnProbe) \
3071 \ 2403 \
3072 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ 2404 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
3109 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), 2441 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
3110 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()) 2442 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
3111 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d 2443 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d
3112 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), 2444 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
3113 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) 2445 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
3114 #endif /* USDT2 */
3115 2446
3116 // 2447 //
3117 // String Operations 2448 // String Operations
3118 // 2449 //
3119 2450
3120 // Unicode Interface 2451 // Unicode Interface
3121 2452
3122 #ifndef USDT2
3123 DT_RETURN_MARK_DECL(NewString, jstring);
3124 #else /* USDT2 */
3125 DT_RETURN_MARK_DECL(NewString, jstring 2453 DT_RETURN_MARK_DECL(NewString, jstring
3126 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref)); 2454 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
3127 #endif /* USDT2 */
3128 2455
3129 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) 2456 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
3130 JNIWrapper("NewString"); 2457 JNIWrapper("NewString");
3131 #ifndef USDT2
3132 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len);
3133 #else /* USDT2 */
3134 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len); 2458 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
3135 #endif /* USDT2 */
3136 jstring ret = NULL; 2459 jstring ret = NULL;
3137 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); 2460 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
3138 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); 2461 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
3139 ret = (jstring) JNIHandles::make_local(env, string); 2462 ret = (jstring) JNIHandles::make_local(env, string);
3140 return ret; 2463 return ret;
3141 JNI_END 2464 JNI_END
3142 2465
3143 2466
3144 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) 2467 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
3145 JNIWrapper("GetStringLength"); 2468 JNIWrapper("GetStringLength");
3146 #ifndef USDT2
3147 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string);
3148 #else /* USDT2 */
3149 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string); 2469 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
3150 #endif /* USDT2 */
3151 jsize ret = 0; 2470 jsize ret = 0;
3152 oop s = JNIHandles::resolve_non_null(string); 2471 oop s = JNIHandles::resolve_non_null(string);
3153 if (java_lang_String::value(s) != NULL) { 2472 if (java_lang_String::value(s) != NULL) {
3154 ret = java_lang_String::length(s); 2473 ret = java_lang_String::length(s);
3155 } 2474 }
3156 #ifndef USDT2
3157 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
3158 #else /* USDT2 */
3159 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret); 2475 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
3160 #endif /* USDT2 */
3161 return ret; 2476 return ret;
3162 JNI_END 2477 JNI_END
3163 2478
3164 2479
3165 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( 2480 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
3166 JNIEnv *env, jstring string, jboolean *isCopy)) 2481 JNIEnv *env, jstring string, jboolean *isCopy))
3167 JNIWrapper("GetStringChars"); 2482 JNIWrapper("GetStringChars");
3168 #ifndef USDT2
3169 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
3170 #else /* USDT2 */
3171 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy); 2483 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
3172 #endif /* USDT2 */
3173 jchar* buf = NULL; 2484 jchar* buf = NULL;
3174 oop s = JNIHandles::resolve_non_null(string); 2485 oop s = JNIHandles::resolve_non_null(string);
3175 typeArrayOop s_value = java_lang_String::value(s); 2486 typeArrayOop s_value = java_lang_String::value(s);
3176 if (s_value != NULL) { 2487 if (s_value != NULL) {
3177 int s_len = java_lang_String::length(s); 2488 int s_len = java_lang_String::length(s);
3187 if (isCopy != NULL) { 2498 if (isCopy != NULL) {
3188 *isCopy = JNI_TRUE; 2499 *isCopy = JNI_TRUE;
3189 } 2500 }
3190 } 2501 }
3191 } 2502 }
3192 #ifndef USDT2
3193 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
3194 #else /* USDT2 */
3195 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf); 2503 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
3196 #endif /* USDT2 */
3197 return buf; 2504 return buf;
3198 JNI_END 2505 JNI_END
3199 2506
3200 2507
3201 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) 2508 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
3202 JNIWrapper("ReleaseStringChars"); 2509 JNIWrapper("ReleaseStringChars");
3203 #ifndef USDT2
3204 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars);
3205 #else /* USDT2 */
3206 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars); 2510 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
3207 #endif /* USDT2 */
3208 //%note jni_6 2511 //%note jni_6
3209 if (chars != NULL) { 2512 if (chars != NULL) {
3210 // Since String objects are supposed to be immutable, don't copy any 2513 // Since String objects are supposed to be immutable, don't copy any
3211 // new data back. A bad user will have to go after the char array. 2514 // new data back. A bad user will have to go after the char array.
3212 FreeHeap((void*) chars); 2515 FreeHeap((void*) chars);
3213 } 2516 }
3214 #ifndef USDT2
3215 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return);
3216 #else /* USDT2 */
3217 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN(); 2517 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
3218 #endif /* USDT2 */
3219 JNI_END 2518 JNI_END
3220 2519
3221 2520
3222 // UTF Interface 2521 // UTF Interface
3223 2522
3224 #ifndef USDT2
3225 DT_RETURN_MARK_DECL(NewStringUTF, jstring);
3226 #else /* USDT2 */
3227 DT_RETURN_MARK_DECL(NewStringUTF, jstring 2523 DT_RETURN_MARK_DECL(NewStringUTF, jstring
3228 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref)); 2524 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
3229 #endif /* USDT2 */
3230 2525
3231 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) 2526 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
3232 JNIWrapper("NewStringUTF"); 2527 JNIWrapper("NewStringUTF");
3233 #ifndef USDT2
3234 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes);
3235 #else /* USDT2 */
3236 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes); 2528 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
3237 #endif /* USDT2 */
3238 jstring ret; 2529 jstring ret;
3239 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); 2530 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
3240 2531
3241 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); 2532 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
3242 ret = (jstring) JNIHandles::make_local(env, result); 2533 ret = (jstring) JNIHandles::make_local(env, result);
3244 JNI_END 2535 JNI_END
3245 2536
3246 2537
3247 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) 2538 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
3248 JNIWrapper("GetStringUTFLength"); 2539 JNIWrapper("GetStringUTFLength");
3249 #ifndef USDT2
3250 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string);
3251 #else /* USDT2 */
3252 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string); 2540 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
3253 #endif /* USDT2 */
3254 jsize ret = 0; 2541 jsize ret = 0;
3255 oop java_string = JNIHandles::resolve_non_null(string); 2542 oop java_string = JNIHandles::resolve_non_null(string);
3256 if (java_lang_String::value(java_string) != NULL) { 2543 if (java_lang_String::value(java_string) != NULL) {
3257 ret = java_lang_String::utf8_length(java_string); 2544 ret = java_lang_String::utf8_length(java_string);
3258 } 2545 }
3259 #ifndef USDT2
3260 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
3261 #else /* USDT2 */
3262 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret); 2546 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
3263 #endif /* USDT2 */
3264 return ret; 2547 return ret;
3265 JNI_END 2548 JNI_END
3266 2549
3267 2550
3268 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) 2551 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
3269 JNIWrapper("GetStringUTFChars"); 2552 JNIWrapper("GetStringUTFChars");
3270 #ifndef USDT2
3271 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy);
3272 #else /* USDT2 */
3273 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy); 2553 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
3274 #endif /* USDT2 */
3275 char* result = NULL; 2554 char* result = NULL;
3276 oop java_string = JNIHandles::resolve_non_null(string); 2555 oop java_string = JNIHandles::resolve_non_null(string);
3277 if (java_lang_String::value(java_string) != NULL) { 2556 if (java_lang_String::value(java_string) != NULL) {
3278 size_t length = java_lang_String::utf8_length(java_string); 2557 size_t length = java_lang_String::utf8_length(java_string);
3279 /* JNI Specification states return NULL on OOM */ 2558 /* JNI Specification states return NULL on OOM */
3283 if (isCopy != NULL) { 2562 if (isCopy != NULL) {
3284 *isCopy = JNI_TRUE; 2563 *isCopy = JNI_TRUE;
3285 } 2564 }
3286 } 2565 }
3287 } 2566 }
3288 #ifndef USDT2
3289 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
3290 #else /* USDT2 */
3291 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result); 2567 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
3292 #endif /* USDT2 */
3293 return result; 2568 return result;
3294 JNI_END 2569 JNI_END
3295 2570
3296 2571
3297 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) 2572 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
3298 JNIWrapper("ReleaseStringUTFChars"); 2573 JNIWrapper("ReleaseStringUTFChars");
3299 #ifndef USDT2
3300 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars);
3301 #else /* USDT2 */
3302 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars); 2574 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
3303 #endif /* USDT2 */
3304 if (chars != NULL) { 2575 if (chars != NULL) {
3305 FreeHeap((char*) chars); 2576 FreeHeap((char*) chars);
3306 } 2577 }
3307 #ifndef USDT2
3308 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return);
3309 #else /* USDT2 */
3310 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN(); 2578 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN();
3311 #endif /* USDT2 */
3312 JNI_END 2579 JNI_END
3313 2580
3314 2581
3315 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) 2582 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
3316 JNIWrapper("GetArrayLength"); 2583 JNIWrapper("GetArrayLength");
3317 #ifndef USDT2
3318 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array);
3319 #else /* USDT2 */
3320 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array); 2584 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
3321 #endif /* USDT2 */
3322 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); 2585 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
3323 assert(a->is_array(), "must be array"); 2586 assert(a->is_array(), "must be array");
3324 jsize ret = a->length(); 2587 jsize ret = a->length();
3325 #ifndef USDT2
3326 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret);
3327 #else /* USDT2 */
3328 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret); 2588 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
3329 #endif /* USDT2 */
3330 return ret; 2589 return ret;
3331 JNI_END 2590 JNI_END
3332 2591
3333 2592
3334 // 2593 //
3335 // Object Array Operations 2594 // Object Array Operations
3336 // 2595 //
3337 2596
3338 #ifndef USDT2
3339 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray);
3340 #else /* USDT2 */
3341 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray 2597 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
3342 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref)); 2598 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
3343 #endif /* USDT2 */
3344 2599
3345 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) 2600 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
3346 JNIWrapper("NewObjectArray"); 2601 JNIWrapper("NewObjectArray");
3347 #ifndef USDT2
3348 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement);
3349 #else /* USDT2 */
3350 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement); 2602 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
3351 #endif /* USDT2 */
3352 jobjectArray ret = NULL; 2603 jobjectArray ret = NULL;
3353 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); 2604 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
3354 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass))); 2605 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
3355 Klass* ako = ek()->array_klass(CHECK_NULL); 2606 Klass* ako = ek()->array_klass(CHECK_NULL);
3356 KlassHandle ak = KlassHandle(THREAD, ako); 2607 KlassHandle ak = KlassHandle(THREAD, ako);
3364 } 2615 }
3365 ret = (jobjectArray) JNIHandles::make_local(env, result); 2616 ret = (jobjectArray) JNIHandles::make_local(env, result);
3366 return ret; 2617 return ret;
3367 JNI_END 2618 JNI_END
3368 2619
3369 #ifndef USDT2
3370 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject);
3371 #else /* USDT2 */
3372 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject 2620 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
3373 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref)); 2621 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
3374 #endif /* USDT2 */
3375 2622
3376 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) 2623 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
3377 JNIWrapper("GetObjectArrayElement"); 2624 JNIWrapper("GetObjectArrayElement");
3378 #ifndef USDT2
3379 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index);
3380 #else /* USDT2 */
3381 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index); 2625 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
3382 #endif /* USDT2 */
3383 jobject ret = NULL; 2626 jobject ret = NULL;
3384 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); 2627 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
3385 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 2628 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
3386 if (a->is_within_bounds(index)) { 2629 if (a->is_within_bounds(index)) {
3387 ret = JNIHandles::make_local(env, a->obj_at(index)); 2630 ret = JNIHandles::make_local(env, a->obj_at(index));
3391 sprintf(buf, "%d", index); 2634 sprintf(buf, "%d", index);
3392 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); 2635 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
3393 } 2636 }
3394 JNI_END 2637 JNI_END
3395 2638
3396 #ifndef USDT2
3397 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement);
3398 #else /* USDT2 */
3399 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement 2639 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
3400 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN()); 2640 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
3401 #endif /* USDT2 */
3402 2641
3403 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) 2642 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
3404 JNIWrapper("SetObjectArrayElement"); 2643 JNIWrapper("SetObjectArrayElement");
3405 #ifndef USDT2
3406 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value);
3407 #else /* USDT2 */
3408 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value); 2644 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
3409 #endif /* USDT2 */
3410 DT_VOID_RETURN_MARK(SetObjectArrayElement); 2645 DT_VOID_RETURN_MARK(SetObjectArrayElement);
3411 2646
3412 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 2647 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
3413 oop v = JNIHandles::resolve(value); 2648 oop v = JNIHandles::resolve(value);
3414 if (a->is_within_bounds(index)) { 2649 if (a->is_within_bounds(index)) {
3423 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); 2658 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
3424 } 2659 }
3425 JNI_END 2660 JNI_END
3426 2661
3427 2662
3428 #ifndef USDT2
3429 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \
3430 \
3431 DT_RETURN_MARK_DECL(New##Result##Array, Return); \
3432 \
3433 JNI_ENTRY(Return, \
3434 jni_New##Result##Array(JNIEnv *env, jsize len)) \
3435 JNIWrapper("New" XSTR(Result) "Array"); \
3436 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\
3437 Return ret = NULL;\
3438 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
3439 \
3440 oop obj= oopFactory::Allocator(len, CHECK_0); \
3441 ret = (Return) JNIHandles::make_local(env, obj); \
3442 return ret;\
3443 JNI_END
3444
3445 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean)
3446 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte)
3447 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short)
3448 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char)
3449 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int)
3450 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long)
3451 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float)
3452 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double)
3453
3454 #else /* USDT2 */
3455 2663
3456 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \ 2664 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
3457 ,EntryProbe,ReturnProbe) \ 2665 ,EntryProbe,ReturnProbe) \
3458 \ 2666 \
3459 DT_RETURN_MARK_DECL(New##Result##Array, Return \ 2667 DT_RETURN_MARK_DECL(New##Result##Array, Return \
3493 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len), 2701 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
3494 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref)) 2702 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
3495 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double, 2703 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double,
3496 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len), 2704 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
3497 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref)) 2705 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
3498 #endif /* USDT2 */
3499 2706
3500 // Return an address which will fault if the caller writes to it. 2707 // Return an address which will fault if the caller writes to it.
3501 2708
3502 static char* get_bad_address() { 2709 static char* get_bad_address() {
3503 static char* bad_address = NULL; 2710 static char* bad_address = NULL;
3511 } 2718 }
3512 return bad_address; 2719 return bad_address;
3513 } 2720 }
3514 2721
3515 2722
3516 #ifndef USDT2
3517 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \
3518 \
3519 JNI_QUICK_ENTRY(ElementType*, \
3520 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
3521 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
3522 DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\
3523 /* allocate an chunk of memory in c land */ \
3524 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3525 ElementType* result; \
3526 int len = a->length(); \
3527 if (len == 0) { \
3528 /* Empty array: legal but useless, can't return NULL. \
3529 * Return a pointer to something useless. \
3530 * Avoid asserts in typeArrayOop. */ \
3531 result = (ElementType*)get_bad_address(); \
3532 } else { \
3533 /* JNI Specification states return NULL on OOM */ \
3534 result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
3535 if (result != NULL) { \
3536 /* copy the array to the c chunk */ \
3537 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
3538 if (isCopy) { \
3539 *isCopy = JNI_TRUE; \
3540 } \
3541 } \
3542 } \
3543 DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
3544 return result; \
3545 JNI_END
3546
3547 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
3548 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
3549 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
3550 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
3551 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int)
3552 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
3553 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
3554 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
3555
3556 #else /* USDT2 */
3557 2723
3558 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \ 2724 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
3559 , EntryProbe, ReturnProbe) \ 2725 , EntryProbe, ReturnProbe) \
3560 \ 2726 \
3561 JNI_QUICK_ENTRY(ElementType*, \ 2727 JNI_QUICK_ENTRY(ElementType*, \
3609 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), 2775 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3610 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result)) 2776 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
3611 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double 2777 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
3612 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), 2778 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3613 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result)) 2779 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
3614 #endif /* USDT2 */ 2780
3615
3616 #ifndef USDT2
3617 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \
3618 \
3619 JNI_QUICK_ENTRY(void, \
3620 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
3621 ElementType *buf, jint mode)) \
3622 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
3623 DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\
3624 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3625 int len = a->length(); \
3626 if (len != 0) { /* Empty array: nothing to free or copy. */ \
3627 if ((mode == 0) || (mode == JNI_COMMIT)) { \
3628 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
3629 } \
3630 if ((mode == 0) || (mode == JNI_ABORT)) { \
3631 FreeHeap(buf); \
3632 } \
3633 } \
3634 DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\
3635 JNI_END
3636
3637 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
3638 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
3639 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
3640 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
3641 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int)
3642 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
3643 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
3644 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
3645
3646 #else /* USDT2 */
3647 2781
3648 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \ 2782 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
3649 , EntryProbe, ReturnProbe);\ 2783 , EntryProbe, ReturnProbe);\
3650 \ 2784 \
3651 JNI_QUICK_ENTRY(void, \ 2785 JNI_QUICK_ENTRY(void, \
3688 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode), 2822 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
3689 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()) 2823 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
3690 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double 2824 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
3691 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode), 2825 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
3692 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()) 2826 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
3693 #endif /* USDT2 */ 2827
3694
3695 #ifndef USDT2
3696 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
3697 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\
3698 \
3699 JNI_ENTRY(void, \
3700 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3701 jsize len, ElementType *buf)) \
3702 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
3703 DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\
3704 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
3705 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3706 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
3707 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3708 } else { \
3709 if (len > 0) { \
3710 int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
3711 memcpy((u_char*) buf, \
3712 (u_char*) src->Tag##_at_addr(start), \
3713 len << sc); \
3714 } \
3715 } \
3716 JNI_END
3717
3718 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool)
3719 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
3720 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
3721 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
3722 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int)
3723 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long)
3724 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
3725 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
3726
3727 #else /* USDT2 */
3728 2828
3729 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ 2829 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
3730 , EntryProbe, ReturnProbe); \ 2830 , EntryProbe, ReturnProbe); \
3731 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \ 2831 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
3732 , ReturnProbe); \ 2832 , ReturnProbe); \
3772 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), 2872 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
3773 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()); 2873 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
3774 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double 2874 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
3775 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), 2875 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
3776 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()); 2876 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
3777 #endif /* USDT2 */ 2877
3778
3779 #ifndef USDT2
3780 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
3781 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\
3782 \
3783 JNI_ENTRY(void, \
3784 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3785 jsize len, const ElementType *buf)) \
3786 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
3787 DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\
3788 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
3789 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3790 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
3791 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3792 } else { \
3793 if (len > 0) { \
3794 int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
3795 memcpy((u_char*) dst->Tag##_at_addr(start), \
3796 (u_char*) buf, \
3797 len << sc); \
3798 } \
3799 } \
3800 JNI_END
3801
3802 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool)
3803 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
3804 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
3805 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
3806 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int)
3807 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long)
3808 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
3809 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
3810
3811 #else /* USDT2 */
3812 2878
3813 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ 2879 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
3814 , EntryProbe, ReturnProbe); \ 2880 , EntryProbe, ReturnProbe); \
3815 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \ 2881 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
3816 ,ReturnProbe); \ 2882 ,ReturnProbe); \
3856 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), 2922 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
3857 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN()) 2923 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
3858 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double 2924 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
3859 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), 2925 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
3860 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN()) 2926 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
3861 #endif /* USDT2 */
3862 2927
3863 2928
3864 // 2929 //
3865 // Interception of natives 2930 // Interception of natives
3866 // 2931 //
3941 method->name()->as_C_string()); 3006 method->name()->as_C_string());
3942 } 3007 }
3943 return true; 3008 return true;
3944 } 3009 }
3945 3010
3946 #ifndef USDT2
3947 DT_RETURN_MARK_DECL(RegisterNatives, jint);
3948 #else /* USDT2 */
3949 DT_RETURN_MARK_DECL(RegisterNatives, jint 3011 DT_RETURN_MARK_DECL(RegisterNatives, jint
3950 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref)); 3012 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
3951 #endif /* USDT2 */
3952 3013
3953 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz, 3014 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
3954 const JNINativeMethod *methods, 3015 const JNINativeMethod *methods,
3955 jint nMethods)) 3016 jint nMethods))
3956 JNIWrapper("RegisterNatives"); 3017 JNIWrapper("RegisterNatives");
3957 #ifndef USDT2
3958 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
3959 #else /* USDT2 */
3960 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods); 3018 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
3961 #endif /* USDT2 */
3962 jint ret = 0; 3019 jint ret = 0;
3963 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret); 3020 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
3964 3021
3965 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 3022 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
3966 3023
3994 JNI_END 3051 JNI_END
3995 3052
3996 3053
3997 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz)) 3054 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
3998 JNIWrapper("UnregisterNatives"); 3055 JNIWrapper("UnregisterNatives");
3999 #ifndef USDT2
4000 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz);
4001 #else /* USDT2 */
4002 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz); 3056 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
4003 #endif /* USDT2 */
4004 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)); 3057 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
4005 //%note jni_2 3058 //%note jni_2
4006 if (k->oop_is_instance()) { 3059 if (k->oop_is_instance()) {
4007 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) { 3060 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
4008 Method* m = InstanceKlass::cast(k)->methods()->at(index); 3061 Method* m = InstanceKlass::cast(k)->methods()->at(index);
4010 m->clear_native_function(); 3063 m->clear_native_function();
4011 m->set_signature_handler(NULL); 3064 m->set_signature_handler(NULL);
4012 } 3065 }
4013 } 3066 }
4014 } 3067 }
4015 #ifndef USDT2
4016 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
4017 #else /* USDT2 */
4018 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0); 3068 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
4019 #endif /* USDT2 */
4020 return 0; 3069 return 0;
4021 JNI_END 3070 JNI_END
4022 3071
4023 // 3072 //
4024 // Monitor functions 3073 // Monitor functions
4025 // 3074 //
4026 3075
4027 #ifndef USDT2
4028 DT_RETURN_MARK_DECL(MonitorEnter, jint);
4029 #else /* USDT2 */
4030 DT_RETURN_MARK_DECL(MonitorEnter, jint 3076 DT_RETURN_MARK_DECL(MonitorEnter, jint
4031 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref)); 3077 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
4032 #endif /* USDT2 */
4033 3078
4034 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj)) 3079 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
4035 #ifndef USDT2
4036 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj);
4037 #else /* USDT2 */
4038 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj); 3080 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
4039 #endif /* USDT2 */
4040 jint ret = JNI_ERR; 3081 jint ret = JNI_ERR;
4041 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret); 3082 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
4042 3083
4043 // If the object is null, we can't do anything with it 3084 // If the object is null, we can't do anything with it
4044 if (jobj == NULL) { 3085 if (jobj == NULL) {
4049 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR)); 3090 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
4050 ret = JNI_OK; 3091 ret = JNI_OK;
4051 return ret; 3092 return ret;
4052 JNI_END 3093 JNI_END
4053 3094
4054 #ifndef USDT2
4055 DT_RETURN_MARK_DECL(MonitorExit, jint);
4056 #else /* USDT2 */
4057 DT_RETURN_MARK_DECL(MonitorExit, jint 3095 DT_RETURN_MARK_DECL(MonitorExit, jint
4058 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref)); 3096 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
4059 #endif /* USDT2 */
4060 3097
4061 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj)) 3098 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
4062 #ifndef USDT2
4063 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj);
4064 #else /* USDT2 */
4065 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj); 3099 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
4066 #endif /* USDT2 */
4067 jint ret = JNI_ERR; 3100 jint ret = JNI_ERR;
4068 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret); 3101 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
4069 3102
4070 // Don't do anything with a null object 3103 // Don't do anything with a null object
4071 if (jobj == NULL) { 3104 if (jobj == NULL) {
4081 3114
4082 // 3115 //
4083 // Extensions 3116 // Extensions
4084 // 3117 //
4085 3118
4086 #ifndef USDT2
4087 DT_VOID_RETURN_MARK_DECL(GetStringRegion);
4088 #else /* USDT2 */
4089 DT_VOID_RETURN_MARK_DECL(GetStringRegion 3119 DT_VOID_RETURN_MARK_DECL(GetStringRegion
4090 , HOTSPOT_JNI_GETSTRINGREGION_RETURN()); 3120 , HOTSPOT_JNI_GETSTRINGREGION_RETURN());
4091 #endif /* USDT2 */
4092 3121
4093 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) 3122 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
4094 JNIWrapper("GetStringRegion"); 3123 JNIWrapper("GetStringRegion");
4095 #ifndef USDT2
4096 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf);
4097 #else /* USDT2 */
4098 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf); 3124 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
4099 #endif /* USDT2 */
4100 DT_VOID_RETURN_MARK(GetStringRegion); 3125 DT_VOID_RETURN_MARK(GetStringRegion);
4101 oop s = JNIHandles::resolve_non_null(string); 3126 oop s = JNIHandles::resolve_non_null(string);
4102 int s_len = java_lang_String::length(s); 3127 int s_len = java_lang_String::length(s);
4103 if (start < 0 || len < 0 || start + len > s_len) { 3128 if (start < 0 || len < 0 || start + len > s_len) {
4104 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); 3129 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
4109 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); 3134 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len);
4110 } 3135 }
4111 } 3136 }
4112 JNI_END 3137 JNI_END
4113 3138
4114 #ifndef USDT2
4115 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion);
4116 #else /* USDT2 */
4117 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion 3139 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
4118 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN()); 3140 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
4119 #endif /* USDT2 */
4120 3141
4121 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) 3142 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
4122 JNIWrapper("GetStringUTFRegion"); 3143 JNIWrapper("GetStringUTFRegion");
4123 #ifndef USDT2
4124 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf);
4125 #else /* USDT2 */
4126 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf); 3144 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
4127 #endif /* USDT2 */
4128 DT_VOID_RETURN_MARK(GetStringUTFRegion); 3145 DT_VOID_RETURN_MARK(GetStringUTFRegion);
4129 oop s = JNIHandles::resolve_non_null(string); 3146 oop s = JNIHandles::resolve_non_null(string);
4130 int s_len = java_lang_String::length(s); 3147 int s_len = java_lang_String::length(s);
4131 if (start < 0 || len < 0 || start + len > s_len) { 3148 if (start < 0 || len < 0 || start + len > s_len) {
4132 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); 3149 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
4148 JNI_END 3165 JNI_END
4149 3166
4150 3167
4151 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) 3168 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
4152 JNIWrapper("GetPrimitiveArrayCritical"); 3169 JNIWrapper("GetPrimitiveArrayCritical");
4153 #ifndef USDT2
4154 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy);
4155 #else /* USDT2 */
4156 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy); 3170 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
4157 #endif /* USDT2 */
4158 GC_locker::lock_critical(thread); 3171 GC_locker::lock_critical(thread);
4159 if (isCopy != NULL) { 3172 if (isCopy != NULL) {
4160 *isCopy = JNI_FALSE; 3173 *isCopy = JNI_FALSE;
4161 } 3174 }
4162 oop a = JNIHandles::resolve_non_null(array); 3175 oop a = JNIHandles::resolve_non_null(array);
4166 type = T_OBJECT; 3179 type = T_OBJECT;
4167 } else { 3180 } else {
4168 type = TypeArrayKlass::cast(a->klass())->element_type(); 3181 type = TypeArrayKlass::cast(a->klass())->element_type();
4169 } 3182 }
4170 void* ret = arrayOop(a)->base(type); 3183 void* ret = arrayOop(a)->base(type);
4171 #ifndef USDT2
4172 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
4173 #else /* USDT2 */
4174 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret); 3184 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
4175 #endif /* USDT2 */
4176 return ret; 3185 return ret;
4177 JNI_END 3186 JNI_END
4178 3187
4179 3188
4180 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) 3189 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
4181 JNIWrapper("ReleasePrimitiveArrayCritical"); 3190 JNIWrapper("ReleasePrimitiveArrayCritical");
4182 #ifndef USDT2
4183 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode);
4184 #else /* USDT2 */
4185 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode); 3191 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
4186 #endif /* USDT2 */
4187 // The array, carray and mode arguments are ignored 3192 // The array, carray and mode arguments are ignored
4188 GC_locker::unlock_critical(thread); 3193 GC_locker::unlock_critical(thread);
4189 #ifndef USDT2
4190 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return);
4191 #else /* USDT2 */
4192 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(); 3194 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN();
4193 #endif /* USDT2 */
4194 JNI_END 3195 JNI_END
4195 3196
4196 3197
4197 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) 3198 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
4198 JNIWrapper("GetStringCritical"); 3199 JNIWrapper("GetStringCritical");
4199 #ifndef USDT2
4200 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy);
4201 #else /* USDT2 */
4202 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy); 3200 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
4203 #endif /* USDT2 */
4204 GC_locker::lock_critical(thread); 3201 GC_locker::lock_critical(thread);
4205 if (isCopy != NULL) { 3202 if (isCopy != NULL) {
4206 *isCopy = JNI_FALSE; 3203 *isCopy = JNI_FALSE;
4207 } 3204 }
4208 oop s = JNIHandles::resolve_non_null(string); 3205 oop s = JNIHandles::resolve_non_null(string);
4213 if (s_len > 0) { 3210 if (s_len > 0) {
4214 ret = s_value->char_at_addr(s_offset); 3211 ret = s_value->char_at_addr(s_offset);
4215 } else { 3212 } else {
4216 ret = (jchar*) s_value->base(T_CHAR); 3213 ret = (jchar*) s_value->base(T_CHAR);
4217 } 3214 }
4218 #ifndef USDT2
4219 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
4220 #else /* USDT2 */
4221 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret); 3215 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
4222 #endif /* USDT2 */
4223 return ret; 3216 return ret;
4224 JNI_END 3217 JNI_END
4225 3218
4226 3219
4227 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) 3220 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
4228 JNIWrapper("ReleaseStringCritical"); 3221 JNIWrapper("ReleaseStringCritical");
4229 #ifndef USDT2
4230 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars);
4231 #else /* USDT2 */
4232 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars); 3222 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
4233 #endif /* USDT2 */
4234 // The str and chars arguments are ignored 3223 // The str and chars arguments are ignored
4235 GC_locker::unlock_critical(thread); 3224 GC_locker::unlock_critical(thread);
4236 #ifndef USDT2
4237 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return);
4238 #else /* USDT2 */
4239 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(); 3225 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
4240 #endif /* USDT2 */
4241 JNI_END 3226 JNI_END
4242 3227
4243 3228
4244 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) 3229 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
4245 JNIWrapper("jni_NewWeakGlobalRef"); 3230 JNIWrapper("jni_NewWeakGlobalRef");
4246 #ifndef USDT2
4247 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref);
4248 #else /* USDT2 */
4249 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref); 3231 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
4250 #endif /* USDT2 */
4251 Handle ref_handle(thread, JNIHandles::resolve(ref)); 3232 Handle ref_handle(thread, JNIHandles::resolve(ref));
4252 jweak ret = JNIHandles::make_weak_global(ref_handle); 3233 jweak ret = JNIHandles::make_weak_global(ref_handle);
4253 #ifndef USDT2
4254 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret);
4255 #else /* USDT2 */
4256 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret); 3234 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
4257 #endif /* USDT2 */
4258 return ret; 3235 return ret;
4259 JNI_END 3236 JNI_END
4260 3237
4261 // Must be JNI_ENTRY (with HandleMark) 3238 // Must be JNI_ENTRY (with HandleMark)
4262 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) 3239 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
4263 JNIWrapper("jni_DeleteWeakGlobalRef"); 3240 JNIWrapper("jni_DeleteWeakGlobalRef");
4264 #ifndef USDT2
4265 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref);
4266 #else /* USDT2 */
4267 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref); 3241 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
4268 #endif /* USDT2 */
4269 JNIHandles::destroy_weak_global(ref); 3242 JNIHandles::destroy_weak_global(ref);
4270 #ifndef USDT2
4271 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
4272 #else /* USDT2 */
4273 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(); 3243 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
4274 #endif /* USDT2 */
4275 JNI_END 3244 JNI_END
4276 3245
4277 3246
4278 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) 3247 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
4279 JNIWrapper("jni_ExceptionCheck"); 3248 JNIWrapper("jni_ExceptionCheck");
4280 #ifndef USDT2
4281 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env);
4282 #else /* USDT2 */
4283 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env); 3249 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
4284 #endif /* USDT2 */
4285 jni_check_async_exceptions(thread); 3250 jni_check_async_exceptions(thread);
4286 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; 3251 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
4287 #ifndef USDT2
4288 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret);
4289 #else /* USDT2 */
4290 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret); 3252 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
4291 #endif /* USDT2 */
4292 return ret; 3253 return ret;
4293 JNI_END 3254 JNI_END
4294 3255
4295 3256
4296 // Initialization state for three routines below relating to 3257 // Initialization state for three routines below relating to
4393 { 3354 {
4394 // thread_from_jni_environment() will block if VM is gone. 3355 // thread_from_jni_environment() will block if VM is gone.
4395 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 3356 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
4396 3357
4397 JNIWrapper("jni_NewDirectByteBuffer"); 3358 JNIWrapper("jni_NewDirectByteBuffer");
4398 #ifndef USDT2
4399 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
4400 #else /* USDT2 */
4401 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity); 3359 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
4402 #endif /* USDT2 */
4403 3360
4404 if (!directBufferSupportInitializeEnded) { 3361 if (!directBufferSupportInitializeEnded) {
4405 if (!initializeDirectBufferSupport(env, thread)) { 3362 if (!initializeDirectBufferSupport(env, thread)) {
4406 #ifndef USDT2
4407 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL);
4408 #else /* USDT2 */
4409 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL); 3363 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL);
4410 #endif /* USDT2 */
4411 return NULL; 3364 return NULL;
4412 } 3365 }
4413 } 3366 }
4414 3367
4415 // Being paranoid about accidental sign extension on address 3368 // Being paranoid about accidental sign extension on address
4416 jlong addr = (jlong) ((uintptr_t) address); 3369 jlong addr = (jlong) ((uintptr_t) address);
4417 // NOTE that package-private DirectByteBuffer constructor currently 3370 // NOTE that package-private DirectByteBuffer constructor currently
4418 // takes int capacity 3371 // takes int capacity
4419 jint cap = (jint) capacity; 3372 jint cap = (jint) capacity;
4420 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); 3373 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
4421 #ifndef USDT2
4422 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret);
4423 #else /* USDT2 */
4424 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret); 3374 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
4425 #endif /* USDT2 */
4426 return ret; 3375 return ret;
4427 } 3376 }
4428 3377
4429 #ifndef USDT2
4430 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*);
4431 #else /* USDT2 */
4432 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void* 3378 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
4433 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref)); 3379 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
4434 #endif /* USDT2 */
4435 3380
4436 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) 3381 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
4437 { 3382 {
4438 // thread_from_jni_environment() will block if VM is gone. 3383 // thread_from_jni_environment() will block if VM is gone.
4439 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 3384 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
4440 3385
4441 JNIWrapper("jni_GetDirectBufferAddress"); 3386 JNIWrapper("jni_GetDirectBufferAddress");
4442 #ifndef USDT2
4443 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
4444 #else /* USDT2 */
4445 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf); 3387 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
4446 #endif /* USDT2 */
4447 void* ret = NULL; 3388 void* ret = NULL;
4448 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); 3389 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
4449 3390
4450 if (!directBufferSupportInitializeEnded) { 3391 if (!directBufferSupportInitializeEnded) {
4451 if (!initializeDirectBufferSupport(env, thread)) { 3392 if (!initializeDirectBufferSupport(env, thread)) {
4459 3400
4460 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); 3401 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
4461 return ret; 3402 return ret;
4462 } 3403 }
4463 3404
4464 #ifndef USDT2
4465 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong);
4466 #else /* USDT2 */
4467 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong 3405 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
4468 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref)); 3406 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
4469 #endif /* USDT2 */
4470 3407
4471 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) 3408 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
4472 { 3409 {
4473 // thread_from_jni_environment() will block if VM is gone. 3410 // thread_from_jni_environment() will block if VM is gone.
4474 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 3411 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
4475 3412
4476 JNIWrapper("jni_GetDirectBufferCapacity"); 3413 JNIWrapper("jni_GetDirectBufferCapacity");
4477 #ifndef USDT2
4478 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
4479 #else /* USDT2 */
4480 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf); 3414 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
4481 #endif /* USDT2 */
4482 jlong ret = -1; 3415 jlong ret = -1;
4483 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); 3416 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
4484 3417
4485 if (!directBufferSupportInitializeEnded) { 3418 if (!directBufferSupportInitializeEnded) {
4486 if (!initializeDirectBufferSupport(env, thread)) { 3419 if (!initializeDirectBufferSupport(env, thread)) {
4503 } 3436 }
4504 3437
4505 3438
4506 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) 3439 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
4507 JNIWrapper("GetVersion"); 3440 JNIWrapper("GetVersion");
4508 #ifndef USDT2
4509 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
4510 #else /* USDT2 */
4511 HOTSPOT_JNI_GETVERSION_ENTRY(env); 3441 HOTSPOT_JNI_GETVERSION_ENTRY(env);
4512 #endif /* USDT2 */
4513 #ifndef USDT2
4514 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
4515 #else /* USDT2 */
4516 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion); 3442 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
4517 #endif /* USDT2 */
4518 return CurrentVersion; 3443 return CurrentVersion;
4519 JNI_END 3444 JNI_END
4520 3445
4521 extern struct JavaVM_ main_vm; 3446 extern struct JavaVM_ main_vm;
4522 3447
4523 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) 3448 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
4524 JNIWrapper("jni_GetJavaVM"); 3449 JNIWrapper("jni_GetJavaVM");
4525 #ifndef USDT2
4526 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm);
4527 #else /* USDT2 */
4528 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm); 3450 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
4529 #endif /* USDT2 */
4530 *vm = (JavaVM *)(&main_vm); 3451 *vm = (JavaVM *)(&main_vm);
4531 #ifndef USDT2
4532 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK);
4533 #else /* USDT2 */
4534 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK); 3452 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
4535 #endif /* USDT2 */
4536 return JNI_OK; 3453 return JNI_OK;
4537 JNI_END 3454 JNI_END
4538 3455
4539 // Structure containing all jni functions 3456 // Structure containing all jni functions
4540 struct JNINativeInterface_ jni_NativeInterface = { 3457 struct JNINativeInterface_ jni_NativeInterface = {
4908 3825
4909 3826
4910 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */ 3827 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */
4911 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL }; 3828 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
4912 3829
4913 #ifndef USDT2
4914 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*);
4915 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint);
4916 #else /* USDT2 */
4917 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint 3830 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
4918 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref)); 3831 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
4919 #endif /* USDT2 */
4920 3832
4921 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) { 3833 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
4922 #ifndef USDT2
4923 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_);
4924 #else /* USDT2 */
4925 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_); 3834 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
4926 #endif /* USDT2 */
4927 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_; 3835 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
4928 jint ret = JNI_ERR; 3836 jint ret = JNI_ERR;
4929 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret); 3837 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
4930 3838
4931 if (Threads::is_supported_jni_version(args->version)) { 3839 if (Threads::is_supported_jni_version(args->version)) {
5007 3915
5008 #undef run_unit_test 3916 #undef run_unit_test
5009 3917
5010 #endif 3918 #endif
5011 3919
5012 #ifndef USDT2
5013 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5014 DT_RETURN_MARK_DECL(CreateJavaVM, jint);
5015 #else /* USDT2 */
5016 DT_RETURN_MARK_DECL(CreateJavaVM, jint 3920 DT_RETURN_MARK_DECL(CreateJavaVM, jint
5017 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref)); 3921 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
5018 #endif /* USDT2 */
5019 3922
5020 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) { 3923 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
5021 #ifndef USDT2
5022 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5023 #else /* USDT2 */
5024 HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args); 3924 HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
5025 #endif /* USDT2 */
5026 3925
5027 jint result = JNI_ERR; 3926 jint result = JNI_ERR;
5028 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result); 3927 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
5029 3928
5030 // We're about to use Atomic::xchg for synchronization. Some Zero 3929 // We're about to use Atomic::xchg for synchronization. Some Zero
5142 } 4041 }
5143 4042
5144 return result; 4043 return result;
5145 } 4044 }
5146 4045
5147 #ifndef USDT2
5148 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \
5149 JavaVM**, jsize, jsize*);
5150 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint);
5151 #endif /* !USDT2 */
5152 4046
5153 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { 4047 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
5154 // See bug 4367188, the wrapper can sometimes cause VM crashes 4048 // See bug 4367188, the wrapper can sometimes cause VM crashes
5155 // JNIWrapper("GetCreatedJavaVMs"); 4049 // JNIWrapper("GetCreatedJavaVMs");
5156 #ifndef USDT2 4050
5157 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
5158 vm_buf, bufLen, numVMs);
5159 #else /* USDT2 */
5160 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs); 4051 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
5161 #endif /* USDT2 */ 4052
5162 if (vm_created) { 4053 if (vm_created) {
5163 if (numVMs != NULL) *numVMs = 1; 4054 if (numVMs != NULL) *numVMs = 1;
5164 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); 4055 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
5165 } else { 4056 } else {
5166 if (numVMs != NULL) *numVMs = 0; 4057 if (numVMs != NULL) *numVMs = 0;
5167 } 4058 }
5168 #ifndef USDT2
5169 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK);
5170 #else /* USDT2 */
5171 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK); 4059 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
5172 #endif /* USDT2 */
5173 return JNI_OK; 4060 return JNI_OK;
5174 } 4061 }
5175 4062
5176 extern "C" { 4063 extern "C" {
5177 4064
5178 #ifndef USDT2
5179 DT_RETURN_MARK_DECL(DestroyJavaVM, jint);
5180 #else /* USDT2 */
5181 DT_RETURN_MARK_DECL(DestroyJavaVM, jint 4065 DT_RETURN_MARK_DECL(DestroyJavaVM, jint
5182 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref)); 4066 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
5183 #endif /* USDT2 */
5184 4067
5185 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { 4068 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
5186 #ifndef USDT2
5187 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
5188 #else /* USDT2 */
5189 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm); 4069 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
5190 #endif /* USDT2 */
5191 jint res = JNI_ERR; 4070 jint res = JNI_ERR;
5192 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); 4071 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
5193 4072
5194 if (!vm_created) { 4073 if (!vm_created) {
5195 res = JNI_ERR; 4074 res = JNI_ERR;
5337 return JNI_OK; 4216 return JNI_OK;
5338 } 4217 }
5339 4218
5340 4219
5341 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { 4220 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
5342 #ifndef USDT2
5343 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args);
5344 #else /* USDT2 */
5345 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args); 4221 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
5346 #endif /* USDT2 */
5347 if (!vm_created) { 4222 if (!vm_created) {
5348 #ifndef USDT2
5349 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
5350 #else /* USDT2 */
5351 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); 4223 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
5352 #endif /* USDT2 */
5353 return JNI_ERR; 4224 return JNI_ERR;
5354 } 4225 }
5355 4226
5356 JNIWrapper("AttachCurrentThread"); 4227 JNIWrapper("AttachCurrentThread");
5357 jint ret = attach_current_thread(vm, penv, _args, false); 4228 jint ret = attach_current_thread(vm, penv, _args, false);
5358 #ifndef USDT2
5359 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret);
5360 #else /* USDT2 */
5361 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret); 4229 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
5362 #endif /* USDT2 */
5363 return ret; 4230 return ret;
5364 } 4231 }
5365 4232
5366 4233
5367 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { 4234 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
5368 #ifndef USDT2
5369 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm);
5370 #else /* USDT2 */
5371 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm); 4235 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
5372 #endif /* USDT2 */
5373 VM_Exit::block_if_vm_exited(); 4236 VM_Exit::block_if_vm_exited();
5374 4237
5375 JNIWrapper("DetachCurrentThread"); 4238 JNIWrapper("DetachCurrentThread");
5376 4239
5377 // If the thread has been deattacted the operations is a no-op 4240 // If the thread has been deattacted the operations is a no-op
5378 if (ThreadLocalStorage::thread() == NULL) { 4241 if (ThreadLocalStorage::thread() == NULL) {
5379 #ifndef USDT2
5380 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5381 #else /* USDT2 */
5382 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK); 4242 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
5383 #endif /* USDT2 */
5384 return JNI_OK; 4243 return JNI_OK;
5385 } 4244 }
5386 4245
5387 JavaThread* thread = JavaThread::current(); 4246 JavaThread* thread = JavaThread::current();
5388 if (thread->has_last_Java_frame()) { 4247 if (thread->has_last_Java_frame()) {
5389 #ifndef USDT2
5390 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR);
5391 #else /* USDT2 */
5392 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); 4248 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
5393 #endif /* USDT2 */
5394 // Can't detach a thread that's running java, that can't work. 4249 // Can't detach a thread that's running java, that can't work.
5395 return JNI_ERR; 4250 return JNI_ERR;
5396 } 4251 }
5397 4252
5398 // Safepoint support. Have to do call-back to safepoint code, if in the 4253 // Safepoint support. Have to do call-back to safepoint code, if in the
5409 // (platform-dependent) methods where we do alternate stack 4264 // (platform-dependent) methods where we do alternate stack
5410 // maintenance work?) 4265 // maintenance work?)
5411 thread->exit(false, JavaThread::jni_detach); 4266 thread->exit(false, JavaThread::jni_detach);
5412 delete thread; 4267 delete thread;
5413 4268
5414 #ifndef USDT2
5415 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5416 #else /* USDT2 */
5417 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK); 4269 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
5418 #endif /* USDT2 */
5419 return JNI_OK; 4270 return JNI_OK;
5420 } 4271 }
5421 4272
5422 #ifndef USDT2
5423 DT_RETURN_MARK_DECL(GetEnv, jint);
5424 #else /* USDT2 */
5425 DT_RETURN_MARK_DECL(GetEnv, jint 4273 DT_RETURN_MARK_DECL(GetEnv, jint
5426 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref)); 4274 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
5427 #endif /* USDT2 */
5428 4275
5429 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) { 4276 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
5430 #ifndef USDT2
5431 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version);
5432 #else /* USDT2 */
5433 HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version); 4277 HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
5434 #endif /* USDT2 */
5435 jint ret = JNI_ERR; 4278 jint ret = JNI_ERR;
5436 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret); 4279 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
5437 4280
5438 if (!vm_created) { 4281 if (!vm_created) {
5439 *penv = NULL; 4282 *penv = NULL;
5483 } 4326 }
5484 } 4327 }
5485 4328
5486 4329
5487 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) { 4330 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
5488 #ifndef USDT2
5489 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args);
5490 #else /* USDT2 */
5491 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args); 4331 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
5492 #endif /* USDT2 */
5493 if (!vm_created) { 4332 if (!vm_created) {
5494 #ifndef USDT2
5495 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
5496 #else /* USDT2 */
5497 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR); 4333 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
5498 #endif /* USDT2 */
5499 return JNI_ERR; 4334 return JNI_ERR;
5500 } 4335 }
5501 4336
5502 JNIWrapper("AttachCurrentThreadAsDaemon"); 4337 JNIWrapper("AttachCurrentThreadAsDaemon");
5503 jint ret = attach_current_thread(vm, penv, _args, true); 4338 jint ret = attach_current_thread(vm, penv, _args, true);
5504 #ifndef USDT2
5505 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret);
5506 #else /* USDT2 */
5507 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret); 4339 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
5508 #endif /* USDT2 */
5509 return ret; 4340 return ret;
5510 } 4341 }
5511 4342
5512 4343
5513 } // End extern "C" 4344 } // End extern "C"