Mercurial > hg > graal-compiler

comparison src/share/vm/prims/jni.cpp @ 14518:d8041d695d19

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