Mercurial > hg > graal-compiler

comparison src/share/vm/prims/jni.cpp @ 14909:4ca6dc0799b6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Backout jdk9 merge
author Gilles Duboscq <duboscq@ssw.jku.at>
date Tue, 01 Apr 2014 13:57:07 +0200
parents d8041d695d19
children 0aed1c2d0caa
comparison
equal deleted inserted replaced
14908:8db6e76cb658 14909:4ca6dc0799b6
1 /* 1 /*
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2012 Red Hat, Inc. 3 * Copyright (c) 2012 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 * 5 *
6 * This code is free software; you can redistribute it and/or modify it 6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as 7 * under the terms of the GNU General Public License version 2 only, as
115 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value); 115 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
116 // foo(CHECK_0) 116 // foo(CHECK_0)
117 // return_value = 5; 117 // return_value = 5;
118 // return return_value; 118 // return return_value;
119 // JNI_END 119 // JNI_END
120 #ifndef USDT2
121 #define DT_RETURN_MARK_DECL(name, type) \
122 HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \
123 DTRACE_ONLY( \
124 class DTraceReturnProbeMark_##name { \
125 public: \
126 const type& _ret_ref; \
127 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \
128 ~DTraceReturnProbeMark_##name() { \
129 HS_DTRACE_PROBE1(hotspot_jni, name##__return, _ret_ref); \
130 } \
131 } \
132 )
133 // Void functions are simpler since there's no return value
134 #define DT_VOID_RETURN_MARK_DECL(name) \
135 HS_DTRACE_PROBE_DECL0(hotspot_jni, name##__return); \
136 DTRACE_ONLY( \
137 class DTraceReturnProbeMark_##name { \
138 public: \
139 ~DTraceReturnProbeMark_##name() { \
140 HS_DTRACE_PROBE0(hotspot_jni, name##__return); \
141 } \
142 } \
143 )
144
145 #else /* USDT2 */
146
120 #define DT_RETURN_MARK_DECL(name, type, probe) \ 147 #define DT_RETURN_MARK_DECL(name, type, probe) \
121 DTRACE_ONLY( \ 148 DTRACE_ONLY( \
122 class DTraceReturnProbeMark_##name { \ 149 class DTraceReturnProbeMark_##name { \
123 public: \ 150 public: \
124 const type& _ret_ref; \ 151 const type& _ret_ref; \
136 ~DTraceReturnProbeMark_##name() { \ 163 ~DTraceReturnProbeMark_##name() { \
137 probe; \ 164 probe; \
138 } \ 165 } \
139 } \ 166 } \
140 ) 167 )
168 #endif /* USDT2 */
141 169
142 // Place these macros in the function to mark the return. Non-void 170 // Place these macros in the function to mark the return. Non-void
143 // functions need the type and address of the return value. 171 // functions need the type and address of the return value.
144 #define DT_RETURN_MARK(name, type, ref) \ 172 #define DT_RETURN_MARK(name, type, ref) \
145 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) ) 173 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
164 192
165 #define COMMA , 193 #define COMMA ,
166 194
167 // Choose DT_RETURN_MARK macros based on the type: float/double -> void 195 // Choose DT_RETURN_MARK macros based on the type: float/double -> void
168 // (dtrace doesn't do FP yet) 196 // (dtrace doesn't do FP yet)
197 #ifndef USDT2
198 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \
199 FP_SELECT(TypeName, \
200 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) )
201 #else /* USDT2 */
169 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \ 202 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \
170 FP_SELECT(TypeName, \ 203 FP_SELECT(TypeName, \
171 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) ) 204 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )
205 #endif /* USDT2 */
172 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ 206 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
173 FP_SELECT(TypeName, \ 207 FP_SELECT(TypeName, \
174 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) 208 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
175 209
176 210
325 #endif 359 #endif
326 360
327 361
328 // Implementation of JNI entries 362 // Implementation of JNI entries
329 363
364 #ifndef USDT2
365 DT_RETURN_MARK_DECL(DefineClass, jclass);
366 #else /* USDT2 */
330 DT_RETURN_MARK_DECL(DefineClass, jclass 367 DT_RETURN_MARK_DECL(DefineClass, jclass
331 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref)); 368 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
369 #endif /* USDT2 */
332 370
333 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, 371 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
334 const jbyte *buf, jsize bufLen)) 372 const jbyte *buf, jsize bufLen))
335 JNIWrapper("DefineClass"); 373 JNIWrapper("DefineClass");
336 374
375 #ifndef USDT2
376 DTRACE_PROBE5(hotspot_jni, DefineClass__entry,
377 env, name, loaderRef, buf, bufLen);
378 #else /* USDT2 */
337 HOTSPOT_JNI_DEFINECLASS_ENTRY( 379 HOTSPOT_JNI_DEFINECLASS_ENTRY(
338 env, (char*) name, loaderRef, (char*) buf, bufLen); 380 env, (char*) name, loaderRef, (char*) buf, bufLen);
339 381 #endif /* USDT2 */
340 jclass cls = NULL; 382 jclass cls = NULL;
341 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); 383 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
342 384
343 TempNewSymbol class_name = NULL; 385 TempNewSymbol class_name = NULL;
344 // Since exceptions can be thrown, class initialization can take place 386 // Since exceptions can be thrown, class initialization can take place
380 422
381 423
382 424
383 static bool first_time_FindClass = true; 425 static bool first_time_FindClass = true;
384 426
427 #ifndef USDT2
428 DT_RETURN_MARK_DECL(FindClass, jclass);
429 #else /* USDT2 */
385 DT_RETURN_MARK_DECL(FindClass, jclass 430 DT_RETURN_MARK_DECL(FindClass, jclass
386 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref)); 431 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
432 #endif /* USDT2 */
387 433
388 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name)) 434 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
389 JNIWrapper("FindClass"); 435 JNIWrapper("FindClass");
390 436 #ifndef USDT2
391 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name); 437 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);
438 #else /* USDT2 */
439 HOTSPOT_JNI_FINDCLASS_ENTRY(
440 env, (char *)name);
441 #endif /* USDT2 */
392 442
393 jclass result = NULL; 443 jclass result = NULL;
394 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result); 444 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
395 445
396 // Remember if we are the first invocation of jni_FindClass 446 // Remember if we are the first invocation of jni_FindClass
450 CompilationPolicy::completed_vm_startup(); 500 CompilationPolicy::completed_vm_startup();
451 501
452 return result; 502 return result;
453 JNI_END 503 JNI_END
454 504
505 #ifndef USDT2
506 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID);
507 #else /* USDT2 */
455 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID 508 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
456 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref)); 509 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
510 #endif /* USDT2 */
457 511
458 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method)) 512 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
459 JNIWrapper("FromReflectedMethod"); 513 JNIWrapper("FromReflectedMethod");
460 514 #ifndef USDT2
461 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method); 515 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method);
462 516 #else /* USDT2 */
517 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(
518 env, method);
519 #endif /* USDT2 */
463 jmethodID ret = NULL; 520 jmethodID ret = NULL;
464 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret); 521 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
465 522
466 // method is a handle to a java.lang.reflect.Method object 523 // method is a handle to a java.lang.reflect.Method object
467 oop reflected = JNIHandles::resolve_non_null(method); 524 oop reflected = JNIHandles::resolve_non_null(method);
484 Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot); 541 Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot);
485 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted 542 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
486 return ret; 543 return ret;
487 JNI_END 544 JNI_END
488 545
546 #ifndef USDT2
547 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID);
548 #else /* USDT2 */
489 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID 549 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
490 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref)); 550 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
551 #endif /* USDT2 */
491 552
492 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field)) 553 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
493 JNIWrapper("FromReflectedField"); 554 JNIWrapper("FromReflectedField");
494 555 #ifndef USDT2
495 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field); 556 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field);
496 557 #else /* USDT2 */
558 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(
559 env, field);
560 #endif /* USDT2 */
497 jfieldID ret = NULL; 561 jfieldID ret = NULL;
498 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret); 562 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
499 563
500 // field is a handle to a java.lang.reflect.Field object 564 // field is a handle to a java.lang.reflect.Field object
501 oop reflected = JNIHandles::resolve_non_null(field); 565 oop reflected = JNIHandles::resolve_non_null(field);
526 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); 590 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
527 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); 591 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
528 return ret; 592 return ret;
529 JNI_END 593 JNI_END
530 594
531 595 #ifndef USDT2
596 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject);
597 #else /* USDT2 */
532 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject 598 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
533 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref)); 599 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
600 #endif /* USDT2 */
534 601
535 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) 602 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
536 JNIWrapper("ToReflectedMethod"); 603 JNIWrapper("ToReflectedMethod");
537 604 #ifndef USDT2
538 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic); 605 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);
539 606 #else /* USDT2 */
607 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(
608 env, cls, (uintptr_t) method_id, isStatic);
609 #endif /* USDT2 */
540 jobject ret = NULL; 610 jobject ret = NULL;
541 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); 611 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
542 612
543 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id)); 613 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
544 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); 614 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
550 } 620 }
551 ret = JNIHandles::make_local(env, reflection_method); 621 ret = JNIHandles::make_local(env, reflection_method);
552 return ret; 622 return ret;
553 JNI_END 623 JNI_END
554 624
625 #ifndef USDT2
626 DT_RETURN_MARK_DECL(GetSuperclass, jclass);
627 #else /* USDT2 */
555 DT_RETURN_MARK_DECL(GetSuperclass, jclass 628 DT_RETURN_MARK_DECL(GetSuperclass, jclass
556 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref)); 629 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
630 #endif /* USDT2 */
557 631
558 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub)) 632 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
559 JNIWrapper("GetSuperclass"); 633 JNIWrapper("GetSuperclass");
560 634 #ifndef USDT2
561 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub); 635 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub);
562 636 #else /* USDT2 */
637 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(
638 env, sub);
639 #endif /* USDT2 */
563 jclass obj = NULL; 640 jclass obj = NULL;
564 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj); 641 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
565 642
566 oop mirror = JNIHandles::resolve_non_null(sub); 643 oop mirror = JNIHandles::resolve_non_null(sub);
567 // primitive classes return NULL 644 // primitive classes return NULL
586 return obj; 663 return obj;
587 JNI_END 664 JNI_END
588 665
589 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) 666 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
590 JNIWrapper("IsSubclassOf"); 667 JNIWrapper("IsSubclassOf");
591 668 #ifndef USDT2
592 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super); 669 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super);
593 670 #else /* USDT2 */
671 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(
672 env, sub, super);
673 #endif /* USDT2 */
594 oop sub_mirror = JNIHandles::resolve_non_null(sub); 674 oop sub_mirror = JNIHandles::resolve_non_null(sub);
595 oop super_mirror = JNIHandles::resolve_non_null(super); 675 oop super_mirror = JNIHandles::resolve_non_null(super);
596 if (java_lang_Class::is_primitive(sub_mirror) || 676 if (java_lang_Class::is_primitive(sub_mirror) ||
597 java_lang_Class::is_primitive(super_mirror)) { 677 java_lang_Class::is_primitive(super_mirror)) {
598 jboolean ret = (sub_mirror == super_mirror); 678 jboolean ret = (sub_mirror == super_mirror);
599 679 #ifndef USDT2
600 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); 680 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
681 #else /* USDT2 */
682 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(
683 ret);
684 #endif /* USDT2 */
601 return ret; 685 return ret;
602 } 686 }
603 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror); 687 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
604 Klass* super_klass = java_lang_Class::as_Klass(super_mirror); 688 Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
605 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); 689 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
606 jboolean ret = sub_klass->is_subtype_of(super_klass) ? 690 jboolean ret = sub_klass->is_subtype_of(super_klass) ?
607 JNI_TRUE : JNI_FALSE; 691 JNI_TRUE : JNI_FALSE;
608 692 #ifndef USDT2
609 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); 693 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
694 #else /* USDT2 */
695 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(
696 ret);
697 #endif /* USDT2 */
610 return ret; 698 return ret;
611 JNI_END 699 JNI_END
612 700
613 701 #ifndef USDT2
702 DT_RETURN_MARK_DECL(Throw, jint);
703 #else /* USDT2 */
614 DT_RETURN_MARK_DECL(Throw, jint 704 DT_RETURN_MARK_DECL(Throw, jint
615 , HOTSPOT_JNI_THROW_RETURN(_ret_ref)); 705 , HOTSPOT_JNI_THROW_RETURN(_ret_ref));
706 #endif /* USDT2 */
616 707
617 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) 708 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
618 JNIWrapper("Throw"); 709 JNIWrapper("Throw");
619 710 #ifndef USDT2
620 HOTSPOT_JNI_THROW_ENTRY(env, obj); 711 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj);
621 712 #else /* USDT2 */
713 HOTSPOT_JNI_THROW_ENTRY(
714 env, obj);
715 #endif /* USDT2 */
622 jint ret = JNI_OK; 716 jint ret = JNI_OK;
623 DT_RETURN_MARK(Throw, jint, (const jint&)ret); 717 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
624 718
625 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); 719 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
626 ShouldNotReachHere(); 720 ShouldNotReachHere();
627 JNI_END 721 JNI_END
628 722
629 723 #ifndef USDT2
724 DT_RETURN_MARK_DECL(ThrowNew, jint);
725 #else /* USDT2 */
630 DT_RETURN_MARK_DECL(ThrowNew, jint 726 DT_RETURN_MARK_DECL(ThrowNew, jint
631 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref)); 727 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
728 #endif /* USDT2 */
632 729
633 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) 730 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
634 JNIWrapper("ThrowNew"); 731 JNIWrapper("ThrowNew");
635 732 #ifndef USDT2
636 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message); 733 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
637 734 #else /* USDT2 */
735 HOTSPOT_JNI_THROWNEW_ENTRY(
736 env, clazz, (char *) message);
737 #endif /* USDT2 */
638 jint ret = JNI_OK; 738 jint ret = JNI_OK;
639 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); 739 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
640 740
641 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 741 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
642 Symbol* name = k->name(); 742 Symbol* name = k->name();
661 thread->check_and_handle_async_exceptions(); 761 thread->check_and_handle_async_exceptions();
662 } 762 }
663 763
664 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) 764 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
665 JNIWrapper("ExceptionOccurred"); 765 JNIWrapper("ExceptionOccurred");
666 766 #ifndef USDT2
667 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env); 767 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env);
668 768 #else /* USDT2 */
769 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(
770 env);
771 #endif /* USDT2 */
669 jni_check_async_exceptions(thread); 772 jni_check_async_exceptions(thread);
670 oop exception = thread->pending_exception(); 773 oop exception = thread->pending_exception();
671 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); 774 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
672 775 #ifndef USDT2
673 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret); 776 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret);
777 #else /* USDT2 */
778 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(
779 ret);
780 #endif /* USDT2 */
674 return ret; 781 return ret;
675 JNI_END 782 JNI_END
676 783
677 784
678 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) 785 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
679 JNIWrapper("ExceptionDescribe"); 786 JNIWrapper("ExceptionDescribe");
680 787 #ifndef USDT2
681 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env); 788 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env);
682 789 #else /* USDT2 */
790 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(
791 env);
792 #endif /* USDT2 */
683 if (thread->has_pending_exception()) { 793 if (thread->has_pending_exception()) {
684 Handle ex(thread, thread->pending_exception()); 794 Handle ex(thread, thread->pending_exception());
685 thread->clear_pending_exception(); 795 thread->clear_pending_exception();
686 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { 796 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
687 // Don't print anything if we are being killed. 797 // Don't print anything if we are being killed.
713 ". Uncaught exception of type %s.", 823 ". Uncaught exception of type %s.",
714 ex->klass()->external_name()); 824 ex->klass()->external_name());
715 } 825 }
716 } 826 }
717 } 827 }
718 828 #ifndef USDT2
719 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(); 829 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
830 #else /* USDT2 */
831 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(
832 );
833 #endif /* USDT2 */
720 JNI_END 834 JNI_END
721 835
722 836
723 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) 837 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
724 JNIWrapper("ExceptionClear"); 838 JNIWrapper("ExceptionClear");
725 839 #ifndef USDT2
726 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env); 840 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env);
841 #else /* USDT2 */
842 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(
843 env);
844 #endif /* USDT2 */
727 845
728 // The jni code might be using this API to clear java thrown exception. 846 // The jni code might be using this API to clear java thrown exception.
729 // So just mark jvmti thread exception state as exception caught. 847 // So just mark jvmti thread exception state as exception caught.
730 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); 848 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
731 if (state != NULL && state->is_exception_detected()) { 849 if (state != NULL && state->is_exception_detected()) {
732 state->set_exception_caught(); 850 state->set_exception_caught();
733 } 851 }
734 thread->clear_pending_exception(); 852 thread->clear_pending_exception();
735 853 #ifndef USDT2
736 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(); 854 DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
855 #else /* USDT2 */
856 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(
857 );
858 #endif /* USDT2 */
737 JNI_END 859 JNI_END
738 860
739 861
740 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) 862 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
741 JNIWrapper("FatalError"); 863 JNIWrapper("FatalError");
742 864 #ifndef USDT2
743 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg); 865 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg);
744 866 #else /* USDT2 */
867 HOTSPOT_JNI_FATALERROR_ENTRY(
868 env, (char *) msg);
869 #endif /* USDT2 */
745 tty->print_cr("FATAL ERROR in native method: %s", msg); 870 tty->print_cr("FATAL ERROR in native method: %s", msg);
746 thread->print_stack(); 871 thread->print_stack();
747 os::abort(); // Dump core and abort 872 os::abort(); // Dump core and abort
748 JNI_END 873 JNI_END
749 874
750 875
751 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) 876 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
752 JNIWrapper("PushLocalFrame"); 877 JNIWrapper("PushLocalFrame");
753 878 #ifndef USDT2
754 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity); 879 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity);
755 880 #else /* USDT2 */
881 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(
882 env, capacity);
883 #endif /* USDT2 */
756 //%note jni_11 884 //%note jni_11
757 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) { 885 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) {
758 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR); 886 #ifndef USDT2
887 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR);
888 #else /* USDT2 */
889 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(
890 (uint32_t)JNI_ERR);
891 #endif /* USDT2 */
759 return JNI_ERR; 892 return JNI_ERR;
760 } 893 }
761 JNIHandleBlock* old_handles = thread->active_handles(); 894 JNIHandleBlock* old_handles = thread->active_handles();
762 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); 895 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
763 assert(new_handles != NULL, "should not be NULL"); 896 assert(new_handles != NULL, "should not be NULL");
764 new_handles->set_pop_frame_link(old_handles); 897 new_handles->set_pop_frame_link(old_handles);
765 thread->set_active_handles(new_handles); 898 thread->set_active_handles(new_handles);
766 jint ret = JNI_OK; 899 jint ret = JNI_OK;
767 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret); 900 #ifndef USDT2
901 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret);
902 #else /* USDT2 */
903 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(
904 ret);
905 #endif /* USDT2 */
768 return ret; 906 return ret;
769 JNI_END 907 JNI_END
770 908
771 909
772 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) 910 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
773 JNIWrapper("PopLocalFrame"); 911 JNIWrapper("PopLocalFrame");
774 912 #ifndef USDT2
775 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result); 913 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result);
776 914 #else /* USDT2 */
915 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(
916 env, result);
917 #endif /* USDT2 */
777 //%note jni_11 918 //%note jni_11
778 Handle result_handle(thread, JNIHandles::resolve(result)); 919 Handle result_handle(thread, JNIHandles::resolve(result));
779 JNIHandleBlock* old_handles = thread->active_handles(); 920 JNIHandleBlock* old_handles = thread->active_handles();
780 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); 921 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
781 if (new_handles != NULL) { 922 if (new_handles != NULL) {
786 thread->set_active_handles(new_handles); 927 thread->set_active_handles(new_handles);
787 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below 928 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
788 JNIHandleBlock::release_block(old_handles, thread); // may block 929 JNIHandleBlock::release_block(old_handles, thread); // may block
789 result = JNIHandles::make_local(thread, result_handle()); 930 result = JNIHandles::make_local(thread, result_handle());
790 } 931 }
791 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result); 932 #ifndef USDT2
933 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
934 #else /* USDT2 */
935 HOTSPOT_JNI_POPLOCALFRAME_RETURN(
936 result);
937 #endif /* USDT2 */
792 return result; 938 return result;
793 JNI_END 939 JNI_END
794 940
795 941
796 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) 942 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
797 JNIWrapper("NewGlobalRef"); 943 JNIWrapper("NewGlobalRef");
798 944 #ifndef USDT2
799 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref); 945 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref);
800 946 #else /* USDT2 */
947 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(
948 env, ref);
949 #endif /* USDT2 */
801 Handle ref_handle(thread, JNIHandles::resolve(ref)); 950 Handle ref_handle(thread, JNIHandles::resolve(ref));
802 jobject ret = JNIHandles::make_global(ref_handle); 951 jobject ret = JNIHandles::make_global(ref_handle);
803 952 #ifndef USDT2
804 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret); 953 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret);
954 #else /* USDT2 */
955 HOTSPOT_JNI_NEWGLOBALREF_RETURN(
956 ret);
957 #endif /* USDT2 */
805 return ret; 958 return ret;
806 JNI_END 959 JNI_END
807 960
808 // Must be JNI_ENTRY (with HandleMark) 961 // Must be JNI_ENTRY (with HandleMark)
809 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) 962 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
810 JNIWrapper("DeleteGlobalRef"); 963 JNIWrapper("DeleteGlobalRef");
811 964 #ifndef USDT2
812 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref); 965 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref);
813 966 #else /* USDT2 */
967 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(
968 env, ref);
969 #endif /* USDT2 */
814 JNIHandles::destroy_global(ref); 970 JNIHandles::destroy_global(ref);
815 971 #ifndef USDT2
816 HOTSPOT_JNI_DELETEGLOBALREF_RETURN(); 972 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
973 #else /* USDT2 */
974 HOTSPOT_JNI_DELETEGLOBALREF_RETURN(
975 );
976 #endif /* USDT2 */
817 JNI_END 977 JNI_END
818 978
819 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) 979 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
820 JNIWrapper("DeleteLocalRef"); 980 JNIWrapper("DeleteLocalRef");
821 981 #ifndef USDT2
822 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj); 982 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj);
823 983 #else /* USDT2 */
984 HOTSPOT_JNI_DELETELOCALREF_ENTRY(
985 env, obj);
986 #endif /* USDT2 */
824 JNIHandles::destroy_local(obj); 987 JNIHandles::destroy_local(obj);
825 988 #ifndef USDT2
826 HOTSPOT_JNI_DELETELOCALREF_RETURN(); 989 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
990 #else /* USDT2 */
991 HOTSPOT_JNI_DELETELOCALREF_RETURN(
992 );
993 #endif /* USDT2 */
827 JNI_END 994 JNI_END
828 995
829 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) 996 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
830 JNIWrapper("IsSameObject"); 997 JNIWrapper("IsSameObject");
831 998 #ifndef USDT2
832 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2); 999 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2);
833 1000 #else /* USDT2 */
1001 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(
1002 env, r1, r2);
1003 #endif /* USDT2 */
834 oop a = JNIHandles::resolve(r1); 1004 oop a = JNIHandles::resolve(r1);
835 oop b = JNIHandles::resolve(r2); 1005 oop b = JNIHandles::resolve(r2);
836 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; 1006 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
837 1007 #ifndef USDT2
838 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret); 1008 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret);
1009 #else /* USDT2 */
1010 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(
1011 ret);
1012 #endif /* USDT2 */
839 return ret; 1013 return ret;
840 JNI_END 1014 JNI_END
841 1015
842 1016
843 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) 1017 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
844 JNIWrapper("NewLocalRef"); 1018 JNIWrapper("NewLocalRef");
845 1019 #ifndef USDT2
846 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref); 1020 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref);
847 1021 #else /* USDT2 */
1022 HOTSPOT_JNI_NEWLOCALREF_ENTRY(
1023 env, ref);
1024 #endif /* USDT2 */
848 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); 1025 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
849 1026 #ifndef USDT2
850 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret); 1027 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret);
1028 #else /* USDT2 */
1029 HOTSPOT_JNI_NEWLOCALREF_RETURN(
1030 ret);
1031 #endif /* USDT2 */
851 return ret; 1032 return ret;
852 JNI_END 1033 JNI_END
853 1034
854 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) 1035 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
855 JNIWrapper("EnsureLocalCapacity"); 1036 JNIWrapper("EnsureLocalCapacity");
856 1037 #ifndef USDT2
857 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity); 1038 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity);
858 1039 #else /* USDT2 */
1040 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(
1041 env, capacity);
1042 #endif /* USDT2 */
859 jint ret; 1043 jint ret;
860 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { 1044 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) {
861 ret = JNI_OK; 1045 ret = JNI_OK;
862 } else { 1046 } else {
863 ret = JNI_ERR; 1047 ret = JNI_ERR;
864 } 1048 }
865 1049 #ifndef USDT2
866 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret); 1050 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret);
1051 #else /* USDT2 */
1052 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(
1053 ret);
1054 #endif /* USDT2 */
867 return ret; 1055 return ret;
868 JNI_END 1056 JNI_END
869 1057
870 // Return the Handle Type 1058 // Return the Handle Type
871 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) 1059 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
872 JNIWrapper("GetObjectRefType"); 1060 JNIWrapper("GetObjectRefType");
873 1061 #ifndef USDT2
874 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj); 1062 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj);
875 1063 #else /* USDT2 */
1064 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(
1065 env, obj);
1066 #endif /* USDT2 */
876 jobjectRefType ret; 1067 jobjectRefType ret;
877 if (JNIHandles::is_local_handle(thread, obj) || 1068 if (JNIHandles::is_local_handle(thread, obj) ||
878 JNIHandles::is_frame_handle(thread, obj)) 1069 JNIHandles::is_frame_handle(thread, obj))
879 ret = JNILocalRefType; 1070 ret = JNILocalRefType;
880 else if (JNIHandles::is_global_handle(obj)) 1071 else if (JNIHandles::is_global_handle(obj))
881 ret = JNIGlobalRefType; 1072 ret = JNIGlobalRefType;
882 else if (JNIHandles::is_weak_global_handle(obj)) 1073 else if (JNIHandles::is_weak_global_handle(obj))
883 ret = JNIWeakGlobalRefType; 1074 ret = JNIWeakGlobalRefType;
884 else 1075 else
885 ret = JNIInvalidRefType; 1076 ret = JNIInvalidRefType;
886 1077 #ifndef USDT2
887 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret); 1078 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
1079 #else /* USDT2 */
1080 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN(
1081 (void *) ret);
1082 #endif /* USDT2 */
888 return ret; 1083 return ret;
889 JNI_END 1084 JNI_END
890 1085
891 1086
892 class JNI_ArgumentPusher : public SignatureIterator { 1087 class JNI_ArgumentPusher : public SignatureIterator {
1162 } 1357 }
1163 } else { 1358 } else {
1164 // interface call 1359 // interface call
1165 KlassHandle h_holder(THREAD, holder); 1360 KlassHandle h_holder(THREAD, holder);
1166 1361
1167 if (call_type == JNI_VIRTUAL) { 1362 int itbl_index = m->itable_index();
1168 int itbl_index = m->itable_index(); 1363 Klass* k = h_recv->klass();
1169 Klass* k = h_recv->klass(); 1364 selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
1170 selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
1171 } else {
1172 selected_method = m;
1173 }
1174 } 1365 }
1175 } 1366 }
1176 1367
1177 methodHandle method(THREAD, selected_method); 1368 methodHandle method(THREAD, selected_method);
1178 1369
1201 } 1392 }
1202 1393
1203 1394
1204 static instanceOop alloc_object(jclass clazz, TRAPS) { 1395 static instanceOop alloc_object(jclass clazz, TRAPS) {
1205 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 1396 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1206 if (k == NULL) {
1207 ResourceMark rm(THREAD);
1208 THROW_(vmSymbols::java_lang_InstantiationException(), NULL);
1209 }
1210 k()->check_valid_for_instantiation(false, CHECK_NULL); 1397 k()->check_valid_for_instantiation(false, CHECK_NULL);
1211 InstanceKlass::cast(k())->initialize(CHECK_NULL); 1398 InstanceKlass::cast(k())->initialize(CHECK_NULL);
1212 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD); 1399 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD);
1213 return ih; 1400 return ih;
1214 } 1401 }
1215 1402
1403 #ifndef USDT2
1404 DT_RETURN_MARK_DECL(AllocObject, jobject);
1405 #else /* USDT2 */
1216 DT_RETURN_MARK_DECL(AllocObject, jobject 1406 DT_RETURN_MARK_DECL(AllocObject, jobject
1217 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref)); 1407 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1408 #endif /* USDT2 */
1218 1409
1219 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) 1410 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1220 JNIWrapper("AllocObject"); 1411 JNIWrapper("AllocObject");
1221 1412
1222 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz); 1413 #ifndef USDT2
1223 1414 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
1415 #else /* USDT2 */
1416 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(
1417 env, clazz);
1418 #endif /* USDT2 */
1224 jobject ret = NULL; 1419 jobject ret = NULL;
1225 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); 1420 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1226 1421
1227 instanceOop i = alloc_object(clazz, CHECK_NULL); 1422 instanceOop i = alloc_object(clazz, CHECK_NULL);
1228 ret = JNIHandles::make_local(env, i); 1423 ret = JNIHandles::make_local(env, i);
1229 return ret; 1424 return ret;
1230 JNI_END 1425 JNI_END
1231 1426
1427 #ifndef USDT2
1428 DT_RETURN_MARK_DECL(NewObjectA, jobject);
1429 #else /* USDT2 */
1232 DT_RETURN_MARK_DECL(NewObjectA, jobject 1430 DT_RETURN_MARK_DECL(NewObjectA, jobject
1233 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref)); 1431 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1432 #endif /* USDT2 */
1234 1433
1235 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) 1434 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
1236 JNIWrapper("NewObjectA"); 1435 JNIWrapper("NewObjectA");
1237 1436 #ifndef USDT2
1238 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID); 1437 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID);
1239 1438 #else /* USDT2 */
1439 HOTSPOT_JNI_NEWOBJECTA_ENTRY(
1440 env, clazz, (uintptr_t) methodID);
1441 #endif /* USDT2 */
1240 jobject obj = NULL; 1442 jobject obj = NULL;
1241 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); 1443 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
1242 1444
1243 instanceOop i = alloc_object(clazz, CHECK_NULL); 1445 instanceOop i = alloc_object(clazz, CHECK_NULL);
1244 obj = JNIHandles::make_local(env, i); 1446 obj = JNIHandles::make_local(env, i);
1246 JNI_ArgumentPusherArray ap(methodID, args); 1448 JNI_ArgumentPusherArray ap(methodID, args);
1247 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1449 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1248 return obj; 1450 return obj;
1249 JNI_END 1451 JNI_END
1250 1452
1251 1453 #ifndef USDT2
1454 DT_RETURN_MARK_DECL(NewObjectV, jobject);
1455 #else /* USDT2 */
1252 DT_RETURN_MARK_DECL(NewObjectV, jobject 1456 DT_RETURN_MARK_DECL(NewObjectV, jobject
1253 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref)); 1457 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1458 #endif /* USDT2 */
1254 1459
1255 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) 1460 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
1256 JNIWrapper("NewObjectV"); 1461 JNIWrapper("NewObjectV");
1257 1462 #ifndef USDT2
1258 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID); 1463 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID);
1259 1464 #else /* USDT2 */
1465 HOTSPOT_JNI_NEWOBJECTV_ENTRY(
1466 env, clazz, (uintptr_t) methodID);
1467 #endif /* USDT2 */
1260 jobject obj = NULL; 1468 jobject obj = NULL;
1261 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); 1469 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
1262 1470
1263 instanceOop i = alloc_object(clazz, CHECK_NULL); 1471 instanceOop i = alloc_object(clazz, CHECK_NULL);
1264 obj = JNIHandles::make_local(env, i); 1472 obj = JNIHandles::make_local(env, i);
1266 JNI_ArgumentPusherVaArg ap(methodID, args); 1474 JNI_ArgumentPusherVaArg ap(methodID, args);
1267 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1475 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1268 return obj; 1476 return obj;
1269 JNI_END 1477 JNI_END
1270 1478
1271 1479 #ifndef USDT2
1480 DT_RETURN_MARK_DECL(NewObject, jobject);
1481 #else /* USDT2 */
1272 DT_RETURN_MARK_DECL(NewObject, jobject 1482 DT_RETURN_MARK_DECL(NewObject, jobject
1273 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref)); 1483 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1484 #endif /* USDT2 */
1274 1485
1275 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) 1486 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1276 JNIWrapper("NewObject"); 1487 JNIWrapper("NewObject");
1277 1488 #ifndef USDT2
1278 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID); 1489 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID);
1279 1490 #else /* USDT2 */
1491 HOTSPOT_JNI_NEWOBJECT_ENTRY(
1492 env, clazz, (uintptr_t) methodID);
1493 #endif /* USDT2 */
1280 jobject obj = NULL; 1494 jobject obj = NULL;
1281 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); 1495 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1282 1496
1283 instanceOop i = alloc_object(clazz, CHECK_NULL); 1497 instanceOop i = alloc_object(clazz, CHECK_NULL);
1284 obj = JNIHandles::make_local(env, i); 1498 obj = JNIHandles::make_local(env, i);
1292 JNI_END 1506 JNI_END
1293 1507
1294 1508
1295 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) 1509 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1296 JNIWrapper("GetObjectClass"); 1510 JNIWrapper("GetObjectClass");
1297 1511 #ifndef USDT2
1298 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj); 1512 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
1299 1513 #else /* USDT2 */
1514 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(
1515 env, obj);
1516 #endif /* USDT2 */
1300 Klass* k = JNIHandles::resolve_non_null(obj)->klass(); 1517 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1301 jclass ret = 1518 jclass ret =
1302 (jclass) JNIHandles::make_local(env, k->java_mirror()); 1519 (jclass) JNIHandles::make_local(env, k->java_mirror());
1303 1520 #ifndef USDT2
1304 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret); 1521 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
1522 #else /* USDT2 */
1523 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(
1524 ret);
1525 #endif /* USDT2 */
1305 return ret; 1526 return ret;
1306 JNI_END 1527 JNI_END
1307 1528
1308 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) 1529 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1309 JNIWrapper("IsInstanceOf"); 1530 JNIWrapper("IsInstanceOf");
1310 1531 #ifndef USDT2
1311 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz); 1532 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz);
1312 1533 #else /* USDT2 */
1534 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(
1535 env, obj, clazz);
1536 #endif /* USDT2 */
1313 jboolean ret = JNI_TRUE; 1537 jboolean ret = JNI_TRUE;
1314 if (obj != NULL) { 1538 if (obj != NULL) {
1315 ret = JNI_FALSE; 1539 ret = JNI_FALSE;
1316 Klass* k = java_lang_Class::as_Klass( 1540 Klass* k = java_lang_Class::as_Klass(
1317 JNIHandles::resolve_non_null(clazz)); 1541 JNIHandles::resolve_non_null(clazz));
1318 if (k != NULL) { 1542 if (k != NULL) {
1319 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; 1543 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
1320 } 1544 }
1321 } 1545 }
1322 1546 #ifndef USDT2
1323 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret); 1547 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
1548 #else /* USDT2 */
1549 HOTSPOT_JNI_ISINSTANCEOF_RETURN(
1550 ret);
1551 #endif /* USDT2 */
1324 return ret; 1552 return ret;
1325 JNI_END 1553 JNI_END
1326 1554
1327 1555
1328 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, 1556 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
1378 1606
1379 1607
1380 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, 1608 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
1381 const char *name, const char *sig)) 1609 const char *name, const char *sig))
1382 JNIWrapper("GetMethodID"); 1610 JNIWrapper("GetMethodID");
1383 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig); 1611 #ifndef USDT2
1612 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig);
1613 #else /* USDT2 */
1614 HOTSPOT_JNI_GETMETHODID_ENTRY(
1615 env, clazz, (char *) name, (char *) sig);
1616 #endif /* USDT2 */
1384 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); 1617 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1385 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret); 1618 #ifndef USDT2
1619 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret);
1620 #else /* USDT2 */
1621 HOTSPOT_JNI_GETMETHODID_RETURN(
1622 (uintptr_t) ret);
1623 #endif /* USDT2 */
1386 return ret; 1624 return ret;
1387 JNI_END 1625 JNI_END
1388 1626
1389 1627
1390 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, 1628 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
1391 const char *name, const char *sig)) 1629 const char *name, const char *sig))
1392 JNIWrapper("GetStaticMethodID"); 1630 JNIWrapper("GetStaticMethodID");
1393 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig); 1631 #ifndef USDT2
1632 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig);
1633 #else /* USDT2 */
1634 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(
1635 env, (char *) clazz, (char *) name, (char *)sig);
1636 #endif /* USDT2 */
1394 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); 1637 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
1395 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret); 1638 #ifndef USDT2
1639 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret);
1640 #else /* USDT2 */
1641 HOTSPOT_JNI_GETSTATICMETHODID_RETURN(
1642 (uintptr_t) ret);
1643 #endif /* USDT2 */
1396 return ret; 1644 return ret;
1397 JNI_END 1645 JNI_END
1398 1646
1399 1647
1400 1648
1401 // 1649 //
1402 // Calling Methods 1650 // Calling Methods
1403 // 1651 //
1404 1652
1653 #ifndef USDT2
1654 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \
1655 \
1656 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\
1657 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\
1658 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\
1659 \
1660 JNI_ENTRY(ResultType, \
1661 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
1662 JNIWrapper("Call" XSTR(Result) "Method"); \
1663 \
1664 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \
1665 ResultType ret = 0;\
1666 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
1667 (const ResultType&)ret);\
1668 \
1669 va_list args; \
1670 va_start(args, methodID); \
1671 JavaValue jvalue(Tag); \
1672 JNI_ArgumentPusherVaArg ap(methodID, args); \
1673 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1674 va_end(args); \
1675 ret = jvalue.get_##ResultType(); \
1676 return ret;\
1677 JNI_END \
1678 \
1679 \
1680 JNI_ENTRY(ResultType, \
1681 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
1682 JNIWrapper("Call" XSTR(Result) "MethodV"); \
1683 \
1684 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID); \
1685 ResultType ret = 0;\
1686 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
1687 (const ResultType&)ret);\
1688 \
1689 JavaValue jvalue(Tag); \
1690 JNI_ArgumentPusherVaArg ap(methodID, args); \
1691 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1692 ret = jvalue.get_##ResultType(); \
1693 return ret;\
1694 JNI_END \
1695 \
1696 \
1697 JNI_ENTRY(ResultType, \
1698 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
1699 JNIWrapper("Call" XSTR(Result) "MethodA"); \
1700 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID); \
1701 ResultType ret = 0;\
1702 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
1703 (const ResultType&)ret);\
1704 \
1705 JavaValue jvalue(Tag); \
1706 JNI_ArgumentPusherArray ap(methodID, args); \
1707 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1708 ret = jvalue.get_##ResultType(); \
1709 return ret;\
1710 JNI_END
1711
1712 // the runtime type of subword integral basic types is integer
1713 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN)
1714 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE)
1715 DEFINE_CALLMETHOD(jchar, Char, T_CHAR)
1716 DEFINE_CALLMETHOD(jshort, Short, T_SHORT)
1717
1718 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT)
1719 DEFINE_CALLMETHOD(jint, Int, T_INT)
1720 DEFINE_CALLMETHOD(jlong, Long, T_LONG)
1721 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT)
1722 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE)
1723
1724 DT_VOID_RETURN_MARK_DECL(CallVoidMethod);
1725 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV);
1726 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA);
1727
1728 #else /* USDT2 */
1405 1729
1406 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \ 1730 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \
1407 , EntryProbe, ReturnProbe) \ 1731 , EntryProbe, ReturnProbe) \
1408 \ 1732 \
1409 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \ 1733 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
1481 return ret;\ 1805 return ret;\
1482 JNI_END 1806 JNI_END
1483 1807
1484 // the runtime type of subword integral basic types is integer 1808 // the runtime type of subword integral basic types is integer
1485 DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN 1809 DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
1486 , HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1810 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1487 HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref)) 1811 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
1488 DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE 1812 DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE
1489 , HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1813 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1490 HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref)) 1814 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
1491 DEFINE_CALLMETHODV(jchar, Char, T_CHAR 1815 DEFINE_CALLMETHODV(jchar, Char, T_CHAR
1492 , HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1816 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1493 HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref)) 1817 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
1494 DEFINE_CALLMETHODV(jshort, Short, T_SHORT 1818 DEFINE_CALLMETHODV(jshort, Short, T_SHORT
1495 , HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1819 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1496 HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref)) 1820 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
1497 1821
1498 DEFINE_CALLMETHODV(jobject, Object, T_OBJECT 1822 DEFINE_CALLMETHODV(jobject, Object, T_OBJECT
1499 , HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1823 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1500 HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref)) 1824 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
1501 DEFINE_CALLMETHODV(jint, Int, T_INT, 1825 DEFINE_CALLMETHODV(jint, Int, T_INT,
1502 HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1826 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1503 HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref)) 1827 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
1504 DEFINE_CALLMETHODV(jlong, Long, T_LONG 1828 DEFINE_CALLMETHODV(jlong, Long, T_LONG
1505 , HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1829 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1506 HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref)) 1830 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
1507 // Float and double probes don't return value because dtrace doesn't currently support it 1831 // Float and double probes don't return value because dtrace doesn't currently support it
1508 DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT 1832 DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT
1509 , HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1833 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1510 HOTSPOT_JNI_CALLFLOATMETHODV_RETURN()) 1834 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
1511 DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE 1835 DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE
1512 , HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID), 1836 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1513 HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN()) 1837 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
1514 1838
1515 #define DEFINE_CALLMETHODA(ResultType, Result, Tag \ 1839 #define DEFINE_CALLMETHODA(ResultType, Result, Tag \
1516 , EntryProbe, ReturnProbe) \ 1840 , EntryProbe, ReturnProbe) \
1517 \ 1841 \
1518 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \ 1842 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \
1533 return ret;\ 1857 return ret;\
1534 JNI_END 1858 JNI_END
1535 1859
1536 // the runtime type of subword integral basic types is integer 1860 // the runtime type of subword integral basic types is integer
1537 DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN 1861 DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
1538 , HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1862 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1539 HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref)) 1863 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
1540 DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE 1864 DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE
1541 , HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1865 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1542 HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref)) 1866 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
1543 DEFINE_CALLMETHODA(jchar, Char, T_CHAR 1867 DEFINE_CALLMETHODA(jchar, Char, T_CHAR
1544 , HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1868 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1545 HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref)) 1869 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
1546 DEFINE_CALLMETHODA(jshort, Short, T_SHORT 1870 DEFINE_CALLMETHODA(jshort, Short, T_SHORT
1547 , HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1871 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1548 HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref)) 1872 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
1549 1873
1550 DEFINE_CALLMETHODA(jobject, Object, T_OBJECT 1874 DEFINE_CALLMETHODA(jobject, Object, T_OBJECT
1551 , HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1875 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1552 HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref)) 1876 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
1553 DEFINE_CALLMETHODA(jint, Int, T_INT, 1877 DEFINE_CALLMETHODA(jint, Int, T_INT,
1554 HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1878 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1555 HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref)) 1879 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
1556 DEFINE_CALLMETHODA(jlong, Long, T_LONG 1880 DEFINE_CALLMETHODA(jlong, Long, T_LONG
1557 , HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1881 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1558 HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref)) 1882 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
1559 // Float and double probes don't return value because dtrace doesn't currently support it 1883 // Float and double probes don't return value because dtrace doesn't currently support it
1560 DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT 1884 DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT
1561 , HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1885 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1562 HOTSPOT_JNI_CALLFLOATMETHODA_RETURN()) 1886 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
1563 DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE 1887 DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE
1564 , HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID), 1888 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1565 HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN()) 1889 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
1566 1890
1567 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN()); 1891 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
1568 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN()); 1892 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
1569 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN()); 1893 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
1570 1894
1895 #endif /* USDT2 */
1571 1896
1572 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) 1897 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
1573 JNIWrapper("CallVoidMethod"); 1898 JNIWrapper("CallVoidMethod");
1574 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID); 1899 #ifndef USDT2
1900 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID);
1901 #else /* USDT2 */
1902 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(
1903 env, obj, (uintptr_t) methodID);
1904 #endif /* USDT2 */
1575 DT_VOID_RETURN_MARK(CallVoidMethod); 1905 DT_VOID_RETURN_MARK(CallVoidMethod);
1576 1906
1577 va_list args; 1907 va_list args;
1578 va_start(args, methodID); 1908 va_start(args, methodID);
1579 JavaValue jvalue(T_VOID); 1909 JavaValue jvalue(T_VOID);
1583 JNI_END 1913 JNI_END
1584 1914
1585 1915
1586 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) 1916 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
1587 JNIWrapper("CallVoidMethodV"); 1917 JNIWrapper("CallVoidMethodV");
1588 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID); 1918 #ifndef USDT2
1919 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
1920 #else /* USDT2 */
1921 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(
1922 env, obj, (uintptr_t) methodID);
1923 #endif /* USDT2 */
1589 DT_VOID_RETURN_MARK(CallVoidMethodV); 1924 DT_VOID_RETURN_MARK(CallVoidMethodV);
1590 1925
1591 JavaValue jvalue(T_VOID); 1926 JavaValue jvalue(T_VOID);
1592 JNI_ArgumentPusherVaArg ap(methodID, args); 1927 JNI_ArgumentPusherVaArg ap(methodID, args);
1593 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1928 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1594 JNI_END 1929 JNI_END
1595 1930
1596 1931
1597 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) 1932 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
1598 JNIWrapper("CallVoidMethodA"); 1933 JNIWrapper("CallVoidMethodA");
1599 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID); 1934 #ifndef USDT2
1935 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
1936 #else /* USDT2 */
1937 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(
1938 env, obj, (uintptr_t) methodID);
1939 #endif /* USDT2 */
1600 DT_VOID_RETURN_MARK(CallVoidMethodA); 1940 DT_VOID_RETURN_MARK(CallVoidMethodA);
1601 1941
1602 JavaValue jvalue(T_VOID); 1942 JavaValue jvalue(T_VOID);
1603 JNI_ArgumentPusherArray ap(methodID, args); 1943 JNI_ArgumentPusherArray ap(methodID, args);
1604 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1944 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1605 JNI_END 1945 JNI_END
1606 1946
1607 1947
1948 #ifndef USDT2
1949 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \
1950 \
1951 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\
1952 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\
1953 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\
1954 \
1955 JNI_ENTRY(ResultType, \
1956 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
1957 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
1958 \
1959 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\
1960 ResultType ret;\
1961 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
1962 (const ResultType&)ret);\
1963 \
1964 va_list args; \
1965 va_start(args, methodID); \
1966 JavaValue jvalue(Tag); \
1967 JNI_ArgumentPusherVaArg ap(methodID, args); \
1968 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1969 va_end(args); \
1970 ret = jvalue.get_##ResultType(); \
1971 return ret;\
1972 JNI_END \
1973 \
1974 JNI_ENTRY(ResultType, \
1975 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
1976 JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \
1977 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\
1978 ResultType ret;\
1979 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
1980 (const ResultType&)ret);\
1981 \
1982 JavaValue jvalue(Tag); \
1983 JNI_ArgumentPusherVaArg ap(methodID, args); \
1984 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1985 ret = jvalue.get_##ResultType(); \
1986 return ret;\
1987 JNI_END \
1988 \
1989 JNI_ENTRY(ResultType, \
1990 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
1991 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
1992 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\
1993 ResultType ret;\
1994 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
1995 (const ResultType&)ret);\
1996 \
1997 JavaValue jvalue(Tag); \
1998 JNI_ArgumentPusherArray ap(methodID, args); \
1999 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
2000 ret = jvalue.get_##ResultType(); \
2001 return ret;\
2002 JNI_END
2003
2004 // the runtime type of subword integral basic types is integer
2005 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN)
2006 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE)
2007 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR)
2008 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT)
2009
2010 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT)
2011 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT)
2012 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG)
2013 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT)
2014 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE)
2015
2016
2017 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod);
2018 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV);
2019 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA);
2020
2021 #else /* USDT2 */
1608 2022
1609 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \ 2023 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
1610 , EntryProbe, ReturnProbe) \ 2024 , EntryProbe, ReturnProbe) \
1611 \ 2025 \
1612 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \ 2026 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
1772 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()); 2186 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
1773 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV 2187 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
1774 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()); 2188 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
1775 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA 2189 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
1776 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()); 2190 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
2191 #endif /* USDT2 */
1777 2192
1778 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) 2193 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
1779 JNIWrapper("CallNonvirtualVoidMethod"); 2194 JNIWrapper("CallNonvirtualVoidMethod");
1780 2195
1781 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID); 2196 #ifndef USDT2
2197 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
2198 env, obj, cls, methodID);
2199 #else /* USDT2 */
2200 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(
2201 env, obj, cls, (uintptr_t) methodID);
2202 #endif /* USDT2 */
1782 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); 2203 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
1783 2204
1784 va_list args; 2205 va_list args;
1785 va_start(args, methodID); 2206 va_start(args, methodID);
1786 JavaValue jvalue(T_VOID); 2207 JavaValue jvalue(T_VOID);
1791 2212
1792 2213
1793 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) 2214 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
1794 JNIWrapper("CallNonvirtualVoidMethodV"); 2215 JNIWrapper("CallNonvirtualVoidMethodV");
1795 2216
2217 #ifndef USDT2
2218 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry,
2219 env, obj, cls, methodID);
2220 #else /* USDT2 */
1796 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY( 2221 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
1797 env, obj, cls, (uintptr_t) methodID); 2222 env, obj, cls, (uintptr_t) methodID);
2223 #endif /* USDT2 */
1798 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); 2224 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
1799 2225
1800 JavaValue jvalue(T_VOID); 2226 JavaValue jvalue(T_VOID);
1801 JNI_ArgumentPusherVaArg ap(methodID, args); 2227 JNI_ArgumentPusherVaArg ap(methodID, args);
1802 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 2228 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
1803 JNI_END 2229 JNI_END
1804 2230
1805 2231
1806 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) 2232 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
1807 JNIWrapper("CallNonvirtualVoidMethodA"); 2233 JNIWrapper("CallNonvirtualVoidMethodA");
2234 #ifndef USDT2
2235 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry,
2236 env, obj, cls, methodID);
2237 #else /* USDT2 */
1808 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY( 2238 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
1809 env, obj, cls, (uintptr_t) methodID); 2239 env, obj, cls, (uintptr_t) methodID);
2240 #endif /* USDT2 */
1810 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); 2241 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
1811 JavaValue jvalue(T_VOID); 2242 JavaValue jvalue(T_VOID);
1812 JNI_ArgumentPusherArray ap(methodID, args); 2243 JNI_ArgumentPusherArray ap(methodID, args);
1813 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 2244 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
1814 JNI_END 2245 JNI_END
1815 2246
1816 2247
2248 #ifndef USDT2
2249 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \
2250 \
2251 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\
2252 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\
2253 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\
2254 \
2255 JNI_ENTRY(ResultType, \
2256 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
2257 JNIWrapper("CallStatic" XSTR(Result) "Method"); \
2258 \
2259 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\
2260 ResultType ret = 0;\
2261 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
2262 (const ResultType&)ret);\
2263 \
2264 va_list args; \
2265 va_start(args, methodID); \
2266 JavaValue jvalue(Tag); \
2267 JNI_ArgumentPusherVaArg ap(methodID, args); \
2268 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2269 va_end(args); \
2270 ret = jvalue.get_##ResultType(); \
2271 return ret;\
2272 JNI_END \
2273 \
2274 JNI_ENTRY(ResultType, \
2275 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
2276 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
2277 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\
2278 ResultType ret = 0;\
2279 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
2280 (const ResultType&)ret);\
2281 \
2282 JavaValue jvalue(Tag); \
2283 JNI_ArgumentPusherVaArg ap(methodID, args); \
2284 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2285 ret = jvalue.get_##ResultType(); \
2286 return ret;\
2287 JNI_END \
2288 \
2289 JNI_ENTRY(ResultType, \
2290 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
2291 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
2292 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\
2293 ResultType ret = 0;\
2294 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
2295 (const ResultType&)ret);\
2296 \
2297 JavaValue jvalue(Tag); \
2298 JNI_ArgumentPusherArray ap(methodID, args); \
2299 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2300 ret = jvalue.get_##ResultType(); \
2301 return ret;\
2302 JNI_END
2303
2304 // the runtime type of subword integral basic types is integer
2305 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN)
2306 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE)
2307 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR)
2308 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT)
2309
2310 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT)
2311 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT)
2312 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG)
2313 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT)
2314 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE)
2315
2316
2317 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod);
2318 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV);
2319 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA);
2320
2321 #else /* USDT2 */
1817 2322
1818 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \ 2323 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
1819 , EntryProbe, ResultProbe) \ 2324 , EntryProbe, ResultProbe) \
1820 \ 2325 \
1821 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \ 2326 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
1985 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()); 2490 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
1986 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV 2491 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
1987 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()); 2492 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
1988 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA 2493 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
1989 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()); 2494 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
2495 #endif /* USDT2 */
1990 2496
1991 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) 2497 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
1992 JNIWrapper("CallStaticVoidMethod"); 2498 JNIWrapper("CallStaticVoidMethod");
1993 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID); 2499 #ifndef USDT2
2500 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID);
2501 #else /* USDT2 */
2502 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(
2503 env, cls, (uintptr_t) methodID);
2504 #endif /* USDT2 */
1994 DT_VOID_RETURN_MARK(CallStaticVoidMethod); 2505 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
1995 2506
1996 va_list args; 2507 va_list args;
1997 va_start(args, methodID); 2508 va_start(args, methodID);
1998 JavaValue jvalue(T_VOID); 2509 JavaValue jvalue(T_VOID);
2002 JNI_END 2513 JNI_END
2003 2514
2004 2515
2005 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) 2516 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
2006 JNIWrapper("CallStaticVoidMethodV"); 2517 JNIWrapper("CallStaticVoidMethodV");
2007 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID); 2518 #ifndef USDT2
2519 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
2520 #else /* USDT2 */
2521 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(
2522 env, cls, (uintptr_t) methodID);
2523 #endif /* USDT2 */
2008 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); 2524 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
2009 2525
2010 JavaValue jvalue(T_VOID); 2526 JavaValue jvalue(T_VOID);
2011 JNI_ArgumentPusherVaArg ap(methodID, args); 2527 JNI_ArgumentPusherVaArg ap(methodID, args);
2012 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 2528 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2013 JNI_END 2529 JNI_END
2014 2530
2015 2531
2016 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) 2532 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
2017 JNIWrapper("CallStaticVoidMethodA"); 2533 JNIWrapper("CallStaticVoidMethodA");
2018 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID); 2534 #ifndef USDT2
2535 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
2536 #else /* USDT2 */
2537 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(
2538 env, cls, (uintptr_t) methodID);
2539 #endif /* USDT2 */
2019 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); 2540 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
2020 2541
2021 JavaValue jvalue(T_VOID); 2542 JavaValue jvalue(T_VOID);
2022 JNI_ArgumentPusherArray ap(methodID, args); 2543 JNI_ArgumentPusherArray ap(methodID, args);
2023 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 2544 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2027 // 2548 //
2028 // Accessing Fields 2549 // Accessing Fields
2029 // 2550 //
2030 2551
2031 2552
2553 #ifndef USDT2
2554 DT_RETURN_MARK_DECL(GetFieldID, jfieldID);
2555 #else /* USDT2 */
2032 DT_RETURN_MARK_DECL(GetFieldID, jfieldID 2556 DT_RETURN_MARK_DECL(GetFieldID, jfieldID
2033 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref)); 2557 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
2558 #endif /* USDT2 */
2034 2559
2035 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz, 2560 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
2036 const char *name, const char *sig)) 2561 const char *name, const char *sig))
2037 JNIWrapper("GetFieldID"); 2562 JNIWrapper("GetFieldID");
2038 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig); 2563 #ifndef USDT2
2564 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig);
2565 #else /* USDT2 */
2566 HOTSPOT_JNI_GETFIELDID_ENTRY(
2567 env, clazz, (char *) name, (char *) sig);
2568 #endif /* USDT2 */
2039 jfieldID ret = 0; 2569 jfieldID ret = 0;
2040 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret); 2570 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
2041 2571
2042 // The class should have been loaded (we have an instance of the class 2572 // The class should have been loaded (we have an instance of the class
2043 // passed in) so the field and signature should already be in the symbol 2573 // passed in) so the field and signature should already be in the symbol
2065 JNI_END 2595 JNI_END
2066 2596
2067 2597
2068 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)) 2598 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
2069 JNIWrapper("GetObjectField"); 2599 JNIWrapper("GetObjectField");
2070 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID); 2600 #ifndef USDT2
2601 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID);
2602 #else /* USDT2 */
2603 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(
2604 env, obj, (uintptr_t) fieldID);
2605 #endif /* USDT2 */
2071 oop o = JNIHandles::resolve_non_null(obj); 2606 oop o = JNIHandles::resolve_non_null(obj);
2072 Klass* k = o->klass(); 2607 Klass* k = o->klass();
2073 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 2608 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2074 // Keep JVMTI addition small and only check enabled flag here. 2609 // Keep JVMTI addition small and only check enabled flag here.
2075 // jni_GetField_probe() assumes that is okay to create handles. 2610 // jni_GetField_probe() assumes that is okay to create handles.
2095 oop referent = JNIHandles::resolve(ret); 2630 oop referent = JNIHandles::resolve(ret);
2096 G1SATBCardTableModRefBS::enqueue(referent); 2631 G1SATBCardTableModRefBS::enqueue(referent);
2097 } 2632 }
2098 } 2633 }
2099 #endif // INCLUDE_ALL_GCS 2634 #endif // INCLUDE_ALL_GCS
2100 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret); 2635 #ifndef USDT2
2636 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
2637 #else /* USDT2 */
2638 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(
2639 ret);
2640 #endif /* USDT2 */
2101 return ret; 2641 return ret;
2102 JNI_END 2642 JNI_END
2103 2643
2104 2644
2645 #ifndef USDT2
2646 #define DEFINE_GETFIELD(Return,Fieldname,Result) \
2647 \
2648 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\
2649 \
2650 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
2651 JNIWrapper("Get" XSTR(Result) "Field"); \
2652 \
2653 DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\
2654 Return ret = 0;\
2655 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
2656 \
2657 oop o = JNIHandles::resolve_non_null(obj); \
2658 Klass* k = o->klass(); \
2659 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2660 /* Keep JVMTI addition small and only check enabled flag here. */ \
2661 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
2662 /* and creates a ResetNoHandleMark. */ \
2663 if (JvmtiExport::should_post_field_access()) { \
2664 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
2665 } \
2666 ret = o->Fieldname##_field(offset); \
2667 return ret; \
2668 JNI_END
2669
2670 DEFINE_GETFIELD(jboolean, bool, Boolean)
2671 DEFINE_GETFIELD(jbyte, byte, Byte)
2672 DEFINE_GETFIELD(jchar, char, Char)
2673 DEFINE_GETFIELD(jshort, short, Short)
2674 DEFINE_GETFIELD(jint, int, Int)
2675 DEFINE_GETFIELD(jlong, long, Long)
2676 DEFINE_GETFIELD(jfloat, float, Float)
2677 DEFINE_GETFIELD(jdouble, double, Double)
2678
2679 #else /* USDT2 */
2105 2680
2106 #define DEFINE_GETFIELD(Return,Fieldname,Result \ 2681 #define DEFINE_GETFIELD(Return,Fieldname,Result \
2107 , EntryProbe, ReturnProbe) \ 2682 , EntryProbe, ReturnProbe) \
2108 \ 2683 \
2109 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \ 2684 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
2152 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2727 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2153 HOTSPOT_JNI_GETFLOATFIELD_RETURN()) 2728 HOTSPOT_JNI_GETFLOATFIELD_RETURN())
2154 DEFINE_GETFIELD(jdouble, double, Double 2729 DEFINE_GETFIELD(jdouble, double, Double
2155 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2730 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2156 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN()) 2731 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
2732 #endif /* USDT2 */
2157 2733
2158 address jni_GetBooleanField_addr() { 2734 address jni_GetBooleanField_addr() {
2159 return (address)jni_GetBooleanField; 2735 return (address)jni_GetBooleanField;
2160 } 2736 }
2161 address jni_GetByteField_addr() { 2737 address jni_GetByteField_addr() {
2180 return (address)jni_GetDoubleField; 2756 return (address)jni_GetDoubleField;
2181 } 2757 }
2182 2758
2183 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)) 2759 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
2184 JNIWrapper("SetObjectField"); 2760 JNIWrapper("SetObjectField");
2185 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value); 2761 #ifndef USDT2
2762 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value);
2763 #else /* USDT2 */
2764 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(
2765 env, obj, (uintptr_t) fieldID, value);
2766 #endif /* USDT2 */
2186 oop o = JNIHandles::resolve_non_null(obj); 2767 oop o = JNIHandles::resolve_non_null(obj);
2187 Klass* k = o->klass(); 2768 Klass* k = o->klass();
2188 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 2769 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2189 // Keep JVMTI addition small and only check enabled flag here. 2770 // Keep JVMTI addition small and only check enabled flag here.
2190 // jni_SetField_probe_nh() assumes that is not okay to create handles 2771 // jni_SetField_probe_nh() assumes that is not okay to create handles
2193 jvalue field_value; 2774 jvalue field_value;
2194 field_value.l = value; 2775 field_value.l = value;
2195 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); 2776 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
2196 } 2777 }
2197 o->obj_field_put(offset, JNIHandles::resolve(value)); 2778 o->obj_field_put(offset, JNIHandles::resolve(value));
2198 HOTSPOT_JNI_SETOBJECTFIELD_RETURN(); 2779 #ifndef USDT2
2199 JNI_END 2780 DTRACE_PROBE(hotspot_jni, SetObjectField__return);
2200 2781 #else /* USDT2 */
2782 HOTSPOT_JNI_SETOBJECTFIELD_RETURN(
2783 );
2784 #endif /* USDT2 */
2785 JNI_END
2786
2787 #ifndef USDT2
2788 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
2789 \
2790 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
2791 JNIWrapper("Set" XSTR(Result) "Field"); \
2792 \
2793 FP_SELECT_##Result( \
2794 DTRACE_PROBE4(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID, value), \
2795 DTRACE_PROBE3(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID)); \
2796 \
2797 oop o = JNIHandles::resolve_non_null(obj); \
2798 Klass* k = o->klass(); \
2799 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2800 /* Keep JVMTI addition small and only check enabled flag here. */ \
2801 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
2802 /* and creates a ResetNoHandleMark. */ \
2803 if (JvmtiExport::should_post_field_modification()) { \
2804 jvalue field_value; \
2805 field_value.unionType = value; \
2806 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
2807 } \
2808 o->Fieldname##_field_put(offset, value); \
2809 DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\
2810 JNI_END
2811
2812 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z)
2813 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b)
2814 DEFINE_SETFIELD(jchar, char, Char, 'C', c)
2815 DEFINE_SETFIELD(jshort, short, Short, 'S', s)
2816 DEFINE_SETFIELD(jint, int, Int, 'I', i)
2817 DEFINE_SETFIELD(jlong, long, Long, 'J', j)
2818 DEFINE_SETFIELD(jfloat, float, Float, 'F', f)
2819 DEFINE_SETFIELD(jdouble, double, Double, 'D', d)
2820
2821 #else /* USDT2 */
2201 2822
2202 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \ 2823 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
2203 , EntryProbe, ReturnProbe) \ 2824 , EntryProbe, ReturnProbe) \
2204 \ 2825 \
2205 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ 2826 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
2245 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2866 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2246 HOTSPOT_JNI_SETFLOATFIELD_RETURN()) 2867 HOTSPOT_JNI_SETFLOATFIELD_RETURN())
2247 DEFINE_SETFIELD(jdouble, double, Double, 'D', d 2868 DEFINE_SETFIELD(jdouble, double, Double, 'D', d
2248 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), 2869 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2249 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()) 2870 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
2250 2871 #endif /* USDT2 */
2872
2873 #ifndef USDT2
2874 DT_RETURN_MARK_DECL(ToReflectedField, jobject);
2875 #else /* USDT2 */
2251 DT_RETURN_MARK_DECL(ToReflectedField, jobject 2876 DT_RETURN_MARK_DECL(ToReflectedField, jobject
2252 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref)); 2877 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
2878 #endif /* USDT2 */
2253 2879
2254 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) 2880 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
2255 JNIWrapper("ToReflectedField"); 2881 JNIWrapper("ToReflectedField");
2256 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic); 2882 #ifndef USDT2
2883 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
2884 env, cls, fieldID, isStatic);
2885 #else /* USDT2 */
2886 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(
2887 env, cls, (uintptr_t) fieldID, isStatic);
2888 #endif /* USDT2 */
2257 jobject ret = NULL; 2889 jobject ret = NULL;
2258 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); 2890 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
2259 2891
2260 fieldDescriptor fd; 2892 fieldDescriptor fd;
2261 bool found = false; 2893 bool found = false;
2281 2913
2282 2914
2283 // 2915 //
2284 // Accessing Static Fields 2916 // Accessing Static Fields
2285 // 2917 //
2918 #ifndef USDT2
2919 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID);
2920 #else /* USDT2 */
2286 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID 2921 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2287 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref)); 2922 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2923 #endif /* USDT2 */
2288 2924
2289 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, 2925 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2290 const char *name, const char *sig)) 2926 const char *name, const char *sig))
2291 JNIWrapper("GetStaticFieldID"); 2927 JNIWrapper("GetStaticFieldID");
2292 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig); 2928 #ifndef USDT2
2929 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig);
2930 #else /* USDT2 */
2931 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(
2932 env, clazz, (char *) name, (char *) sig);
2933 #endif /* USDT2 */
2293 jfieldID ret = NULL; 2934 jfieldID ret = NULL;
2294 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); 2935 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2295 2936
2296 // The class should have been loaded (we have an instance of the class 2937 // The class should have been loaded (we have an instance of the class
2297 // passed in) so the field and signature should already be in the symbol 2938 // passed in) so the field and signature should already be in the symbol
2323 JNI_END 2964 JNI_END
2324 2965
2325 2966
2326 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)) 2967 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2327 JNIWrapper("GetStaticObjectField"); 2968 JNIWrapper("GetStaticObjectField");
2328 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID); 2969 #ifndef USDT2
2970 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID);
2971 #else /* USDT2 */
2972 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(
2973 env, clazz, (uintptr_t) fieldID);
2974 #endif /* USDT2 */
2329 #if INCLUDE_JNI_CHECK 2975 #if INCLUDE_JNI_CHECK
2330 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);) 2976 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2331 #endif // INCLUDE_JNI_CHECK 2977 #endif // INCLUDE_JNI_CHECK
2332 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 2978 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2333 assert(id->is_static_field_id(), "invalid static field id"); 2979 assert(id->is_static_field_id(), "invalid static field id");
2335 // jni_GetField_probe() assumes that is okay to create handles. 2981 // jni_GetField_probe() assumes that is okay to create handles.
2336 if (JvmtiExport::should_post_field_access()) { 2982 if (JvmtiExport::should_post_field_access()) {
2337 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); 2983 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
2338 } 2984 }
2339 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); 2985 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
2340 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret); 2986 #ifndef USDT2
2987 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret);
2988 #else /* USDT2 */
2989 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(
2990 ret);
2991 #endif /* USDT2 */
2341 return ret; 2992 return ret;
2342 JNI_END 2993 JNI_END
2343 2994
2995 #ifndef USDT2
2996 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \
2997 \
2998 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\
2999 \
3000 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
3001 JNIWrapper("GetStatic" XSTR(Result) "Field"); \
3002 DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\
3003 Return ret = 0;\
3004 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
3005 (const Return&)ret);\
3006 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3007 assert(id->is_static_field_id(), "invalid static field id"); \
3008 /* Keep JVMTI addition small and only check enabled flag here. */ \
3009 /* jni_GetField_probe() assumes that is okay to create handles. */ \
3010 if (JvmtiExport::should_post_field_access()) { \
3011 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
3012 } \
3013 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
3014 return ret;\
3015 JNI_END
3016
3017 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean)
3018 DEFINE_GETSTATICFIELD(jbyte, byte, Byte)
3019 DEFINE_GETSTATICFIELD(jchar, char, Char)
3020 DEFINE_GETSTATICFIELD(jshort, short, Short)
3021 DEFINE_GETSTATICFIELD(jint, int, Int)
3022 DEFINE_GETSTATICFIELD(jlong, long, Long)
3023 DEFINE_GETSTATICFIELD(jfloat, float, Float)
3024 DEFINE_GETSTATICFIELD(jdouble, double, Double)
3025
3026 #else /* USDT2 */
2344 3027
2345 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \ 3028 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
2346 , EntryProbe, ReturnProbe) \ 3029 , EntryProbe, ReturnProbe) \
2347 \ 3030 \
2348 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \ 3031 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
2380 // Float and double probes don't return value because dtrace doesn't currently support it 3063 // Float and double probes don't return value because dtrace doesn't currently support it
2381 DEFINE_GETSTATICFIELD(jfloat, float, Float 3064 DEFINE_GETSTATICFIELD(jfloat, float, Float
2382 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() ) 3065 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() )
2383 DEFINE_GETSTATICFIELD(jdouble, double, Double 3066 DEFINE_GETSTATICFIELD(jdouble, double, Double
2384 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() ) 3067 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() )
3068 #endif /* USDT2 */
2385 3069
2386 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) 3070 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
2387 JNIWrapper("SetStaticObjectField"); 3071 JNIWrapper("SetStaticObjectField");
2388 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value); 3072 #ifndef USDT2
3073 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value);
3074 #else /* USDT2 */
3075 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(
3076 env, clazz, (uintptr_t) fieldID, value);
3077 #endif /* USDT2 */
2389 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 3078 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2390 assert(id->is_static_field_id(), "invalid static field id"); 3079 assert(id->is_static_field_id(), "invalid static field id");
2391 // Keep JVMTI addition small and only check enabled flag here. 3080 // Keep JVMTI addition small and only check enabled flag here.
2392 // jni_SetField_probe() assumes that is okay to create handles. 3081 // jni_SetField_probe() assumes that is okay to create handles.
2393 if (JvmtiExport::should_post_field_modification()) { 3082 if (JvmtiExport::should_post_field_modification()) {
2394 jvalue field_value; 3083 jvalue field_value;
2395 field_value.l = value; 3084 field_value.l = value;
2396 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); 3085 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
2397 } 3086 }
2398 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); 3087 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
2399 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN(); 3088 #ifndef USDT2
2400 JNI_END 3089 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return);
2401 3090 #else /* USDT2 */
2402 3091 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN(
3092 );
3093 #endif /* USDT2 */
3094 JNI_END
3095
3096
3097 #ifndef USDT2
3098 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \
3099 \
3100 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
3101 JNIWrapper("SetStatic" XSTR(Result) "Field"); \
3102 FP_SELECT_##Result( \
3103 DTRACE_PROBE4(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID, value), \
3104 DTRACE_PROBE3(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID)); \
3105 \
3106 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3107 assert(id->is_static_field_id(), "invalid static field id"); \
3108 /* Keep JVMTI addition small and only check enabled flag here. */ \
3109 /* jni_SetField_probe() assumes that is okay to create handles. */ \
3110 if (JvmtiExport::should_post_field_modification()) { \
3111 jvalue field_value; \
3112 field_value.unionType = value; \
3113 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
3114 } \
3115 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
3116 DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\
3117 JNI_END
3118
3119 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z)
3120 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b)
3121 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c)
3122 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s)
3123 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i)
3124 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j)
3125 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f)
3126 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d)
3127
3128 #else /* USDT2 */
2403 3129
2404 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \ 3130 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
2405 , EntryProbe, ReturnProbe) \ 3131 , EntryProbe, ReturnProbe) \
2406 \ 3132 \
2407 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ 3133 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
2420 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \ 3146 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
2421 ReturnProbe;\ 3147 ReturnProbe;\
2422 JNI_END 3148 JNI_END
2423 3149
2424 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z 3150 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z
2425 , HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value), 3151 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value),
2426 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()) 3152 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
2427 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b 3153 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b
2428 , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), 3154 , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
2429 HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN()) 3155 HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN())
2430 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c 3156 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c
2444 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), 3170 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
2445 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()) 3171 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
2446 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d 3172 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d
2447 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), 3173 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
2448 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) 3174 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
3175 #endif /* USDT2 */
2449 3176
2450 // 3177 //
2451 // String Operations 3178 // String Operations
2452 // 3179 //
2453 3180
2454 // Unicode Interface 3181 // Unicode Interface
2455 3182
3183 #ifndef USDT2
3184 DT_RETURN_MARK_DECL(NewString, jstring);
3185 #else /* USDT2 */
2456 DT_RETURN_MARK_DECL(NewString, jstring 3186 DT_RETURN_MARK_DECL(NewString, jstring
2457 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref)); 3187 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
3188 #endif /* USDT2 */
2458 3189
2459 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) 3190 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
2460 JNIWrapper("NewString"); 3191 JNIWrapper("NewString");
2461 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len); 3192 #ifndef USDT2
3193 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len);
3194 #else /* USDT2 */
3195 HOTSPOT_JNI_NEWSTRING_ENTRY(
3196 env, (uint16_t *) unicodeChars, len);
3197 #endif /* USDT2 */
2462 jstring ret = NULL; 3198 jstring ret = NULL;
2463 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); 3199 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
2464 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); 3200 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
2465 ret = (jstring) JNIHandles::make_local(env, string); 3201 ret = (jstring) JNIHandles::make_local(env, string);
2466 return ret; 3202 return ret;
2467 JNI_END 3203 JNI_END
2468 3204
2469 3205
2470 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) 3206 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
2471 JNIWrapper("GetStringLength"); 3207 JNIWrapper("GetStringLength");
2472 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string); 3208 #ifndef USDT2
3209 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string);
3210 #else /* USDT2 */
3211 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(
3212 env, string);
3213 #endif /* USDT2 */
2473 jsize ret = 0; 3214 jsize ret = 0;
2474 oop s = JNIHandles::resolve_non_null(string); 3215 oop s = JNIHandles::resolve_non_null(string);
2475 if (java_lang_String::value(s) != NULL) { 3216 if (java_lang_String::value(s) != NULL) {
2476 ret = java_lang_String::length(s); 3217 ret = java_lang_String::length(s);
2477 } 3218 }
2478 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret); 3219 #ifndef USDT2
3220 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
3221 #else /* USDT2 */
3222 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(
3223 ret);
3224 #endif /* USDT2 */
2479 return ret; 3225 return ret;
2480 JNI_END 3226 JNI_END
2481 3227
2482 3228
2483 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( 3229 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
2484 JNIEnv *env, jstring string, jboolean *isCopy)) 3230 JNIEnv *env, jstring string, jboolean *isCopy))
2485 JNIWrapper("GetStringChars"); 3231 JNIWrapper("GetStringChars");
2486 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy); 3232 #ifndef USDT2
3233 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
3234 #else /* USDT2 */
3235 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(
3236 env, string, (uintptr_t *) isCopy);
3237 #endif /* USDT2 */
2487 jchar* buf = NULL; 3238 jchar* buf = NULL;
2488 oop s = JNIHandles::resolve_non_null(string); 3239 oop s = JNIHandles::resolve_non_null(string);
2489 typeArrayOop s_value = java_lang_String::value(s); 3240 typeArrayOop s_value = java_lang_String::value(s);
2490 if (s_value != NULL) { 3241 if (s_value != NULL) {
2491 int s_len = java_lang_String::length(s); 3242 int s_len = java_lang_String::length(s);
2501 if (isCopy != NULL) { 3252 if (isCopy != NULL) {
2502 *isCopy = JNI_TRUE; 3253 *isCopy = JNI_TRUE;
2503 } 3254 }
2504 } 3255 }
2505 } 3256 }
2506 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf); 3257 #ifndef USDT2
3258 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
3259 #else /* USDT2 */
3260 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(
3261 buf);
3262 #endif /* USDT2 */
2507 return buf; 3263 return buf;
2508 JNI_END 3264 JNI_END
2509 3265
2510 3266
2511 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) 3267 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
2512 JNIWrapper("ReleaseStringChars"); 3268 JNIWrapper("ReleaseStringChars");
2513 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars); 3269 #ifndef USDT2
3270 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars);
3271 #else /* USDT2 */
3272 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(
3273 env, str, (uint16_t *) chars);
3274 #endif /* USDT2 */
2514 //%note jni_6 3275 //%note jni_6
2515 if (chars != NULL) { 3276 if (chars != NULL) {
2516 // Since String objects are supposed to be immutable, don't copy any 3277 // Since String objects are supposed to be immutable, don't copy any
2517 // new data back. A bad user will have to go after the char array. 3278 // new data back. A bad user will have to go after the char array.
2518 FreeHeap((void*) chars); 3279 FreeHeap((void*) chars);
2519 } 3280 }
2520 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN(); 3281 #ifndef USDT2
3282 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return);
3283 #else /* USDT2 */
3284 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN(
3285 );
3286 #endif /* USDT2 */
2521 JNI_END 3287 JNI_END
2522 3288
2523 3289
2524 // UTF Interface 3290 // UTF Interface
2525 3291
3292 #ifndef USDT2
3293 DT_RETURN_MARK_DECL(NewStringUTF, jstring);
3294 #else /* USDT2 */
2526 DT_RETURN_MARK_DECL(NewStringUTF, jstring 3295 DT_RETURN_MARK_DECL(NewStringUTF, jstring
2527 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref)); 3296 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
3297 #endif /* USDT2 */
2528 3298
2529 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) 3299 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
2530 JNIWrapper("NewStringUTF"); 3300 JNIWrapper("NewStringUTF");
2531 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes); 3301 #ifndef USDT2
3302 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes);
3303 #else /* USDT2 */
3304 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(
3305 env, (char *) bytes);
3306 #endif /* USDT2 */
2532 jstring ret; 3307 jstring ret;
2533 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); 3308 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
2534 3309
2535 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); 3310 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
2536 ret = (jstring) JNIHandles::make_local(env, result); 3311 ret = (jstring) JNIHandles::make_local(env, result);
2538 JNI_END 3313 JNI_END
2539 3314
2540 3315
2541 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) 3316 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
2542 JNIWrapper("GetStringUTFLength"); 3317 JNIWrapper("GetStringUTFLength");
2543 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string); 3318 #ifndef USDT2
3319 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string);
3320 #else /* USDT2 */
3321 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(
3322 env, string);
3323 #endif /* USDT2 */
2544 jsize ret = 0; 3324 jsize ret = 0;
2545 oop java_string = JNIHandles::resolve_non_null(string); 3325 oop java_string = JNIHandles::resolve_non_null(string);
2546 if (java_lang_String::value(java_string) != NULL) { 3326 if (java_lang_String::value(java_string) != NULL) {
2547 ret = java_lang_String::utf8_length(java_string); 3327 ret = java_lang_String::utf8_length(java_string);
2548 } 3328 }
2549 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret); 3329 #ifndef USDT2
3330 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
3331 #else /* USDT2 */
3332 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(
3333 ret);
3334 #endif /* USDT2 */
2550 return ret; 3335 return ret;
2551 JNI_END 3336 JNI_END
2552 3337
2553 3338
2554 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) 3339 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
2555 JNIWrapper("GetStringUTFChars"); 3340 JNIWrapper("GetStringUTFChars");
2556 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy); 3341 #ifndef USDT2
3342 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy);
3343 #else /* USDT2 */
3344 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(
3345 env, string, (uintptr_t *) isCopy);
3346 #endif /* USDT2 */
2557 char* result = NULL; 3347 char* result = NULL;
2558 oop java_string = JNIHandles::resolve_non_null(string); 3348 oop java_string = JNIHandles::resolve_non_null(string);
2559 if (java_lang_String::value(java_string) != NULL) { 3349 if (java_lang_String::value(java_string) != NULL) {
2560 size_t length = java_lang_String::utf8_length(java_string); 3350 size_t length = java_lang_String::utf8_length(java_string);
2561 /* JNI Specification states return NULL on OOM */ 3351 /* JNI Specification states return NULL on OOM */
2565 if (isCopy != NULL) { 3355 if (isCopy != NULL) {
2566 *isCopy = JNI_TRUE; 3356 *isCopy = JNI_TRUE;
2567 } 3357 }
2568 } 3358 }
2569 } 3359 }
2570 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result); 3360 #ifndef USDT2
3361 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
3362 #else /* USDT2 */
3363 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(
3364 result);
3365 #endif /* USDT2 */
2571 return result; 3366 return result;
2572 JNI_END 3367 JNI_END
2573 3368
2574 3369
2575 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) 3370 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
2576 JNIWrapper("ReleaseStringUTFChars"); 3371 JNIWrapper("ReleaseStringUTFChars");
2577 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars); 3372 #ifndef USDT2
3373 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars);
3374 #else /* USDT2 */
3375 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(
3376 env, str, (char *) chars);
3377 #endif /* USDT2 */
2578 if (chars != NULL) { 3378 if (chars != NULL) {
2579 FreeHeap((char*) chars); 3379 FreeHeap((char*) chars);
2580 } 3380 }
2581 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN(); 3381 #ifndef USDT2
3382 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return);
3383 #else /* USDT2 */
3384 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN(
3385 );
3386 #endif /* USDT2 */
2582 JNI_END 3387 JNI_END
2583 3388
2584 3389
2585 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) 3390 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
2586 JNIWrapper("GetArrayLength"); 3391 JNIWrapper("GetArrayLength");
2587 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array); 3392 #ifndef USDT2
3393 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array);
3394 #else /* USDT2 */
3395 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(
3396 env, array);
3397 #endif /* USDT2 */
2588 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); 3398 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
2589 assert(a->is_array(), "must be array"); 3399 assert(a->is_array(), "must be array");
2590 jsize ret = a->length(); 3400 jsize ret = a->length();
2591 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret); 3401 #ifndef USDT2
3402 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret);
3403 #else /* USDT2 */
3404 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(
3405 ret);
3406 #endif /* USDT2 */
2592 return ret; 3407 return ret;
2593 JNI_END 3408 JNI_END
2594 3409
2595 3410
2596 // 3411 //
2597 // Object Array Operations 3412 // Object Array Operations
2598 // 3413 //
2599 3414
3415 #ifndef USDT2
3416 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray);
3417 #else /* USDT2 */
2600 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray 3418 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
2601 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref)); 3419 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
3420 #endif /* USDT2 */
2602 3421
2603 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) 3422 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
2604 JNIWrapper("NewObjectArray"); 3423 JNIWrapper("NewObjectArray");
2605 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement); 3424 #ifndef USDT2
3425 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement);
3426 #else /* USDT2 */
3427 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(
3428 env, length, elementClass, initialElement);
3429 #endif /* USDT2 */
2606 jobjectArray ret = NULL; 3430 jobjectArray ret = NULL;
2607 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); 3431 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
2608 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass))); 3432 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
2609 Klass* ako = ek()->array_klass(CHECK_NULL); 3433 Klass* ako = ek()->array_klass(CHECK_NULL);
2610 KlassHandle ak = KlassHandle(THREAD, ako); 3434 KlassHandle ak = KlassHandle(THREAD, ako);
2618 } 3442 }
2619 ret = (jobjectArray) JNIHandles::make_local(env, result); 3443 ret = (jobjectArray) JNIHandles::make_local(env, result);
2620 return ret; 3444 return ret;
2621 JNI_END 3445 JNI_END
2622 3446
3447 #ifndef USDT2
3448 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject);
3449 #else /* USDT2 */
2623 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject 3450 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
2624 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref)); 3451 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
3452 #endif /* USDT2 */
2625 3453
2626 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) 3454 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
2627 JNIWrapper("GetObjectArrayElement"); 3455 JNIWrapper("GetObjectArrayElement");
2628 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index); 3456 #ifndef USDT2
3457 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index);
3458 #else /* USDT2 */
3459 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(
3460 env, array, index);
3461 #endif /* USDT2 */
2629 jobject ret = NULL; 3462 jobject ret = NULL;
2630 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); 3463 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
2631 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 3464 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2632 if (a->is_within_bounds(index)) { 3465 if (a->is_within_bounds(index)) {
2633 ret = JNIHandles::make_local(env, a->obj_at(index)); 3466 ret = JNIHandles::make_local(env, a->obj_at(index));
2637 sprintf(buf, "%d", index); 3470 sprintf(buf, "%d", index);
2638 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); 3471 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
2639 } 3472 }
2640 JNI_END 3473 JNI_END
2641 3474
3475 #ifndef USDT2
3476 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement);
3477 #else /* USDT2 */
2642 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement 3478 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
2643 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN()); 3479 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
3480 #endif /* USDT2 */
2644 3481
2645 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) 3482 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
2646 JNIWrapper("SetObjectArrayElement"); 3483 JNIWrapper("SetObjectArrayElement");
2647 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value); 3484 #ifndef USDT2
3485 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value);
3486 #else /* USDT2 */
3487 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(
3488 env, array, index, value);
3489 #endif /* USDT2 */
2648 DT_VOID_RETURN_MARK(SetObjectArrayElement); 3490 DT_VOID_RETURN_MARK(SetObjectArrayElement);
2649 3491
2650 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 3492 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2651 oop v = JNIHandles::resolve(value); 3493 oop v = JNIHandles::resolve(value);
2652 if (a->is_within_bounds(index)) { 3494 if (a->is_within_bounds(index)) {
2661 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); 3503 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
2662 } 3504 }
2663 JNI_END 3505 JNI_END
2664 3506
2665 3507
3508 #ifndef USDT2
3509 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \
3510 \
3511 DT_RETURN_MARK_DECL(New##Result##Array, Return); \
3512 \
3513 JNI_ENTRY(Return, \
3514 jni_New##Result##Array(JNIEnv *env, jsize len)) \
3515 JNIWrapper("New" XSTR(Result) "Array"); \
3516 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\
3517 Return ret = NULL;\
3518 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
3519 \
3520 oop obj= oopFactory::Allocator(len, CHECK_0); \
3521 ret = (Return) JNIHandles::make_local(env, obj); \
3522 return ret;\
3523 JNI_END
3524
3525 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean)
3526 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte)
3527 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short)
3528 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char)
3529 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int)
3530 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long)
3531 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float)
3532 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double)
3533
3534 #else /* USDT2 */
2666 3535
2667 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \ 3536 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
2668 ,EntryProbe,ReturnProbe) \ 3537 ,EntryProbe,ReturnProbe) \
2669 \ 3538 \
2670 DT_RETURN_MARK_DECL(New##Result##Array, Return \ 3539 DT_RETURN_MARK_DECL(New##Result##Array, Return \
2704 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len), 3573 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
2705 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref)) 3574 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
2706 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double, 3575 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double,
2707 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len), 3576 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
2708 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref)) 3577 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
3578 #endif /* USDT2 */
2709 3579
2710 // Return an address which will fault if the caller writes to it. 3580 // Return an address which will fault if the caller writes to it.
2711 3581
2712 static char* get_bad_address() { 3582 static char* get_bad_address() {
2713 static char* bad_address = NULL; 3583 static char* bad_address = NULL;
2721 } 3591 }
2722 return bad_address; 3592 return bad_address;
2723 } 3593 }
2724 3594
2725 3595
3596 #ifndef USDT2
3597 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \
3598 \
3599 JNI_QUICK_ENTRY(ElementType*, \
3600 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
3601 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
3602 DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\
3603 /* allocate an chunk of memory in c land */ \
3604 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3605 ElementType* result; \
3606 int len = a->length(); \
3607 if (len == 0) { \
3608 /* Empty array: legal but useless, can't return NULL. \
3609 * Return a pointer to something useless. \
3610 * Avoid asserts in typeArrayOop. */ \
3611 result = (ElementType*)get_bad_address(); \
3612 } else { \
3613 /* JNI Specification states return NULL on OOM */ \
3614 result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
3615 if (result != NULL) { \
3616 /* copy the array to the c chunk */ \
3617 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
3618 if (isCopy) { \
3619 *isCopy = JNI_TRUE; \
3620 } \
3621 } \
3622 } \
3623 DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
3624 return result; \
3625 JNI_END
3626
3627 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
3628 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
3629 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
3630 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
3631 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int)
3632 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
3633 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
3634 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
3635
3636 #else /* USDT2 */
2726 3637
2727 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \ 3638 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
2728 , EntryProbe, ReturnProbe) \ 3639 , EntryProbe, ReturnProbe) \
2729 \ 3640 \
2730 JNI_QUICK_ENTRY(ElementType*, \ 3641 JNI_QUICK_ENTRY(ElementType*, \
2778 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), 3689 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2779 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result)) 3690 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
2780 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double 3691 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
2781 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), 3692 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2782 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result)) 3693 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
2783 3694 #endif /* USDT2 */
3695
3696 #ifndef USDT2
3697 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \
3698 \
3699 JNI_QUICK_ENTRY(void, \
3700 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
3701 ElementType *buf, jint mode)) \
3702 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
3703 DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\
3704 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3705 int len = a->length(); \
3706 if (len != 0) { /* Empty array: nothing to free or copy. */ \
3707 if ((mode == 0) || (mode == JNI_COMMIT)) { \
3708 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
3709 } \
3710 if ((mode == 0) || (mode == JNI_ABORT)) { \
3711 FreeHeap(buf); \
3712 } \
3713 } \
3714 DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\
3715 JNI_END
3716
3717 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
3718 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
3719 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
3720 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
3721 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int)
3722 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
3723 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
3724 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
3725
3726 #else /* USDT2 */
2784 3727
2785 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \ 3728 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
2786 , EntryProbe, ReturnProbe);\ 3729 , EntryProbe, ReturnProbe);\
2787 \ 3730 \
2788 JNI_QUICK_ENTRY(void, \ 3731 JNI_QUICK_ENTRY(void, \
2825 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode), 3768 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
2826 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()) 3769 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
2827 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double 3770 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
2828 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode), 3771 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
2829 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()) 3772 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
2830 3773 #endif /* USDT2 */
3774
3775 #ifndef USDT2
3776 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
3777 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\
3778 \
3779 JNI_ENTRY(void, \
3780 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3781 jsize len, ElementType *buf)) \
3782 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
3783 DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\
3784 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
3785 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3786 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
3787 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3788 } else { \
3789 if (len > 0) { \
3790 int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
3791 memcpy((u_char*) buf, \
3792 (u_char*) src->Tag##_at_addr(start), \
3793 len << sc); \
3794 } \
3795 } \
3796 JNI_END
3797
3798 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool)
3799 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
3800 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
3801 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
3802 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int)
3803 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long)
3804 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
3805 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
3806
3807 #else /* USDT2 */
2831 3808
2832 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ 3809 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
2833 , EntryProbe, ReturnProbe); \ 3810 , EntryProbe, ReturnProbe); \
2834 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \ 3811 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
2835 , ReturnProbe); \ 3812 , ReturnProbe); \
2875 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), 3852 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
2876 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()); 3853 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
2877 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double 3854 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
2878 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), 3855 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
2879 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()); 3856 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
2880 3857 #endif /* USDT2 */
3858
3859 #ifndef USDT2
3860 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
3861 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\
3862 \
3863 JNI_ENTRY(void, \
3864 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3865 jsize len, const ElementType *buf)) \
3866 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
3867 DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\
3868 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
3869 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3870 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
3871 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3872 } else { \
3873 if (len > 0) { \
3874 int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
3875 memcpy((u_char*) dst->Tag##_at_addr(start), \
3876 (u_char*) buf, \
3877 len << sc); \
3878 } \
3879 } \
3880 JNI_END
3881
3882 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool)
3883 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
3884 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
3885 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
3886 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int)
3887 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long)
3888 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
3889 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
3890
3891 #else /* USDT2 */
2881 3892
2882 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ 3893 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
2883 , EntryProbe, ReturnProbe); \ 3894 , EntryProbe, ReturnProbe); \
2884 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \ 3895 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
2885 ,ReturnProbe); \ 3896 ,ReturnProbe); \
2925 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), 3936 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
2926 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN()) 3937 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
2927 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double 3938 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
2928 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), 3939 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
2929 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN()) 3940 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
3941 #endif /* USDT2 */
2930 3942
2931 3943
2932 // 3944 //
2933 // Interception of natives 3945 // Interception of natives
2934 // 3946 //
3009 method->name()->as_C_string()); 4021 method->name()->as_C_string());
3010 } 4022 }
3011 return true; 4023 return true;
3012 } 4024 }
3013 4025
4026 #ifndef USDT2
4027 DT_RETURN_MARK_DECL(RegisterNatives, jint);
4028 #else /* USDT2 */
3014 DT_RETURN_MARK_DECL(RegisterNatives, jint 4029 DT_RETURN_MARK_DECL(RegisterNatives, jint
3015 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref)); 4030 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
4031 #endif /* USDT2 */
3016 4032
3017 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz, 4033 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
3018 const JNINativeMethod *methods, 4034 const JNINativeMethod *methods,
3019 jint nMethods)) 4035 jint nMethods))
3020 JNIWrapper("RegisterNatives"); 4036 JNIWrapper("RegisterNatives");
3021 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods); 4037 #ifndef USDT2
4038 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
4039 #else /* USDT2 */
4040 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(
4041 env, clazz, (void *) methods, nMethods);
4042 #endif /* USDT2 */
3022 jint ret = 0; 4043 jint ret = 0;
3023 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret); 4044 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
3024 4045
3025 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 4046 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
3026 4047
3054 JNI_END 4075 JNI_END
3055 4076
3056 4077
3057 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz)) 4078 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
3058 JNIWrapper("UnregisterNatives"); 4079 JNIWrapper("UnregisterNatives");
3059 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz); 4080 #ifndef USDT2
4081 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz);
4082 #else /* USDT2 */
4083 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(
4084 env, clazz);
4085 #endif /* USDT2 */
3060 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)); 4086 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
3061 //%note jni_2 4087 //%note jni_2
3062 if (k->oop_is_instance()) { 4088 if (k->oop_is_instance()) {
3063 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) { 4089 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
3064 Method* m = InstanceKlass::cast(k)->methods()->at(index); 4090 Method* m = InstanceKlass::cast(k)->methods()->at(index);
3066 m->clear_native_function(); 4092 m->clear_native_function();
3067 m->set_signature_handler(NULL); 4093 m->set_signature_handler(NULL);
3068 } 4094 }
3069 } 4095 }
3070 } 4096 }
3071 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0); 4097 #ifndef USDT2
4098 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
4099 #else /* USDT2 */
4100 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(
4101 0);
4102 #endif /* USDT2 */
3072 return 0; 4103 return 0;
3073 JNI_END 4104 JNI_END
3074 4105
3075 // 4106 //
3076 // Monitor functions 4107 // Monitor functions
3077 // 4108 //
3078 4109
4110 #ifndef USDT2
4111 DT_RETURN_MARK_DECL(MonitorEnter, jint);
4112 #else /* USDT2 */
3079 DT_RETURN_MARK_DECL(MonitorEnter, jint 4113 DT_RETURN_MARK_DECL(MonitorEnter, jint
3080 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref)); 4114 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
4115 #endif /* USDT2 */
3081 4116
3082 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj)) 4117 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
3083 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj); 4118 #ifndef USDT2
4119 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj);
4120 #else /* USDT2 */
4121 HOTSPOT_JNI_MONITORENTER_ENTRY(
4122 env, jobj);
4123 #endif /* USDT2 */
3084 jint ret = JNI_ERR; 4124 jint ret = JNI_ERR;
3085 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret); 4125 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
3086 4126
3087 // If the object is null, we can't do anything with it 4127 // If the object is null, we can't do anything with it
3088 if (jobj == NULL) { 4128 if (jobj == NULL) {
3093 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR)); 4133 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
3094 ret = JNI_OK; 4134 ret = JNI_OK;
3095 return ret; 4135 return ret;
3096 JNI_END 4136 JNI_END
3097 4137
4138 #ifndef USDT2
4139 DT_RETURN_MARK_DECL(MonitorExit, jint);
4140 #else /* USDT2 */
3098 DT_RETURN_MARK_DECL(MonitorExit, jint 4141 DT_RETURN_MARK_DECL(MonitorExit, jint
3099 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref)); 4142 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
4143 #endif /* USDT2 */
3100 4144
3101 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj)) 4145 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
3102 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj); 4146 #ifndef USDT2
4147 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj);
4148 #else /* USDT2 */
4149 HOTSPOT_JNI_MONITOREXIT_ENTRY(
4150 env, jobj);
4151 #endif /* USDT2 */
3103 jint ret = JNI_ERR; 4152 jint ret = JNI_ERR;
3104 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret); 4153 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
3105 4154
3106 // Don't do anything with a null object 4155 // Don't do anything with a null object
3107 if (jobj == NULL) { 4156 if (jobj == NULL) {
3117 4166
3118 // 4167 //
3119 // Extensions 4168 // Extensions
3120 // 4169 //
3121 4170
4171 #ifndef USDT2
4172 DT_VOID_RETURN_MARK_DECL(GetStringRegion);
4173 #else /* USDT2 */
3122 DT_VOID_RETURN_MARK_DECL(GetStringRegion 4174 DT_VOID_RETURN_MARK_DECL(GetStringRegion
3123 , HOTSPOT_JNI_GETSTRINGREGION_RETURN()); 4175 , HOTSPOT_JNI_GETSTRINGREGION_RETURN());
4176 #endif /* USDT2 */
3124 4177
3125 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) 4178 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
3126 JNIWrapper("GetStringRegion"); 4179 JNIWrapper("GetStringRegion");
3127 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf); 4180 #ifndef USDT2
4181 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf);
4182 #else /* USDT2 */
4183 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(
4184 env, string, start, len, buf);
4185 #endif /* USDT2 */
3128 DT_VOID_RETURN_MARK(GetStringRegion); 4186 DT_VOID_RETURN_MARK(GetStringRegion);
3129 oop s = JNIHandles::resolve_non_null(string); 4187 oop s = JNIHandles::resolve_non_null(string);
3130 int s_len = java_lang_String::length(s); 4188 int s_len = java_lang_String::length(s);
3131 if (start < 0 || len < 0 || start + len > s_len) { 4189 if (start < 0 || len < 0 || start + len > s_len) {
3132 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); 4190 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
3137 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); 4195 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len);
3138 } 4196 }
3139 } 4197 }
3140 JNI_END 4198 JNI_END
3141 4199
4200 #ifndef USDT2
4201 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion);
4202 #else /* USDT2 */
3142 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion 4203 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
3143 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN()); 4204 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
4205 #endif /* USDT2 */
3144 4206
3145 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) 4207 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
3146 JNIWrapper("GetStringUTFRegion"); 4208 JNIWrapper("GetStringUTFRegion");
3147 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf); 4209 #ifndef USDT2
4210 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf);
4211 #else /* USDT2 */
4212 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(
4213 env, string, start, len, buf);
4214 #endif /* USDT2 */
3148 DT_VOID_RETURN_MARK(GetStringUTFRegion); 4215 DT_VOID_RETURN_MARK(GetStringUTFRegion);
3149 oop s = JNIHandles::resolve_non_null(string); 4216 oop s = JNIHandles::resolve_non_null(string);
3150 int s_len = java_lang_String::length(s); 4217 int s_len = java_lang_String::length(s);
3151 if (start < 0 || len < 0 || start + len > s_len) { 4218 if (start < 0 || len < 0 || start + len > s_len) {
3152 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); 4219 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
3168 JNI_END 4235 JNI_END
3169 4236
3170 4237
3171 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) 4238 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
3172 JNIWrapper("GetPrimitiveArrayCritical"); 4239 JNIWrapper("GetPrimitiveArrayCritical");
3173 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy); 4240 #ifndef USDT2
4241 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy);
4242 #else /* USDT2 */
4243 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(
4244 env, array, (uintptr_t *) isCopy);
4245 #endif /* USDT2 */
3174 GC_locker::lock_critical(thread); 4246 GC_locker::lock_critical(thread);
3175 if (isCopy != NULL) { 4247 if (isCopy != NULL) {
3176 *isCopy = JNI_FALSE; 4248 *isCopy = JNI_FALSE;
3177 } 4249 }
3178 oop a = JNIHandles::resolve_non_null(array); 4250 oop a = JNIHandles::resolve_non_null(array);
3182 type = T_OBJECT; 4254 type = T_OBJECT;
3183 } else { 4255 } else {
3184 type = TypeArrayKlass::cast(a->klass())->element_type(); 4256 type = TypeArrayKlass::cast(a->klass())->element_type();
3185 } 4257 }
3186 void* ret = arrayOop(a)->base(type); 4258 void* ret = arrayOop(a)->base(type);
3187 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret); 4259 #ifndef USDT2
4260 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
4261 #else /* USDT2 */
4262 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(
4263 ret);
4264 #endif /* USDT2 */
3188 return ret; 4265 return ret;
3189 JNI_END 4266 JNI_END
3190 4267
3191 4268
3192 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) 4269 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
3193 JNIWrapper("ReleasePrimitiveArrayCritical"); 4270 JNIWrapper("ReleasePrimitiveArrayCritical");
3194 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode); 4271 #ifndef USDT2
4272 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode);
4273 #else /* USDT2 */
4274 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(
4275 env, array, carray, mode);
4276 #endif /* USDT2 */
3195 // The array, carray and mode arguments are ignored 4277 // The array, carray and mode arguments are ignored
3196 GC_locker::unlock_critical(thread); 4278 GC_locker::unlock_critical(thread);
3197 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(); 4279 #ifndef USDT2
4280 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return);
4281 #else /* USDT2 */
4282 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(
4283 );
4284 #endif /* USDT2 */
3198 JNI_END 4285 JNI_END
3199 4286
3200 4287
3201 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) 4288 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
3202 JNIWrapper("GetStringCritical"); 4289 JNIWrapper("GetStringCritical");
3203 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy); 4290 #ifndef USDT2
4291 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy);
4292 #else /* USDT2 */
4293 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(
4294 env, string, (uintptr_t *) isCopy);
4295 #endif /* USDT2 */
3204 GC_locker::lock_critical(thread); 4296 GC_locker::lock_critical(thread);
3205 if (isCopy != NULL) { 4297 if (isCopy != NULL) {
3206 *isCopy = JNI_FALSE; 4298 *isCopy = JNI_FALSE;
3207 } 4299 }
3208 oop s = JNIHandles::resolve_non_null(string); 4300 oop s = JNIHandles::resolve_non_null(string);
3213 if (s_len > 0) { 4305 if (s_len > 0) {
3214 ret = s_value->char_at_addr(s_offset); 4306 ret = s_value->char_at_addr(s_offset);
3215 } else { 4307 } else {
3216 ret = (jchar*) s_value->base(T_CHAR); 4308 ret = (jchar*) s_value->base(T_CHAR);
3217 } 4309 }
3218 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret); 4310 #ifndef USDT2
4311 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
4312 #else /* USDT2 */
4313 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN(
4314 (uint16_t *) ret);
4315 #endif /* USDT2 */
3219 return ret; 4316 return ret;
3220 JNI_END 4317 JNI_END
3221 4318
3222 4319
3223 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) 4320 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
3224 JNIWrapper("ReleaseStringCritical"); 4321 JNIWrapper("ReleaseStringCritical");
3225 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars); 4322 #ifndef USDT2
4323 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars);
4324 #else /* USDT2 */
4325 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(
4326 env, str, (uint16_t *) chars);
4327 #endif /* USDT2 */
3226 // The str and chars arguments are ignored 4328 // The str and chars arguments are ignored
3227 GC_locker::unlock_critical(thread); 4329 GC_locker::unlock_critical(thread);
3228 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(); 4330 #ifndef USDT2
4331 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return);
4332 #else /* USDT2 */
4333 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(
4334 );
4335 #endif /* USDT2 */
3229 JNI_END 4336 JNI_END
3230 4337
3231 4338
3232 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) 4339 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
3233 JNIWrapper("jni_NewWeakGlobalRef"); 4340 JNIWrapper("jni_NewWeakGlobalRef");
3234 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref); 4341 #ifndef USDT2
4342 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref);
4343 #else /* USDT2 */
4344 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(
4345 env, ref);
4346 #endif /* USDT2 */
3235 Handle ref_handle(thread, JNIHandles::resolve(ref)); 4347 Handle ref_handle(thread, JNIHandles::resolve(ref));
3236 jweak ret = JNIHandles::make_weak_global(ref_handle); 4348 jweak ret = JNIHandles::make_weak_global(ref_handle);
3237 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret); 4349 #ifndef USDT2
4350 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret);
4351 #else /* USDT2 */
4352 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(
4353 ret);
4354 #endif /* USDT2 */
3238 return ret; 4355 return ret;
3239 JNI_END 4356 JNI_END
3240 4357
3241 // Must be JNI_ENTRY (with HandleMark) 4358 // Must be JNI_ENTRY (with HandleMark)
3242 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) 4359 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
3243 JNIWrapper("jni_DeleteWeakGlobalRef"); 4360 JNIWrapper("jni_DeleteWeakGlobalRef");
3244 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref); 4361 #ifndef USDT2
4362 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref);
4363 #else /* USDT2 */
4364 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(
4365 env, ref);
4366 #endif /* USDT2 */
3245 JNIHandles::destroy_weak_global(ref); 4367 JNIHandles::destroy_weak_global(ref);
3246 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(); 4368 #ifndef USDT2
4369 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
4370 #else /* USDT2 */
4371 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(
4372 );
4373 #endif /* USDT2 */
3247 JNI_END 4374 JNI_END
3248 4375
3249 4376
3250 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) 4377 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
3251 JNIWrapper("jni_ExceptionCheck"); 4378 JNIWrapper("jni_ExceptionCheck");
3252 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env); 4379 #ifndef USDT2
4380 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env);
4381 #else /* USDT2 */
4382 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(
4383 env);
4384 #endif /* USDT2 */
3253 jni_check_async_exceptions(thread); 4385 jni_check_async_exceptions(thread);
3254 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; 4386 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
3255 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret); 4387 #ifndef USDT2
4388 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret);
4389 #else /* USDT2 */
4390 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(
4391 ret);
4392 #endif /* USDT2 */
3256 return ret; 4393 return ret;
3257 JNI_END 4394 JNI_END
3258 4395
3259 4396
3260 // Initialization state for three routines below relating to 4397 // Initialization state for three routines below relating to
3310 directBufferClass = (jclass) env->NewGlobalRef(directBufferClass); 4447 directBufferClass = (jclass) env->NewGlobalRef(directBufferClass);
3311 directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass); 4448 directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
3312 4449
3313 // Get needed field and method IDs 4450 // Get needed field and method IDs
3314 directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V"); 4451 directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
3315 if (env->ExceptionCheck()) {
3316 env->ExceptionClear();
3317 directBufferSupportInitializeFailed = 1;
3318 return false;
3319 }
3320 directBufferAddressField = env->GetFieldID(bufferClass, "address", "J"); 4452 directBufferAddressField = env->GetFieldID(bufferClass, "address", "J");
3321 if (env->ExceptionCheck()) {
3322 env->ExceptionClear();
3323 directBufferSupportInitializeFailed = 1;
3324 return false;
3325 }
3326 bufferCapacityField = env->GetFieldID(bufferClass, "capacity", "I"); 4453 bufferCapacityField = env->GetFieldID(bufferClass, "capacity", "I");
3327 if (env->ExceptionCheck()) {
3328 env->ExceptionClear();
3329 directBufferSupportInitializeFailed = 1;
3330 return false;
3331 }
3332 4454
3333 if ((directByteBufferConstructor == NULL) || 4455 if ((directByteBufferConstructor == NULL) ||
3334 (directBufferAddressField == NULL) || 4456 (directBufferAddressField == NULL) ||
3335 (bufferCapacityField == NULL)) { 4457 (bufferCapacityField == NULL)) {
3336 directBufferSupportInitializeFailed = 1; 4458 directBufferSupportInitializeFailed = 1;
3357 { 4479 {
3358 // thread_from_jni_environment() will block if VM is gone. 4480 // thread_from_jni_environment() will block if VM is gone.
3359 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 4481 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
3360 4482
3361 JNIWrapper("jni_NewDirectByteBuffer"); 4483 JNIWrapper("jni_NewDirectByteBuffer");
3362 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity); 4484 #ifndef USDT2
4485 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
4486 #else /* USDT2 */
4487 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(
4488 env, address, capacity);
4489 #endif /* USDT2 */
3363 4490
3364 if (!directBufferSupportInitializeEnded) { 4491 if (!directBufferSupportInitializeEnded) {
3365 if (!initializeDirectBufferSupport(env, thread)) { 4492 if (!initializeDirectBufferSupport(env, thread)) {
3366 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL); 4493 #ifndef USDT2
4494 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL);
4495 #else /* USDT2 */
4496 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(
4497 NULL);
4498 #endif /* USDT2 */
3367 return NULL; 4499 return NULL;
3368 } 4500 }
3369 } 4501 }
3370 4502
3371 // Being paranoid about accidental sign extension on address 4503 // Being paranoid about accidental sign extension on address
3372 jlong addr = (jlong) ((uintptr_t) address); 4504 jlong addr = (jlong) ((uintptr_t) address);
3373 // NOTE that package-private DirectByteBuffer constructor currently 4505 // NOTE that package-private DirectByteBuffer constructor currently
3374 // takes int capacity 4506 // takes int capacity
3375 jint cap = (jint) capacity; 4507 jint cap = (jint) capacity;
3376 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); 4508 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
3377 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret); 4509 #ifndef USDT2
4510 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret);
4511 #else /* USDT2 */
4512 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(
4513 ret);
4514 #endif /* USDT2 */
3378 return ret; 4515 return ret;
3379 } 4516 }
3380 4517
4518 #ifndef USDT2
4519 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*);
4520 #else /* USDT2 */
3381 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void* 4521 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
3382 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref)); 4522 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
4523 #endif /* USDT2 */
3383 4524
3384 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) 4525 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
3385 { 4526 {
3386 // thread_from_jni_environment() will block if VM is gone. 4527 // thread_from_jni_environment() will block if VM is gone.
3387 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 4528 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
3388 4529
3389 JNIWrapper("jni_GetDirectBufferAddress"); 4530 JNIWrapper("jni_GetDirectBufferAddress");
3390 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf); 4531 #ifndef USDT2
4532 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
4533 #else /* USDT2 */
4534 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(
4535 env, buf);
4536 #endif /* USDT2 */
3391 void* ret = NULL; 4537 void* ret = NULL;
3392 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); 4538 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
3393 4539
3394 if (!directBufferSupportInitializeEnded) { 4540 if (!directBufferSupportInitializeEnded) {
3395 if (!initializeDirectBufferSupport(env, thread)) { 4541 if (!initializeDirectBufferSupport(env, thread)) {
3403 4549
3404 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); 4550 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
3405 return ret; 4551 return ret;
3406 } 4552 }
3407 4553
4554 #ifndef USDT2
4555 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong);
4556 #else /* USDT2 */
3408 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong 4557 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
3409 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref)); 4558 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
4559 #endif /* USDT2 */
3410 4560
3411 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) 4561 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
3412 { 4562 {
3413 // thread_from_jni_environment() will block if VM is gone. 4563 // thread_from_jni_environment() will block if VM is gone.
3414 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 4564 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
3415 4565
3416 JNIWrapper("jni_GetDirectBufferCapacity"); 4566 JNIWrapper("jni_GetDirectBufferCapacity");
3417 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf); 4567 #ifndef USDT2
4568 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
4569 #else /* USDT2 */
4570 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(
4571 env, buf);
4572 #endif /* USDT2 */
3418 jlong ret = -1; 4573 jlong ret = -1;
3419 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); 4574 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
3420 4575
3421 if (!directBufferSupportInitializeEnded) { 4576 if (!directBufferSupportInitializeEnded) {
3422 if (!initializeDirectBufferSupport(env, thread)) { 4577 if (!initializeDirectBufferSupport(env, thread)) {
3439 } 4594 }
3440 4595
3441 4596
3442 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) 4597 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
3443 JNIWrapper("GetVersion"); 4598 JNIWrapper("GetVersion");
3444 HOTSPOT_JNI_GETVERSION_ENTRY(env); 4599 #ifndef USDT2
3445 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion); 4600 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
4601 #else /* USDT2 */
4602 HOTSPOT_JNI_GETVERSION_ENTRY(
4603 env);
4604 #endif /* USDT2 */
4605 #ifndef USDT2
4606 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
4607 #else /* USDT2 */
4608 HOTSPOT_JNI_GETVERSION_RETURN(
4609 CurrentVersion);
4610 #endif /* USDT2 */
3446 return CurrentVersion; 4611 return CurrentVersion;
3447 JNI_END 4612 JNI_END
3448 4613
3449 extern struct JavaVM_ main_vm; 4614 extern struct JavaVM_ main_vm;
3450 4615
3451 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) 4616 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
3452 JNIWrapper("jni_GetJavaVM"); 4617 JNIWrapper("jni_GetJavaVM");
3453 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm); 4618 #ifndef USDT2
4619 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm);
4620 #else /* USDT2 */
4621 HOTSPOT_JNI_GETJAVAVM_ENTRY(
4622 env, (void **) vm);
4623 #endif /* USDT2 */
3454 *vm = (JavaVM *)(&main_vm); 4624 *vm = (JavaVM *)(&main_vm);
3455 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK); 4625 #ifndef USDT2
4626 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK);
4627 #else /* USDT2 */
4628 HOTSPOT_JNI_GETJAVAVM_RETURN(
4629 JNI_OK);
4630 #endif /* USDT2 */
3456 return JNI_OK; 4631 return JNI_OK;
3457 JNI_END 4632 JNI_END
3458 4633
3459 // Structure containing all jni functions 4634 // Structure containing all jni functions
3460 struct JNINativeInterface_ jni_NativeInterface = { 4635 struct JNINativeInterface_ jni_NativeInterface = {
3828 5003
3829 5004
3830 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */ 5005 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */
3831 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL }; 5006 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
3832 5007
5008 #ifndef USDT2
5009 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*);
5010 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint);
5011 #else /* USDT2 */
3833 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint 5012 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
3834 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref)); 5013 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
5014 #endif /* USDT2 */
3835 5015
3836 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) { 5016 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
3837 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_); 5017 #ifndef USDT2
5018 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_);
5019 #else /* USDT2 */
5020 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(
5021 args_);
5022 #endif /* USDT2 */
3838 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_; 5023 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
3839 jint ret = JNI_ERR; 5024 jint ret = JNI_ERR;
3840 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret); 5025 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
3841 5026
3842 if (Threads::is_supported_jni_version(args->version)) { 5027 if (Threads::is_supported_jni_version(args->version)) {
3877 void TestReserveMemorySpecial_test(); 5062 void TestReserveMemorySpecial_test();
3878 void TestVirtualSpace_test(); 5063 void TestVirtualSpace_test();
3879 void TestMetaspaceAux_test(); 5064 void TestMetaspaceAux_test();
3880 void TestMetachunk_test(); 5065 void TestMetachunk_test();
3881 void TestVirtualSpaceNode_test(); 5066 void TestVirtualSpaceNode_test();
3882 void TestNewSize_test();
3883 void TestKlass_test();
3884 #if INCLUDE_ALL_GCS 5067 #if INCLUDE_ALL_GCS
3885 void TestOldFreeSpaceCalculation_test();
3886 void TestG1BiasedArray_test(); 5068 void TestG1BiasedArray_test();
3887 void TestBufferingOopClosure_test();
3888 #endif 5069 #endif
3889 5070
3890 void execute_internal_vm_tests() { 5071 void execute_internal_vm_tests() {
3891 if (ExecuteInternalVMTests) { 5072 if (ExecuteInternalVMTests) {
3892 tty->print_cr("Running internal VM tests"); 5073 tty->print_cr("Running internal VM tests");
3901 run_unit_test(arrayOopDesc::test_max_array_length()); 5082 run_unit_test(arrayOopDesc::test_max_array_length());
3902 run_unit_test(CollectedHeap::test_is_in()); 5083 run_unit_test(CollectedHeap::test_is_in());
3903 run_unit_test(QuickSort::test_quick_sort()); 5084 run_unit_test(QuickSort::test_quick_sort());
3904 run_unit_test(AltHashing::test_alt_hash()); 5085 run_unit_test(AltHashing::test_alt_hash());
3905 run_unit_test(test_loggc_filename()); 5086 run_unit_test(test_loggc_filename());
3906 run_unit_test(TestNewSize_test());
3907 run_unit_test(TestKlass_test());
3908 #if INCLUDE_VM_STRUCTS 5087 #if INCLUDE_VM_STRUCTS
3909 run_unit_test(VMStructs::test()); 5088 run_unit_test(VMStructs::test());
3910 #endif 5089 #endif
3911 #if INCLUDE_ALL_GCS 5090 #if INCLUDE_ALL_GCS
3912 run_unit_test(TestOldFreeSpaceCalculation_test());
3913 run_unit_test(TestG1BiasedArray_test()); 5091 run_unit_test(TestG1BiasedArray_test());
3914 run_unit_test(HeapRegionRemSet::test_prt()); 5092 run_unit_test(HeapRegionRemSet::test_prt());
3915 run_unit_test(TestBufferingOopClosure_test());
3916 #endif 5093 #endif
3917 tty->print_cr("All internal VM tests passed"); 5094 tty->print_cr("All internal VM tests passed");
3918 } 5095 }
3919 } 5096 }
3920 5097
3921 #undef run_unit_test 5098 #undef run_unit_test
3922 5099
3923 #endif 5100 #endif
3924 5101
5102 #ifndef USDT2
5103 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5104 DT_RETURN_MARK_DECL(CreateJavaVM, jint);
5105 #else /* USDT2 */
3925 DT_RETURN_MARK_DECL(CreateJavaVM, jint 5106 DT_RETURN_MARK_DECL(CreateJavaVM, jint
3926 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref)); 5107 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
5108 #endif /* USDT2 */
3927 5109
3928 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) { 5110 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
3929 HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args); 5111 #ifndef USDT2
5112 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5113 #else /* USDT2 */
5114 HOTSPOT_JNI_CREATEJAVAVM_ENTRY(
5115 (void **) vm, penv, args);
5116 #endif /* USDT2 */
3930 5117
3931 jint result = JNI_ERR; 5118 jint result = JNI_ERR;
3932 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result); 5119 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
3933 5120
3934 // We're about to use Atomic::xchg for synchronization. Some Zero 5121 // We're about to use Atomic::xchg for synchronization. Some Zero
3980 bool can_try_again = true; 5167 bool can_try_again = true;
3981 5168
3982 result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again); 5169 result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again);
3983 if (result == JNI_OK) { 5170 if (result == JNI_OK) {
3984 JavaThread *thread = JavaThread::current(); 5171 JavaThread *thread = JavaThread::current();
3985 assert(!thread->has_pending_exception(), "should have returned not OK");
3986 /* thread is thread_in_vm here */ 5172 /* thread is thread_in_vm here */
3987 *vm = (JavaVM *)(&main_vm); 5173 *vm = (JavaVM *)(&main_vm);
3988 *(JNIEnv**)penv = thread->jni_environment(); 5174 *(JNIEnv**)penv = thread->jni_environment();
3989 5175
3990 #ifdef GRAAL 5176 #ifdef GRAAL
4027 #endif 5213 #endif
4028 5214
4029 // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving. 5215 // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
4030 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native); 5216 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
4031 } else { 5217 } else {
4032 // If create_vm exits because of a pending exception, exit with that
4033 // exception. In the future when we figure out how to reclaim memory,
4034 // we may be able to exit with JNI_ERR and allow the calling application
4035 // to continue.
4036 if (Universe::is_fully_initialized()) {
4037 // otherwise no pending exception possible - VM will already have aborted
4038 JavaThread* THREAD = JavaThread::current();
4039 if (HAS_PENDING_EXCEPTION) {
4040 HandleMark hm;
4041 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
4042 }
4043 }
4044
4045 if (can_try_again) { 5218 if (can_try_again) {
4046 // reset safe_to_recreate_vm to 1 so that retrial would be possible 5219 // reset safe_to_recreate_vm to 1 so that retrial would be possible
4047 safe_to_recreate_vm = 1; 5220 safe_to_recreate_vm = 1;
4048 } 5221 }
4049 5222
4056 } 5229 }
4057 5230
4058 return result; 5231 return result;
4059 } 5232 }
4060 5233
5234 #ifndef USDT2
5235 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \
5236 JavaVM**, jsize, jsize*);
5237 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint);
5238 #endif /* !USDT2 */
4061 5239
4062 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { 5240 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
4063 // See bug 4367188, the wrapper can sometimes cause VM crashes 5241 // See bug 4367188, the wrapper can sometimes cause VM crashes
4064 // JNIWrapper("GetCreatedJavaVMs"); 5242 // JNIWrapper("GetCreatedJavaVMs");
4065 5243 #ifndef USDT2
4066 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs); 5244 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
4067 5245 vm_buf, bufLen, numVMs);
5246 #else /* USDT2 */
5247 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY(
5248 (void **) vm_buf, bufLen, (uintptr_t *) numVMs);
5249 #endif /* USDT2 */
4068 if (vm_created) { 5250 if (vm_created) {
4069 if (numVMs != NULL) *numVMs = 1; 5251 if (numVMs != NULL) *numVMs = 1;
4070 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); 5252 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
4071 } else { 5253 } else {
4072 if (numVMs != NULL) *numVMs = 0; 5254 if (numVMs != NULL) *numVMs = 0;
4073 } 5255 }
4074 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK); 5256 #ifndef USDT2
5257 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK);
5258 #else /* USDT2 */
5259 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(
5260 JNI_OK);
5261 #endif /* USDT2 */
4075 return JNI_OK; 5262 return JNI_OK;
4076 } 5263 }
4077 5264
4078 extern "C" { 5265 extern "C" {
4079 5266
5267 #ifndef USDT2
5268 DT_RETURN_MARK_DECL(DestroyJavaVM, jint);
5269 #else /* USDT2 */
4080 DT_RETURN_MARK_DECL(DestroyJavaVM, jint 5270 DT_RETURN_MARK_DECL(DestroyJavaVM, jint
4081 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref)); 5271 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
5272 #endif /* USDT2 */
4082 5273
4083 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { 5274 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
4084 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm); 5275 #ifndef USDT2
5276 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
5277 #else /* USDT2 */
5278 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(
5279 vm);
5280 #endif /* USDT2 */
4085 jint res = JNI_ERR; 5281 jint res = JNI_ERR;
4086 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); 5282 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
4087 5283
4088 if (!vm_created) { 5284 if (!vm_created) {
4089 res = JNI_ERR; 5285 res = JNI_ERR;
4231 return JNI_OK; 5427 return JNI_OK;
4232 } 5428 }
4233 5429
4234 5430
4235 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { 5431 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
4236 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args); 5432 #ifndef USDT2
5433 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args);
5434 #else /* USDT2 */
5435 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(
5436 vm, penv, _args);
5437 #endif /* USDT2 */
4237 if (!vm_created) { 5438 if (!vm_created) {
4238 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); 5439 #ifndef USDT2
5440 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
5441 #else /* USDT2 */
5442 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(
5443 (uint32_t) JNI_ERR);
5444 #endif /* USDT2 */
4239 return JNI_ERR; 5445 return JNI_ERR;
4240 } 5446 }
4241 5447
4242 JNIWrapper("AttachCurrentThread"); 5448 JNIWrapper("AttachCurrentThread");
4243 jint ret = attach_current_thread(vm, penv, _args, false); 5449 jint ret = attach_current_thread(vm, penv, _args, false);
4244 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret); 5450 #ifndef USDT2
5451 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret);
5452 #else /* USDT2 */
5453 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(
5454 ret);
5455 #endif /* USDT2 */
4245 return ret; 5456 return ret;
4246 } 5457 }
4247 5458
4248 5459
4249 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { 5460 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
4250 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm); 5461 #ifndef USDT2
5462 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm);
5463 #else /* USDT2 */
5464 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(
5465 vm);
5466 #endif /* USDT2 */
4251 VM_Exit::block_if_vm_exited(); 5467 VM_Exit::block_if_vm_exited();
4252 5468
4253 JNIWrapper("DetachCurrentThread"); 5469 JNIWrapper("DetachCurrentThread");
4254 5470
4255 // If the thread has been deattacted the operations is a no-op 5471 // If the thread has been deattacted the operations is a no-op
4256 if (ThreadLocalStorage::thread() == NULL) { 5472 if (ThreadLocalStorage::thread() == NULL) {
4257 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK); 5473 #ifndef USDT2
5474 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5475 #else /* USDT2 */
5476 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
5477 JNI_OK);
5478 #endif /* USDT2 */
4258 return JNI_OK; 5479 return JNI_OK;
4259 } 5480 }
4260 5481
4261 JavaThread* thread = JavaThread::current(); 5482 JavaThread* thread = JavaThread::current();
4262 if (thread->has_last_Java_frame()) { 5483 if (thread->has_last_Java_frame()) {
4263 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); 5484 #ifndef USDT2
5485 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR);
5486 #else /* USDT2 */
5487 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
5488 (uint32_t) JNI_ERR);
5489 #endif /* USDT2 */
4264 // Can't detach a thread that's running java, that can't work. 5490 // Can't detach a thread that's running java, that can't work.
4265 return JNI_ERR; 5491 return JNI_ERR;
4266 } 5492 }
4267 5493
4268 // Safepoint support. Have to do call-back to safepoint code, if in the 5494 // Safepoint support. Have to do call-back to safepoint code, if in the
4279 // (platform-dependent) methods where we do alternate stack 5505 // (platform-dependent) methods where we do alternate stack
4280 // maintenance work?) 5506 // maintenance work?)
4281 thread->exit(false, JavaThread::jni_detach); 5507 thread->exit(false, JavaThread::jni_detach);
4282 delete thread; 5508 delete thread;
4283 5509
4284 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK); 5510 #ifndef USDT2
5511 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5512 #else /* USDT2 */
5513 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
5514 JNI_OK);
5515 #endif /* USDT2 */
4285 return JNI_OK; 5516 return JNI_OK;
4286 } 5517 }
4287 5518
5519 #ifndef USDT2
5520 DT_RETURN_MARK_DECL(GetEnv, jint);
5521 #else /* USDT2 */
4288 DT_RETURN_MARK_DECL(GetEnv, jint 5522 DT_RETURN_MARK_DECL(GetEnv, jint
4289 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref)); 5523 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
5524 #endif /* USDT2 */
4290 5525
4291 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) { 5526 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
4292 HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version); 5527 #ifndef USDT2
5528 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version);
5529 #else /* USDT2 */
5530 HOTSPOT_JNI_GETENV_ENTRY(
5531 vm, penv, version);
5532 #endif /* USDT2 */
4293 jint ret = JNI_ERR; 5533 jint ret = JNI_ERR;
4294 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret); 5534 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
4295 5535
4296 if (!vm_created) { 5536 if (!vm_created) {
4297 *penv = NULL; 5537 *penv = NULL;
4341 } 5581 }
4342 } 5582 }
4343 5583
4344 5584
4345 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) { 5585 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
4346 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args); 5586 #ifndef USDT2
5587 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args);
5588 #else /* USDT2 */
5589 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(
5590 vm, penv, _args);
5591 #endif /* USDT2 */
4347 if (!vm_created) { 5592 if (!vm_created) {
4348 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR); 5593 #ifndef USDT2
5594 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
5595 #else /* USDT2 */
5596 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(
5597 (uint32_t) JNI_ERR);
5598 #endif /* USDT2 */
4349 return JNI_ERR; 5599 return JNI_ERR;
4350 } 5600 }
4351 5601
4352 JNIWrapper("AttachCurrentThreadAsDaemon"); 5602 JNIWrapper("AttachCurrentThreadAsDaemon");
4353 jint ret = attach_current_thread(vm, penv, _args, true); 5603 jint ret = attach_current_thread(vm, penv, _args, true);
4354 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret); 5604 #ifndef USDT2
5605 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret);
5606 #else /* USDT2 */
5607 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(
5608 ret);
5609 #endif /* USDT2 */
4355 return ret; 5610 return ret;
4356 } 5611 }
4357 5612
4358 5613
4359 } // End extern "C" 5614 } // End extern "C"