1 /*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2012 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
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
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "ci/ciReplay.hpp"
28 #include "classfile/altHashing.hpp"
29 #include "classfile/classLoader.hpp"
30 #include "classfile/javaClasses.hpp"
31 #include "classfile/symbolTable.hpp"
32 #include "classfile/systemDictionary.hpp"
33 #include "classfile/vmSymbols.hpp"
34 #include "interpreter/linkResolver.hpp"
35 #include "utilities/macros.hpp"
36 #if INCLUDE_ALL_GCS
37 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
38 #endif // INCLUDE_ALL_GCS
39 #include "memory/allocation.hpp"
40 #include "memory/allocation.inline.hpp"
41 #include "memory/gcLocker.inline.hpp"
42 #include "memory/oopFactory.hpp"
43 #include "memory/universe.inline.hpp"
44 #include "oops/instanceKlass.hpp"
45 #include "oops/instanceOop.hpp"
46 #include "oops/markOop.hpp"
47 #include "oops/method.hpp"
48 #include "oops/objArrayKlass.hpp"
49 #include "oops/objArrayOop.hpp"
50 #include "oops/oop.inline.hpp"
51 #include "oops/symbol.hpp"
52 #include "oops/typeArrayKlass.hpp"
53 #include "oops/typeArrayOop.hpp"
54 #include "prims/jni.h"
55 #include "prims/jniCheck.hpp"
56 #include "prims/jniExport.hpp"
57 #include "prims/jniFastGetField.hpp"
58 #include "prims/jvm.h"
59 #include "prims/jvm_misc.hpp"
60 #include "prims/jvmtiExport.hpp"
61 #include "prims/jvmtiThreadState.hpp"
62 #include "runtime/compilationPolicy.hpp"
63 #include "runtime/fieldDescriptor.hpp"
64 #include "runtime/fprofiler.hpp"
65 #include "runtime/handles.inline.hpp"
66 #include "runtime/interfaceSupport.hpp"
67 #include "runtime/java.hpp"
68 #include "runtime/javaCalls.hpp"
69 #include "runtime/jfieldIDWorkaround.hpp"
70 #include "runtime/orderAccess.inline.hpp"
71 #include "runtime/reflection.hpp"
72 #include "runtime/sharedRuntime.hpp"
73 #include "runtime/signature.hpp"
74 #include "runtime/thread.inline.hpp"
75 #include "runtime/vm_operations.hpp"
76 #include "services/memTracker.hpp"
77 #include "services/runtimeService.hpp"
78 #include "trace/tracing.hpp"
79 #include "evtrace/traceEvents.hpp"
80 #include "utilities/defaultStream.hpp"
81 #include "utilities/dtrace.hpp"
82 #include "utilities/events.hpp"
83 #include "utilities/histogram.hpp"
84 #ifdef TARGET_OS_FAMILY_linux
85 # include "os_linux.inline.hpp"
86 #endif
87 #ifdef TARGET_OS_FAMILY_solaris
88 # include "os_solaris.inline.hpp"
89 #endif
90 #ifdef TARGET_OS_FAMILY_windows
91 # include "os_windows.inline.hpp"
92 #endif
93 #ifdef TARGET_OS_FAMILY_bsd
94 # include "os_bsd.inline.hpp"
95 #endif
96
97 static jint CurrentVersion = JNI_VERSION_1_8;
98
99
100 // The DT_RETURN_MARK macros create a scoped object to fire the dtrace
101 // '-return' probe regardless of the return path is taken out of the function.
102 // Methods that have multiple return paths use this to avoid having to
103 // instrument each return path. Methods that use CHECK or THROW must use this
104 // since those macros can cause an immedate uninstrumented return.
105 //
106 // In order to get the return value, a reference to the variable containing
107 // the return value must be passed to the contructor of the object, and
108 // the return value must be set before return (since the mark object has
109 // a reference to it).
110 //
111 // Example:
112 // DT_RETURN_MARK_DECL(SomeFunc, int);
113 // JNI_ENTRY(int, SomeFunc, ...)
114 // int return_value = 0;
115 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
116 // foo(CHECK_0)
117 // return_value = 5;
118 // return return_value;
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) \
148 DTRACE_ONLY( \
149 class DTraceReturnProbeMark_##name { \
150 public: \
151 const type& _ret_ref; \
152 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \
153 ~DTraceReturnProbeMark_##name() { \
154 probe; \
155 } \
156 } \
157 )
158 // Void functions are simpler since there's no return value
159 #define DT_VOID_RETURN_MARK_DECL(name, probe) \
160 DTRACE_ONLY( \
161 class DTraceReturnProbeMark_##name { \
162 public: \
163 ~DTraceReturnProbeMark_##name() { \
164 probe; \
165 } \
166 } \
167 )
168 #endif /* USDT2 */
169
170 // Place these macros in the function to mark the return. Non-void
171 // functions need the type and address of the return value.
172 #define DT_RETURN_MARK(name, type, ref) \
173 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
174 #define DT_VOID_RETURN_MARK(name) \
175 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark )
176
177
178 // Use these to select distinct code for floating-point vs. non-floating point
179 // situations. Used from within common macros where we need slightly
180 // different behavior for Float/Double
181 #define FP_SELECT_Boolean(intcode, fpcode) intcode
182 #define FP_SELECT_Byte(intcode, fpcode) intcode
183 #define FP_SELECT_Char(intcode, fpcode) intcode
184 #define FP_SELECT_Short(intcode, fpcode) intcode
185 #define FP_SELECT_Object(intcode, fpcode) intcode
186 #define FP_SELECT_Int(intcode, fpcode) intcode
187 #define FP_SELECT_Long(intcode, fpcode) intcode
188 #define FP_SELECT_Float(intcode, fpcode) fpcode
189 #define FP_SELECT_Double(intcode, fpcode) fpcode
190 #define FP_SELECT(TypeName, intcode, fpcode) \
191 FP_SELECT_##TypeName(intcode, fpcode)
192
193 #define COMMA ,
194
195 // Choose DT_RETURN_MARK macros based on the type: float/double -> void
196 // (dtrace doesn't do FP yet)
197 #ifndef USDT2
198 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \
199 FP_SELECT(TypeName, \
200 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) )
201 #else /* USDT2 */
202 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \
203 FP_SELECT(TypeName, \
204 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) \
207 FP_SELECT(TypeName, \
208 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
209
210
211 // out-of-line helpers for class jfieldIDWorkaround:
212
213 bool jfieldIDWorkaround::is_valid_jfieldID(Klass* k, jfieldID id) {
214 if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) {
215 uintptr_t as_uint = (uintptr_t) id;
216 intptr_t offset = raw_instance_offset(id);
217 if (is_checked_jfieldID(id)) {
218 if (!klass_hash_ok(k, id)) {
219 return false;
220 }
221 }
222 return InstanceKlass::cast(k)->contains_field_offset(offset);
223 } else {
224 JNIid* result = (JNIid*) id;
225 #ifdef ASSERT
226 return result != NULL && result->is_static_field_id();
227 #else
228 return result != NULL;
229 #endif
230 }
231 }
232
233
234 intptr_t jfieldIDWorkaround::encode_klass_hash(Klass* k, intptr_t offset) {
235 if (offset <= small_offset_mask) {
236 Klass* field_klass = k;
237 Klass* super_klass = field_klass->super();
238 // With compressed oops the most super class with nonstatic fields would
239 // be the owner of fields embedded in the header.
240 while (InstanceKlass::cast(super_klass)->has_nonstatic_fields() &&
241 InstanceKlass::cast(super_klass)->contains_field_offset(offset)) {
242 field_klass = super_klass; // super contains the field also
243 super_klass = field_klass->super();
244 }
245 debug_only(No_Safepoint_Verifier nosafepoint;)
246 uintptr_t klass_hash = field_klass->identity_hash();
247 return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place;
248 } else {
249 #if 0
250 #ifndef PRODUCT
251 {
252 ResourceMark rm;
253 warning("VerifyJNIFields: long offset %d in %s", offset, k->external_name());
254 }
255 #endif
256 #endif
257 return 0;
258 }
259 }
260
261 bool jfieldIDWorkaround::klass_hash_ok(Klass* k, jfieldID id) {
262 uintptr_t as_uint = (uintptr_t) id;
263 intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask;
264 do {
265 debug_only(No_Safepoint_Verifier nosafepoint;)
266 // Could use a non-blocking query for identity_hash here...
267 if ((k->identity_hash() & klass_mask) == klass_hash)
268 return true;
269 k = k->super();
270 } while (k != NULL);
271 return false;
272 }
273
274 void jfieldIDWorkaround::verify_instance_jfieldID(Klass* k, jfieldID id) {
275 guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" );
276 uintptr_t as_uint = (uintptr_t) id;
277 intptr_t offset = raw_instance_offset(id);
278 if (VerifyJNIFields) {
279 if (is_checked_jfieldID(id)) {
280 guarantee(klass_hash_ok(k, id),
281 "Bug in native code: jfieldID class must match object");
282 } else {
283 #if 0
284 #ifndef PRODUCT
285 if (Verbose) {
286 ResourceMark rm;
287 warning("VerifyJNIFields: unverified offset %d for %s", offset, k->external_name());
288 }
289 #endif
290 #endif
291 }
292 }
293 guarantee(InstanceKlass::cast(k)->contains_field_offset(offset),
294 "Bug in native code: jfieldID offset must address interior of object");
295 }
296
297 // Wrapper to trace JNI functions
298
299 #ifdef ASSERT
300 Histogram* JNIHistogram;
301 static volatile jint JNIHistogram_lock = 0;
302
303 class JNITraceWrapper : public StackObj {
304 public:
305 JNITraceWrapper(const char* format, ...) ATTRIBUTE_PRINTF(2, 3) {
306 if (TraceJNICalls) {
307 va_list ap;
308 va_start(ap, format);
309 tty->print("JNI ");
310 tty->vprint_cr(format, ap);
311 va_end(ap);
312 }
313 }
314 };
315
316 class JNIHistogramElement : public HistogramElement {
317 public:
318 JNIHistogramElement(const char* name);
319 };
320
321 JNIHistogramElement::JNIHistogramElement(const char* elementName) {
322 _name = elementName;
323 uintx count = 0;
324
325 while (Atomic::cmpxchg(1, &JNIHistogram_lock, 0) != 0) {
326 while (OrderAccess::load_acquire(&JNIHistogram_lock) != 0) {
327 count +=1;
328 if ( (WarnOnStalledSpinLock > 0)
329 && (count % WarnOnStalledSpinLock == 0)) {
330 warning("JNIHistogram_lock seems to be stalled");
331 }
332 }
333 }
334
335
336 if(JNIHistogram == NULL)
337 JNIHistogram = new Histogram("JNI Call Counts",100);
338
339 JNIHistogram->add_element(this);
340 Atomic::dec(&JNIHistogram_lock);
341 }
342
343 #define JNICountWrapper(arg) \
344 static JNIHistogramElement* e = new JNIHistogramElement(arg); \
345 /* There is a MT-race condition in VC++. So we need to make sure that that e has been initialized */ \
346 if (e != NULL) e->increment_count()
347 #define JNIWrapper(arg) JNICountWrapper(arg); JNITraceWrapper(arg)
348 #else
349 #define JNIWrapper(arg)
350 #endif
351
352
353 // Implementation of JNI entries
354
355 #ifndef USDT2
356 DT_RETURN_MARK_DECL(DefineClass, jclass);
357 #else /* USDT2 */
358 DT_RETURN_MARK_DECL(DefineClass, jclass
359 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
360 #endif /* USDT2 */
361
362 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
363 const jbyte *buf, jsize bufLen))
364 JNIWrapper("DefineClass");
365
366 #ifndef USDT2
367 DTRACE_PROBE5(hotspot_jni, DefineClass__entry,
368 env, name, loaderRef, buf, bufLen);
369 #else /* USDT2 */
370 HOTSPOT_JNI_DEFINECLASS_ENTRY(
371 env, (char*) name, loaderRef, (char*) buf, bufLen);
372 #endif /* USDT2 */
373 jclass cls = NULL;
374 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
375
376 TempNewSymbol class_name = NULL;
377 // Since exceptions can be thrown, class initialization can take place
378 // if name is NULL no check for class name in .class stream has to be made.
379 if (name != NULL) {
380 const int str_len = (int)strlen(name);
381 if (str_len > Symbol::max_length()) {
382 // It's impossible to create this class; the name cannot fit
383 // into the constant pool.
384 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
385 }
386 class_name = SymbolTable::new_symbol(name, CHECK_NULL);
387 }
388 ResourceMark rm(THREAD);
389 ClassFileStream st((u1*) buf, bufLen, NULL);
390 Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));
391
392 if (UsePerfData && !class_loader.is_null()) {
393 // check whether the current caller thread holds the lock or not.
394 // If not, increment the corresponding counter
395 if (ObjectSynchronizer::
396 query_lock_ownership((JavaThread*)THREAD, class_loader) !=
397 ObjectSynchronizer::owner_self) {
398 ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();
399 }
400 }
401 Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader,
402 Handle(), &st, true,
403 CHECK_NULL);
404
405 if (TraceClassResolution && k != NULL) {
406 trace_class_resolution(k);
407 }
408
409 cls = (jclass)JNIHandles::make_local(
410 env, k->java_mirror());
411 return cls;
412 JNI_END
413
414
415
416 static bool first_time_FindClass = true;
417
418 #ifndef USDT2
419 DT_RETURN_MARK_DECL(FindClass, jclass);
420 #else /* USDT2 */
421 DT_RETURN_MARK_DECL(FindClass, jclass
422 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
423 #endif /* USDT2 */
424
425 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
426 JNIWrapper("FindClass");
427 #ifndef USDT2
428 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);
429 #else /* USDT2 */
430 HOTSPOT_JNI_FINDCLASS_ENTRY(
431 env, (char *)name);
432 #endif /* USDT2 */
433
434 jclass result = NULL;
435 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
436
437 // Remember if we are the first invocation of jni_FindClass
438 bool first_time = first_time_FindClass;
439 first_time_FindClass = false;
440
441 // Sanity check the name: it cannot be null or larger than the maximum size
442 // name we can fit in the constant pool.
443 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
444 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
445 }
446
447 //%note jni_3
448 Handle loader;
449 Handle protection_domain;
450 // Find calling class
451 instanceKlassHandle k (THREAD, thread->security_get_caller_class(0));
452 if (k.not_null()) {
453 loader = Handle(THREAD, k->class_loader());
454 // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
455 // in the correct class context.
456 if (loader.is_null() &&
457 k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
458 JavaValue result(T_OBJECT);
459 JavaCalls::call_static(&result, k,
460 vmSymbols::getFromClass_name(),
461 vmSymbols::void_class_signature(),
462 thread);
463 if (HAS_PENDING_EXCEPTION) {
464 Handle ex(thread, thread->pending_exception());
465 CLEAR_PENDING_EXCEPTION;
466 THROW_HANDLE_0(ex);
467 }
468 oop mirror = (oop) result.get_jobject();
469 loader = Handle(THREAD,
470 InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->class_loader());
471 protection_domain = Handle(THREAD,
472 InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->protection_domain());
473 }
474 } else {
475 // We call ClassLoader.getSystemClassLoader to obtain the system class loader.
476 loader = Handle(THREAD, SystemDictionary::java_system_loader());
477 }
478
479 TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
480 result = find_class_from_class_loader(env, sym, true, loader,
481 protection_domain, true, thread);
482
483 if (TraceClassResolution && result != NULL) {
484 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
485 }
486
487 // If we were the first invocation of jni_FindClass, we enable compilation again
488 // rather than just allowing invocation counter to overflow and decay.
489 // Controlled by flag DelayCompilationDuringStartup.
490 if (first_time && !CompileTheWorld)
491 CompilationPolicy::completed_vm_startup();
492
493 return result;
494 JNI_END
495
496 #ifndef USDT2
497 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID);
498 #else /* USDT2 */
499 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
500 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
501 #endif /* USDT2 */
502
503 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
504 JNIWrapper("FromReflectedMethod");
505 #ifndef USDT2
506 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method);
507 #else /* USDT2 */
508 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(
509 env, method);
510 #endif /* USDT2 */
511 jmethodID ret = NULL;
512 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
513
514 // method is a handle to a java.lang.reflect.Method object
515 oop reflected = JNIHandles::resolve_non_null(method);
516 oop mirror = NULL;
517 int slot = 0;
518
519 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
520 mirror = java_lang_reflect_Constructor::clazz(reflected);
521 slot = java_lang_reflect_Constructor::slot(reflected);
522 } else {
523 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
524 mirror = java_lang_reflect_Method::clazz(reflected);
525 slot = java_lang_reflect_Method::slot(reflected);
526 }
527 Klass* k = java_lang_Class::as_Klass(mirror);
528
529 KlassHandle k1(THREAD, k);
530 // Make sure class is initialized before handing id's out to methods
531 k1()->initialize(CHECK_NULL);
532 Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot);
533 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
534 return ret;
535 JNI_END
536
537 #ifndef USDT2
538 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID);
539 #else /* USDT2 */
540 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
541 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
542 #endif /* USDT2 */
543
544 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
545 JNIWrapper("FromReflectedField");
546 #ifndef USDT2
547 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field);
548 #else /* USDT2 */
549 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(
550 env, field);
551 #endif /* USDT2 */
552 jfieldID ret = NULL;
553 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
554
555 // field is a handle to a java.lang.reflect.Field object
556 oop reflected = JNIHandles::resolve_non_null(field);
557 oop mirror = java_lang_reflect_Field::clazz(reflected);
558 Klass* k = java_lang_Class::as_Klass(mirror);
559 int slot = java_lang_reflect_Field::slot(reflected);
560 int modifiers = java_lang_reflect_Field::modifiers(reflected);
561
562 KlassHandle k1(THREAD, k);
563 // Make sure class is initialized before handing id's out to fields
564 k1()->initialize(CHECK_NULL);
565
566 // First check if this is a static field
567 if (modifiers & JVM_ACC_STATIC) {
568 intptr_t offset = InstanceKlass::cast(k1())->field_offset( slot );
569 JNIid* id = InstanceKlass::cast(k1())->jni_id_for(offset);
570 assert(id != NULL, "corrupt Field object");
571 debug_only(id->set_is_static_field_id();)
572 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
573 ret = jfieldIDWorkaround::to_static_jfieldID(id);
574 return ret;
575 }
576
577 // The slot is the index of the field description in the field-array
578 // The jfieldID is the offset of the field within the object
579 // It may also have hash bits for k, if VerifyJNIFields is turned on.
580 intptr_t offset = InstanceKlass::cast(k1())->field_offset( slot );
581 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
582 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
583 return ret;
584 JNI_END
585
586 #ifndef USDT2
587 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject);
588 #else /* USDT2 */
589 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
590 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
591 #endif /* USDT2 */
592
593 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
594 JNIWrapper("ToReflectedMethod");
595 #ifndef USDT2
596 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);
597 #else /* USDT2 */
598 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(
599 env, cls, (uintptr_t) method_id, isStatic);
600 #endif /* USDT2 */
601 jobject ret = NULL;
602 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
603
604 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
605 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
606 oop reflection_method;
607 if (m->is_initializer()) {
608 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
609 } else {
610 reflection_method = Reflection::new_method(m, UseNewReflection, false, CHECK_NULL);
611 }
612 ret = JNIHandles::make_local(env, reflection_method);
613 return ret;
614 JNI_END
615
616 #ifndef USDT2
617 DT_RETURN_MARK_DECL(GetSuperclass, jclass);
618 #else /* USDT2 */
619 DT_RETURN_MARK_DECL(GetSuperclass, jclass
620 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
621 #endif /* USDT2 */
622
623 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
624 JNIWrapper("GetSuperclass");
625 #ifndef USDT2
626 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub);
627 #else /* USDT2 */
628 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(
629 env, sub);
630 #endif /* USDT2 */
631 jclass obj = NULL;
632 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
633
634 oop mirror = JNIHandles::resolve_non_null(sub);
635 // primitive classes return NULL
636 if (java_lang_Class::is_primitive(mirror)) return NULL;
637
638 // Rules of Class.getSuperClass as implemented by KLass::java_super:
639 // arrays return Object
640 // interfaces return NULL
641 // proper classes return Klass::super()
642 Klass* k = java_lang_Class::as_Klass(mirror);
643 if (k->is_interface()) return NULL;
644
645 // return mirror for superclass
646 Klass* super = k->java_super();
647 // super2 is the value computed by the compiler's getSuperClass intrinsic:
648 debug_only(Klass* super2 = ( k->oop_is_array()
649 ? SystemDictionary::Object_klass()
650 : k->super() ) );
651 assert(super == super2,
652 "java_super computation depends on interface, array, other super");
653 obj = (super == NULL) ? NULL : (jclass) JNIHandles::make_local(super->java_mirror());
654 return obj;
655 JNI_END
656
657 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
658 JNIWrapper("IsSubclassOf");
659 #ifndef USDT2
660 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super);
661 #else /* USDT2 */
662 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(
663 env, sub, super);
664 #endif /* USDT2 */
665 oop sub_mirror = JNIHandles::resolve_non_null(sub);
666 oop super_mirror = JNIHandles::resolve_non_null(super);
667 if (java_lang_Class::is_primitive(sub_mirror) ||
668 java_lang_Class::is_primitive(super_mirror)) {
669 jboolean ret = (sub_mirror == super_mirror);
670 #ifndef USDT2
671 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
672 #else /* USDT2 */
673 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(
674 ret);
675 #endif /* USDT2 */
676 return ret;
677 }
678 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
679 Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
680 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
681 jboolean ret = sub_klass->is_subtype_of(super_klass) ?
682 JNI_TRUE : JNI_FALSE;
683 #ifndef USDT2
684 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
685 #else /* USDT2 */
686 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(
687 ret);
688 #endif /* USDT2 */
689 return ret;
690 JNI_END
691
692 #ifndef USDT2
693 DT_RETURN_MARK_DECL(Throw, jint);
694 #else /* USDT2 */
695 DT_RETURN_MARK_DECL(Throw, jint
696 , HOTSPOT_JNI_THROW_RETURN(_ret_ref));
697 #endif /* USDT2 */
698
699 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
700 JNIWrapper("Throw");
701 #ifndef USDT2
702 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj);
703 #else /* USDT2 */
704 HOTSPOT_JNI_THROW_ENTRY(
705 env, obj);
706 #endif /* USDT2 */
707 jint ret = JNI_OK;
708 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
709
710 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
711 ShouldNotReachHere();
712 JNI_END
713
714 #ifndef USDT2
715 DT_RETURN_MARK_DECL(ThrowNew, jint);
716 #else /* USDT2 */
717 DT_RETURN_MARK_DECL(ThrowNew, jint
718 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
719 #endif /* USDT2 */
720
721 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
722 JNIWrapper("ThrowNew");
723 #ifndef USDT2
724 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
725 #else /* USDT2 */
726 HOTSPOT_JNI_THROWNEW_ENTRY(
727 env, clazz, (char *) message);
728 #endif /* USDT2 */
729 jint ret = JNI_OK;
730 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
731
732 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
733 Symbol* name = k->name();
734 Handle class_loader (THREAD, k->class_loader());
735 Handle protection_domain (THREAD, k->protection_domain());
736 THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK);
737 ShouldNotReachHere();
738 JNI_END
739
740
741 // JNI functions only transform a pending async exception to a synchronous
742 // exception in ExceptionOccurred and ExceptionCheck calls, since
743 // delivering an async exception in other places won't change the native
744 // code's control flow and would be harmful when native code further calls
745 // JNI functions with a pending exception. Async exception is also checked
746 // during the call, so ExceptionOccurred/ExceptionCheck won't return
747 // false but deliver the async exception at the very end during
748 // state transition.
749
750 static void jni_check_async_exceptions(JavaThread *thread) {
751 assert(thread == Thread::current(), "must be itself");
752 thread->check_and_handle_async_exceptions();
753 }
754
755 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
756 JNIWrapper("ExceptionOccurred");
757 #ifndef USDT2
758 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env);
759 #else /* USDT2 */
760 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(
761 env);
762 #endif /* USDT2 */
763 jni_check_async_exceptions(thread);
764 oop exception = thread->pending_exception();
765 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
766 #ifndef USDT2
767 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret);
768 #else /* USDT2 */
769 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(
770 ret);
771 #endif /* USDT2 */
772 return ret;
773 JNI_END
774
775
776 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
777 JNIWrapper("ExceptionDescribe");
778 #ifndef USDT2
779 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env);
780 #else /* USDT2 */
781 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(
782 env);
783 #endif /* USDT2 */
784 if (thread->has_pending_exception()) {
785 Handle ex(thread, thread->pending_exception());
786 thread->clear_pending_exception();
787 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
788 // Don't print anything if we are being killed.
789 } else {
790 jio_fprintf(defaultStream::error_stream(), "Exception ");
791 if (thread != NULL && thread->threadObj() != NULL) {
792 ResourceMark rm(THREAD);
793 jio_fprintf(defaultStream::error_stream(),
794 "in thread \"%s\" ", thread->get_thread_name());
795 }
796 if (ex->is_a(SystemDictionary::Throwable_klass())) {
797 JavaValue result(T_VOID);
798 JavaCalls::call_virtual(&result,
799 ex,
800 KlassHandle(THREAD,
801 SystemDictionary::Throwable_klass()),
802 vmSymbols::printStackTrace_name(),
803 vmSymbols::void_method_signature(),
804 THREAD);
805 // If an exception is thrown in the call it gets thrown away. Not much
806 // we can do with it. The native code that calls this, does not check
807 // for the exception - hence, it might still be in the thread when DestroyVM gets
808 // called, potentially causing a few asserts to trigger - since no pending exception
809 // is expected.
810 CLEAR_PENDING_EXCEPTION;
811 } else {
812 ResourceMark rm(THREAD);
813 jio_fprintf(defaultStream::error_stream(),
814 ". Uncaught exception of type %s.",
815 ex->klass()->external_name());
816 }
817 }
818 }
819 #ifndef USDT2
820 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
821 #else /* USDT2 */
822 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(
823 );
824 #endif /* USDT2 */
825 JNI_END
826
827
828 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
829 JNIWrapper("ExceptionClear");
830 #ifndef USDT2
831 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env);
832 #else /* USDT2 */
833 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(
834 env);
835 #endif /* USDT2 */
836
837 // The jni code might be using this API to clear java thrown exception.
838 // So just mark jvmti thread exception state as exception caught.
839 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
840 if (state != NULL && state->is_exception_detected()) {
841 state->set_exception_caught();
842 }
843 thread->clear_pending_exception();
844 #ifndef USDT2
845 DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
846 #else /* USDT2 */
847 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(
848 );
849 #endif /* USDT2 */
850 JNI_END
851
852
853 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
854 JNIWrapper("FatalError");
855 #ifndef USDT2
856 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg);
857 #else /* USDT2 */
858 HOTSPOT_JNI_FATALERROR_ENTRY(
859 env, (char *) msg);
860 #endif /* USDT2 */
861 tty->print_cr("FATAL ERROR in native method: %s", msg);
862 thread->print_stack();
863 os::abort(); // Dump core and abort
864 JNI_END
865
866
867 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
868 JNIWrapper("PushLocalFrame");
869 #ifndef USDT2
870 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity);
871 #else /* USDT2 */
872 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(
873 env, capacity);
874 #endif /* USDT2 */
875 //%note jni_11
876 if (capacity < 0 ||
877 ((MaxJNILocalCapacity > 0) && (capacity > MaxJNILocalCapacity))) {
878 #ifndef USDT2
879 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR);
880 #else /* USDT2 */
881 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(
882 (uint32_t)JNI_ERR);
883 #endif /* USDT2 */
884 return JNI_ERR;
885 }
886 JNIHandleBlock* old_handles = thread->active_handles();
887 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
888 assert(new_handles != NULL, "should not be NULL");
889 new_handles->set_pop_frame_link(old_handles);
890 thread->set_active_handles(new_handles);
891 jint ret = JNI_OK;
892 #ifndef USDT2
893 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret);
894 #else /* USDT2 */
895 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(
896 ret);
897 #endif /* USDT2 */
898 return ret;
899 JNI_END
900
901
902 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
903 JNIWrapper("PopLocalFrame");
904 #ifndef USDT2
905 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result);
906 #else /* USDT2 */
907 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(
908 env, result);
909 #endif /* USDT2 */
910 //%note jni_11
911 Handle result_handle(thread, JNIHandles::resolve(result));
912 JNIHandleBlock* old_handles = thread->active_handles();
913 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
914 if (new_handles != NULL) {
915 // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL.
916 // This way code will still work if PopLocalFrame is called without a corresponding
917 // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise
918 // the release_block call will release the blocks.
919 thread->set_active_handles(new_handles);
920 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
921 JNIHandleBlock::release_block(old_handles, thread); // may block
922 result = JNIHandles::make_local(thread, result_handle());
923 }
924 #ifndef USDT2
925 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
926 #else /* USDT2 */
927 HOTSPOT_JNI_POPLOCALFRAME_RETURN(
928 result);
929 #endif /* USDT2 */
930 return result;
931 JNI_END
932
933
934 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
935 JNIWrapper("NewGlobalRef");
936 #ifndef USDT2
937 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref);
938 #else /* USDT2 */
939 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(
940 env, ref);
941 #endif /* USDT2 */
942 Handle ref_handle(thread, JNIHandles::resolve(ref));
943 jobject ret = JNIHandles::make_global(ref_handle);
944 #ifndef USDT2
945 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret);
946 #else /* USDT2 */
947 HOTSPOT_JNI_NEWGLOBALREF_RETURN(
948 ret);
949 #endif /* USDT2 */
950 return ret;
951 JNI_END
952
953 // Must be JNI_ENTRY (with HandleMark)
954 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
955 JNIWrapper("DeleteGlobalRef");
956 #ifndef USDT2
957 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref);
958 #else /* USDT2 */
959 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(
960 env, ref);
961 #endif /* USDT2 */
962 JNIHandles::destroy_global(ref);
963 #ifndef USDT2
964 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
965 #else /* USDT2 */
966 HOTSPOT_JNI_DELETEGLOBALREF_RETURN(
967 );
968 #endif /* USDT2 */
969 JNI_END
970
971 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
972 JNIWrapper("DeleteLocalRef");
973 #ifndef USDT2
974 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj);
975 #else /* USDT2 */
976 HOTSPOT_JNI_DELETELOCALREF_ENTRY(
977 env, obj);
978 #endif /* USDT2 */
979 JNIHandles::destroy_local(obj);
980 #ifndef USDT2
981 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
982 #else /* USDT2 */
983 HOTSPOT_JNI_DELETELOCALREF_RETURN(
984 );
985 #endif /* USDT2 */
986 JNI_END
987
988 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
989 JNIWrapper("IsSameObject");
990 #ifndef USDT2
991 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2);
992 #else /* USDT2 */
993 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(
994 env, r1, r2);
995 #endif /* USDT2 */
996 oop a = JNIHandles::resolve(r1);
997 oop b = JNIHandles::resolve(r2);
998 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
999 #ifndef USDT2
1000 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret);
1001 #else /* USDT2 */
1002 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(
1003 ret);
1004 #endif /* USDT2 */
1005 return ret;
1006 JNI_END
1007
1008
1009 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
1010 JNIWrapper("NewLocalRef");
1011 #ifndef USDT2
1012 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref);
1013 #else /* USDT2 */
1014 HOTSPOT_JNI_NEWLOCALREF_ENTRY(
1015 env, ref);
1016 #endif /* USDT2 */
1017 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
1018 #ifndef USDT2
1019 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret);
1020 #else /* USDT2 */
1021 HOTSPOT_JNI_NEWLOCALREF_RETURN(
1022 ret);
1023 #endif /* USDT2 */
1024 return ret;
1025 JNI_END
1026
1027 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
1028 JNIWrapper("EnsureLocalCapacity");
1029 #ifndef USDT2
1030 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity);
1031 #else /* USDT2 */
1032 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(
1033 env, capacity);
1034 #endif /* USDT2 */
1035 jint ret;
1036 if (capacity >= 0 &&
1037 ((MaxJNILocalCapacity <= 0) || (capacity <= MaxJNILocalCapacity))) {
1038 ret = JNI_OK;
1039 } else {
1040 ret = JNI_ERR;
1041 }
1042 #ifndef USDT2
1043 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret);
1044 #else /* USDT2 */
1045 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(
1046 ret);
1047 #endif /* USDT2 */
1048 return ret;
1049 JNI_END
1050
1051 // Return the Handle Type
1052 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
1053 JNIWrapper("GetObjectRefType");
1054 #ifndef USDT2
1055 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj);
1056 #else /* USDT2 */
1057 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(
1058 env, obj);
1059 #endif /* USDT2 */
1060 jobjectRefType ret;
1061 if (JNIHandles::is_local_handle(thread, obj) ||
1062 JNIHandles::is_frame_handle(thread, obj))
1063 ret = JNILocalRefType;
1064 else if (JNIHandles::is_global_handle(obj))
1065 ret = JNIGlobalRefType;
1066 else if (JNIHandles::is_weak_global_handle(obj))
1067 ret = JNIWeakGlobalRefType;
1068 else
1069 ret = JNIInvalidRefType;
1070 #ifndef USDT2
1071 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
1072 #else /* USDT2 */
1073 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN(
1074 (void *) ret);
1075 #endif /* USDT2 */
1076 return ret;
1077 JNI_END
1078
1079
1080 class JNI_ArgumentPusher : public SignatureIterator {
1081 protected:
1082 JavaCallArguments* _arguments;
1083
1084 virtual void get_bool () = 0;
1085 virtual void get_char () = 0;
1086 virtual void get_short () = 0;
1087 virtual void get_byte () = 0;
1088 virtual void get_int () = 0;
1089 virtual void get_long () = 0;
1090 virtual void get_float () = 0;
1091 virtual void get_double () = 0;
1092 virtual void get_object () = 0;
1093
1094 JNI_ArgumentPusher(Symbol* signature) : SignatureIterator(signature) {
1095 this->_return_type = T_ILLEGAL;
1096 _arguments = NULL;
1097 }
1098
1099 public:
1100 virtual void iterate( uint64_t fingerprint ) = 0;
1101
1102 void set_java_argument_object(JavaCallArguments *arguments) { _arguments = arguments; }
1103
1104 inline void do_bool() { if (!is_return_type()) get_bool(); }
1105 inline void do_char() { if (!is_return_type()) get_char(); }
1106 inline void do_short() { if (!is_return_type()) get_short(); }
1107 inline void do_byte() { if (!is_return_type()) get_byte(); }
1108 inline void do_int() { if (!is_return_type()) get_int(); }
1109 inline void do_long() { if (!is_return_type()) get_long(); }
1110 inline void do_float() { if (!is_return_type()) get_float(); }
1111 inline void do_double() { if (!is_return_type()) get_double(); }
1112 inline void do_object(int begin, int end) { if (!is_return_type()) get_object(); }
1113 inline void do_array(int begin, int end) { if (!is_return_type()) get_object(); } // do_array uses get_object -- there is no get_array
1114 inline void do_void() { }
1115
1116 JavaCallArguments* arguments() { return _arguments; }
1117 void push_receiver(Handle h) { _arguments->push_oop(h); }
1118 };
1119
1120
1121 class JNI_ArgumentPusherVaArg : public JNI_ArgumentPusher {
1122 protected:
1123 va_list _ap;
1124
1125 inline void get_bool() {
1126 // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
1127 // 0 to JNI_FALSE. Boolean return values from native are normalized the same in
1128 // TemplateInterpreterGenerator::generate_result_handler_for and
1129 // SharedRuntime::generate_native_wrapper.
1130 jboolean b = va_arg(_ap, jint);
1131 _arguments->push_int((jint)(b == 0 ? JNI_FALSE : JNI_TRUE));
1132 }
1133 inline void get_char() { _arguments->push_int(va_arg(_ap, jint)); } // char is coerced to int when using va_arg
1134 inline void get_short() { _arguments->push_int(va_arg(_ap, jint)); } // short is coerced to int when using va_arg
1135 inline void get_byte() { _arguments->push_int(va_arg(_ap, jint)); } // byte is coerced to int when using va_arg
1136 inline void get_int() { _arguments->push_int(va_arg(_ap, jint)); }
1137
1138 // each of these paths is exercized by the various jck Call[Static,Nonvirtual,][Void,Int,..]Method[A,V,] tests
1139
1140 inline void get_long() { _arguments->push_long(va_arg(_ap, jlong)); }
1141 inline void get_float() { _arguments->push_float((jfloat)va_arg(_ap, jdouble)); } // float is coerced to double w/ va_arg
1142 inline void get_double() { _arguments->push_double(va_arg(_ap, jdouble)); }
1143 inline void get_object() { jobject l = va_arg(_ap, jobject);
1144 _arguments->push_oop(Handle((oop *)l, false)); }
1145
1146 inline void set_ap(va_list rap) {
1147 #ifdef va_copy
1148 va_copy(_ap, rap);
1149 #elif defined (__va_copy)
1150 __va_copy(_ap, rap);
1151 #else
1152 _ap = rap;
1153 #endif
1154 }
1155
1156 public:
1157 JNI_ArgumentPusherVaArg(Symbol* signature, va_list rap)
1158 : JNI_ArgumentPusher(signature) {
1159 set_ap(rap);
1160 }
1161 JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap)
1162 : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)->signature()) {
1163 set_ap(rap);
1164 }
1165
1166 // Optimized path if we have the bitvector form of signature
1167 void iterate( uint64_t fingerprint ) {
1168 if ( fingerprint == UCONST64(-1) ) SignatureIterator::iterate();// Must be too many arguments
1169 else {
1170 _return_type = (BasicType)((fingerprint >> static_feature_size) &
1171 result_feature_mask);
1172
1173 assert(fingerprint, "Fingerprint should not be 0");
1174 fingerprint = fingerprint >> (static_feature_size + result_feature_size);
1175 while ( 1 ) {
1176 switch ( fingerprint & parameter_feature_mask ) {
1177 case bool_parm:
1178 get_bool();
1179 break;
1180 case char_parm:
1181 get_char();
1182 break;
1183 case short_parm:
1184 get_short();
1185 break;
1186 case byte_parm:
1187 get_byte();
1188 break;
1189 case int_parm:
1190 get_int();
1191 break;
1192 case obj_parm:
1193 get_object();
1194 break;
1195 case long_parm:
1196 get_long();
1197 break;
1198 case float_parm:
1199 get_float();
1200 break;
1201 case double_parm:
1202 get_double();
1203 break;
1204 case done_parm:
1205 return;
1206 break;
1207 default:
1208 ShouldNotReachHere();
1209 break;
1210 }
1211 fingerprint >>= parameter_feature_size;
1212 }
1213 }
1214 }
1215 };
1216
1217
1218 class JNI_ArgumentPusherArray : public JNI_ArgumentPusher {
1219 protected:
1220 const jvalue *_ap;
1221
1222 inline void get_bool() {
1223 // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
1224 // 0 to JNI_FALSE. Boolean return values from native are normalized the same in
1225 // TemplateInterpreterGenerator::generate_result_handler_for and
1226 // SharedRuntime::generate_native_wrapper.
1227 jboolean b = (_ap++)->z;
1228 _arguments->push_int((jint)(b == 0 ? JNI_FALSE : JNI_TRUE));
1229 }
1230 inline void get_char() { _arguments->push_int((jint)(_ap++)->c); }
1231 inline void get_short() { _arguments->push_int((jint)(_ap++)->s); }
1232 inline void get_byte() { _arguments->push_int((jint)(_ap++)->b); }
1233 inline void get_int() { _arguments->push_int((jint)(_ap++)->i); }
1234
1235 inline void get_long() { _arguments->push_long((_ap++)->j); }
1236 inline void get_float() { _arguments->push_float((_ap++)->f); }
1237 inline void get_double() { _arguments->push_double((_ap++)->d);}
1238 inline void get_object() { _arguments->push_oop(Handle((oop *)(_ap++)->l, false)); }
1239
1240 inline void set_ap(const jvalue *rap) { _ap = rap; }
1241
1242 public:
1243 JNI_ArgumentPusherArray(Symbol* signature, const jvalue *rap)
1244 : JNI_ArgumentPusher(signature) {
1245 set_ap(rap);
1246 }
1247 JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap)
1248 : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)->signature()) {
1249 set_ap(rap);
1250 }
1251
1252 // Optimized path if we have the bitvector form of signature
1253 void iterate( uint64_t fingerprint ) {
1254 if ( fingerprint == UCONST64(-1) ) SignatureIterator::iterate(); // Must be too many arguments
1255 else {
1256 _return_type = (BasicType)((fingerprint >> static_feature_size) &
1257 result_feature_mask);
1258 assert(fingerprint, "Fingerprint should not be 0");
1259 fingerprint = fingerprint >> (static_feature_size + result_feature_size);
1260 while ( 1 ) {
1261 switch ( fingerprint & parameter_feature_mask ) {
1262 case bool_parm:
1263 get_bool();
1264 break;
1265 case char_parm:
1266 get_char();
1267 break;
1268 case short_parm:
1269 get_short();
1270 break;
1271 case byte_parm:
1272 get_byte();
1273 break;
1274 case int_parm:
1275 get_int();
1276 break;
1277 case obj_parm:
1278 get_object();
1279 break;
1280 case long_parm:
1281 get_long();
1282 break;
1283 case float_parm:
1284 get_float();
1285 break;
1286 case double_parm:
1287 get_double();
1288 break;
1289 case done_parm:
1290 return;
1291 break;
1292 default:
1293 ShouldNotReachHere();
1294 break;
1295 }
1296 fingerprint >>= parameter_feature_size;
1297 }
1298 }
1299 }
1300 };
1301
1302
1303 enum JNICallType {
1304 JNI_STATIC,
1305 JNI_VIRTUAL,
1306 JNI_NONVIRTUAL
1307 };
1308
1309
1310
1311 static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
1312 methodHandle method(THREAD, Method::resolve_jmethod_id(method_id));
1313
1314 // Create object to hold arguments for the JavaCall, and associate it with
1315 // the jni parser
1316 ResourceMark rm(THREAD);
1317 int number_of_parameters = method->size_of_parameters();
1318 JavaCallArguments java_args(number_of_parameters);
1319 args->set_java_argument_object(&java_args);
1320
1321 assert(method->is_static(), "method should be static");
1322
1323 // Fill out JavaCallArguments object
1324 args->iterate( Fingerprinter(method).fingerprint() );
1325 // Initialize result type
1326 result->set_type(args->get_ret_type());
1327
1328 // Invoke the method. Result is returned as oop.
1329 JavaCalls::call(result, method, &java_args, CHECK);
1330
1331 // Convert result
1332 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
1333 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
1334 }
1335 }
1336
1337
1338 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
1339 oop recv = JNIHandles::resolve(receiver);
1340 if (recv == NULL) {
1341 THROW(vmSymbols::java_lang_NullPointerException());
1342 }
1343 Handle h_recv(THREAD, recv);
1344
1345 int number_of_parameters;
1346 Method* selected_method;
1347 {
1348 Method* m = Method::resolve_jmethod_id(method_id);
1349 number_of_parameters = m->size_of_parameters();
1350 Klass* holder = m->method_holder();
1351 if (call_type != JNI_VIRTUAL) {
1352 selected_method = m;
1353 } else if (!m->has_itable_index()) {
1354 // non-interface call -- for that little speed boost, don't handlize
1355 debug_only(No_Safepoint_Verifier nosafepoint;)
1356 // jni_GetMethodID makes sure class is linked and initialized
1357 // so m should have a valid vtable index.
1358 assert(m->valid_vtable_index(), "no valid vtable index");
1359 int vtbl_index = m->vtable_index();
1360 if (vtbl_index != Method::nonvirtual_vtable_index) {
1361 Klass* k = h_recv->klass();
1362 // k might be an arrayKlassOop but all vtables start at
1363 // the same place. The cast is to avoid virtual call and assertion.
1364 InstanceKlass *ik = (InstanceKlass*)k;
1365 selected_method = ik->method_at_vtable(vtbl_index);
1366 } else {
1367 // final method
1368 selected_method = m;
1369 }
1370 } else {
1371 // interface call
1372 KlassHandle h_holder(THREAD, holder);
1373
1374 int itbl_index = m->itable_index();
1375 Klass* k = h_recv->klass();
1376 selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
1377 }
1378 }
1379
1380 methodHandle method(THREAD, selected_method);
1381
1382 // Create object to hold arguments for the JavaCall, and associate it with
1383 // the jni parser
1384 ResourceMark rm(THREAD);
1385 JavaCallArguments java_args(number_of_parameters);
1386 args->set_java_argument_object(&java_args);
1387
1388 // handle arguments
1389 assert(!method->is_static(), "method should not be static");
1390 args->push_receiver(h_recv); // Push jobject handle
1391
1392 // Fill out JavaCallArguments object
1393 args->iterate( Fingerprinter(method).fingerprint() );
1394 // Initialize result type
1395 result->set_type(args->get_ret_type());
1396
1397 // Invoke the method. Result is returned as oop.
1398 JavaCalls::call(result, method, &java_args, CHECK);
1399
1400 // Convert result
1401 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
1402 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
1403 }
1404 }
1405
1406
1407 static instanceOop alloc_object(jclass clazz, TRAPS) {
1408 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1409 k()->check_valid_for_instantiation(false, CHECK_NULL);
1410 InstanceKlass::cast(k())->initialize(CHECK_NULL);
1411 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD);
1412 return ih;
1413 }
1414
1415 #ifndef USDT2
1416 DT_RETURN_MARK_DECL(AllocObject, jobject);
1417 #else /* USDT2 */
1418 DT_RETURN_MARK_DECL(AllocObject, jobject
1419 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1420 #endif /* USDT2 */
1421
1422 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1423 JNIWrapper("AllocObject");
1424
1425 #ifndef USDT2
1426 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
1427 #else /* USDT2 */
1428 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(
1429 env, clazz);
1430 #endif /* USDT2 */
1431 jobject ret = NULL;
1432 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1433
1434 instanceOop i = alloc_object(clazz, CHECK_NULL);
1435 ret = JNIHandles::make_local(env, i);
1436 return ret;
1437 JNI_END
1438
1439 #ifndef USDT2
1440 DT_RETURN_MARK_DECL(NewObjectA, jobject);
1441 #else /* USDT2 */
1442 DT_RETURN_MARK_DECL(NewObjectA, jobject
1443 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1444 #endif /* USDT2 */
1445
1446 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
1447 JNIWrapper("NewObjectA");
1448 #ifndef USDT2
1449 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID);
1450 #else /* USDT2 */
1451 HOTSPOT_JNI_NEWOBJECTA_ENTRY(
1452 env, clazz, (uintptr_t) methodID);
1453 #endif /* USDT2 */
1454 jobject obj = NULL;
1455 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
1456
1457 instanceOop i = alloc_object(clazz, CHECK_NULL);
1458 obj = JNIHandles::make_local(env, i);
1459 JavaValue jvalue(T_VOID);
1460 JNI_ArgumentPusherArray ap(methodID, args);
1461 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1462 return obj;
1463 JNI_END
1464
1465 #ifndef USDT2
1466 DT_RETURN_MARK_DECL(NewObjectV, jobject);
1467 #else /* USDT2 */
1468 DT_RETURN_MARK_DECL(NewObjectV, jobject
1469 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1470 #endif /* USDT2 */
1471
1472 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
1473 JNIWrapper("NewObjectV");
1474 #ifndef USDT2
1475 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID);
1476 #else /* USDT2 */
1477 HOTSPOT_JNI_NEWOBJECTV_ENTRY(
1478 env, clazz, (uintptr_t) methodID);
1479 #endif /* USDT2 */
1480 jobject obj = NULL;
1481 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
1482
1483 instanceOop i = alloc_object(clazz, CHECK_NULL);
1484 obj = JNIHandles::make_local(env, i);
1485 JavaValue jvalue(T_VOID);
1486 JNI_ArgumentPusherVaArg ap(methodID, args);
1487 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1488 return obj;
1489 JNI_END
1490
1491 #ifndef USDT2
1492 DT_RETURN_MARK_DECL(NewObject, jobject);
1493 #else /* USDT2 */
1494 DT_RETURN_MARK_DECL(NewObject, jobject
1495 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1496 #endif /* USDT2 */
1497
1498 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1499 JNIWrapper("NewObject");
1500 #ifndef USDT2
1501 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID);
1502 #else /* USDT2 */
1503 HOTSPOT_JNI_NEWOBJECT_ENTRY(
1504 env, clazz, (uintptr_t) methodID);
1505 #endif /* USDT2 */
1506 jobject obj = NULL;
1507 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1508
1509 instanceOop i = alloc_object(clazz, CHECK_NULL);
1510 obj = JNIHandles::make_local(env, i);
1511 va_list args;
1512 va_start(args, methodID);
1513 JavaValue jvalue(T_VOID);
1514 JNI_ArgumentPusherVaArg ap(methodID, args);
1515 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1516 va_end(args);
1517 return obj;
1518 JNI_END
1519
1520
1521 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1522 JNIWrapper("GetObjectClass");
1523 #ifndef USDT2
1524 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
1525 #else /* USDT2 */
1526 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(
1527 env, obj);
1528 #endif /* USDT2 */
1529 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1530 jclass ret =
1531 (jclass) JNIHandles::make_local(env, k->java_mirror());
1532 #ifndef USDT2
1533 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
1534 #else /* USDT2 */
1535 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(
1536 ret);
1537 #endif /* USDT2 */
1538 return ret;
1539 JNI_END
1540
1541 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1542 JNIWrapper("IsInstanceOf");
1543 #ifndef USDT2
1544 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz);
1545 #else /* USDT2 */
1546 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(
1547 env, obj, clazz);
1548 #endif /* USDT2 */
1549 jboolean ret = JNI_TRUE;
1550 if (obj != NULL) {
1551 ret = JNI_FALSE;
1552 Klass* k = java_lang_Class::as_Klass(
1553 JNIHandles::resolve_non_null(clazz));
1554 if (k != NULL) {
1555 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
1556 }
1557 }
1558 #ifndef USDT2
1559 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
1560 #else /* USDT2 */
1561 HOTSPOT_JNI_ISINSTANCEOF_RETURN(
1562 ret);
1563 #endif /* USDT2 */
1564 return ret;
1565 JNI_END
1566
1567
1568 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
1569 const char *sig, bool is_static, TRAPS) {
1570 // %%%% This code should probably just call into a method in the LinkResolver
1571 //
1572 // The class should have been loaded (we have an instance of the class
1573 // passed in) so the method and signature should already be in the symbol
1574 // table. If they're not there, the method doesn't exist.
1575 const char *name_to_probe = (name_str == NULL)
1576 ? vmSymbols::object_initializer_name()->as_C_string()
1577 : name_str;
1578 TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
1579 TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
1580
1581 if (name == NULL || signature == NULL) {
1582 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1583 }
1584
1585 // Throw a NoSuchMethodError exception if we have an instance of a
1586 // primitive java.lang.Class
1587 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) {
1588 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1589 }
1590
1591 KlassHandle klass(THREAD,
1592 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1593
1594 // Make sure class is linked and initialized before handing id's out to
1595 // Method*s.
1596 klass()->initialize(CHECK_NULL);
1597
1598 Method* m;
1599 if (name == vmSymbols::object_initializer_name() ||
1600 name == vmSymbols::class_initializer_name()) {
1601 // Never search superclasses for constructors
1602 if (klass->oop_is_instance()) {
1603 m = InstanceKlass::cast(klass())->find_method(name, signature);
1604 } else {
1605 m = NULL;
1606 }
1607 } else {
1608 m = klass->lookup_method(name, signature);
1609 if (m == NULL && klass->oop_is_instance()) {
1610 m = InstanceKlass::cast(klass())->lookup_method_in_ordered_interfaces(name, signature);
1611 }
1612 }
1613 if (m == NULL || (m->is_static() != is_static)) {
1614 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1615 }
1616 return m->jmethod_id();
1617 }
1618
1619
1620 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
1621 const char *name, const char *sig))
1622 JNIWrapper("GetMethodID");
1623 #ifndef USDT2
1624 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig);
1625 #else /* USDT2 */
1626 HOTSPOT_JNI_GETMETHODID_ENTRY(
1627 env, clazz, (char *) name, (char *) sig);
1628 #endif /* USDT2 */
1629 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1630 #ifndef USDT2
1631 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret);
1632 #else /* USDT2 */
1633 HOTSPOT_JNI_GETMETHODID_RETURN(
1634 (uintptr_t) ret);
1635 #endif /* USDT2 */
1636 return ret;
1637 JNI_END
1638
1639
1640 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
1641 const char *name, const char *sig))
1642 JNIWrapper("GetStaticMethodID");
1643 #ifndef USDT2
1644 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig);
1645 #else /* USDT2 */
1646 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(
1647 env, (char *) clazz, (char *) name, (char *)sig);
1648 #endif /* USDT2 */
1649 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
1650 #ifndef USDT2
1651 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret);
1652 #else /* USDT2 */
1653 HOTSPOT_JNI_GETSTATICMETHODID_RETURN(
1654 (uintptr_t) ret);
1655 #endif /* USDT2 */
1656 return ret;
1657 JNI_END
1658
1659
1660
1661 //
1662 // Calling Methods
1663 //
1664
1665 #ifndef USDT2
1666 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \
1667 \
1668 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\
1669 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\
1670 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\
1671 \
1672 JNI_ENTRY(ResultType, \
1673 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
1674 JNIWrapper("Call" XSTR(Result) "Method"); \
1675 \
1676 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \
1677 ResultType ret = 0;\
1678 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
1679 (const ResultType&)ret);\
1680 \
1681 va_list args; \
1682 va_start(args, methodID); \
1683 JavaValue jvalue(Tag); \
1684 JNI_ArgumentPusherVaArg ap(methodID, args); \
1685 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1686 va_end(args); \
1687 ret = jvalue.get_##ResultType(); \
1688 return ret;\
1689 JNI_END \
1690 \
1691 \
1692 JNI_ENTRY(ResultType, \
1693 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
1694 JNIWrapper("Call" XSTR(Result) "MethodV"); \
1695 \
1696 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID); \
1697 ResultType ret = 0;\
1698 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
1699 (const ResultType&)ret);\
1700 \
1701 JavaValue jvalue(Tag); \
1702 JNI_ArgumentPusherVaArg ap(methodID, args); \
1703 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1704 ret = jvalue.get_##ResultType(); \
1705 return ret;\
1706 JNI_END \
1707 \
1708 \
1709 JNI_ENTRY(ResultType, \
1710 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
1711 JNIWrapper("Call" XSTR(Result) "MethodA"); \
1712 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID); \
1713 ResultType ret = 0;\
1714 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
1715 (const ResultType&)ret);\
1716 \
1717 JavaValue jvalue(Tag); \
1718 JNI_ArgumentPusherArray ap(methodID, args); \
1719 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1720 ret = jvalue.get_##ResultType(); \
1721 return ret;\
1722 JNI_END
1723
1724 // the runtime type of subword integral basic types is integer
1725 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN)
1726 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE)
1727 DEFINE_CALLMETHOD(jchar, Char, T_CHAR)
1728 DEFINE_CALLMETHOD(jshort, Short, T_SHORT)
1729
1730 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT)
1731 DEFINE_CALLMETHOD(jint, Int, T_INT)
1732 DEFINE_CALLMETHOD(jlong, Long, T_LONG)
1733 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT)
1734 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE)
1735
1736 DT_VOID_RETURN_MARK_DECL(CallVoidMethod);
1737 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV);
1738 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA);
1739
1740 #else /* USDT2 */
1741
1742 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \
1743 , EntryProbe, ReturnProbe) \
1744 \
1745 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
1746 , ReturnProbe); \
1747 \
1748 JNI_ENTRY(ResultType, \
1749 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
1750 JNIWrapper("Call" XSTR(Result) "Method"); \
1751 \
1752 EntryProbe; \
1753 ResultType ret = 0;\
1754 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
1755 (const ResultType&)ret);\
1756 \
1757 va_list args; \
1758 va_start(args, methodID); \
1759 JavaValue jvalue(Tag); \
1760 JNI_ArgumentPusherVaArg ap(methodID, args); \
1761 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1762 va_end(args); \
1763 ret = jvalue.get_##ResultType(); \
1764 return ret;\
1765 JNI_END
1766
1767 // the runtime type of subword integral basic types is integer
1768 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN
1769 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1770 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
1771 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE
1772 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1773 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
1774 DEFINE_CALLMETHOD(jchar, Char, T_CHAR
1775 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1776 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
1777 DEFINE_CALLMETHOD(jshort, Short, T_SHORT
1778 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1779 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
1780
1781 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT
1782 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1783 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
1784 DEFINE_CALLMETHOD(jint, Int, T_INT,
1785 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1786 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
1787 DEFINE_CALLMETHOD(jlong, Long, T_LONG
1788 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1789 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
1790 // Float and double probes don't return value because dtrace doesn't currently support it
1791 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT
1792 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1793 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
1794 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE
1795 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1796 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
1797
1798 #define DEFINE_CALLMETHODV(ResultType, Result, Tag \
1799 , EntryProbe, ReturnProbe) \
1800 \
1801 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType \
1802 , ReturnProbe); \
1803 \
1804 JNI_ENTRY(ResultType, \
1805 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
1806 JNIWrapper("Call" XSTR(Result) "MethodV"); \
1807 \
1808 EntryProbe;\
1809 ResultType ret = 0;\
1810 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
1811 (const ResultType&)ret);\
1812 \
1813 JavaValue jvalue(Tag); \
1814 JNI_ArgumentPusherVaArg ap(methodID, args); \
1815 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1816 ret = jvalue.get_##ResultType(); \
1817 return ret;\
1818 JNI_END
1819
1820 // the runtime type of subword integral basic types is integer
1821 DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
1822 , HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1823 HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref))
1824 DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE
1825 , HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1826 HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref))
1827 DEFINE_CALLMETHODV(jchar, Char, T_CHAR
1828 , HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1829 HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref))
1830 DEFINE_CALLMETHODV(jshort, Short, T_SHORT
1831 , HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1832 HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref))
1833
1834 DEFINE_CALLMETHODV(jobject, Object, T_OBJECT
1835 , HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1836 HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref))
1837 DEFINE_CALLMETHODV(jint, Int, T_INT,
1838 HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1839 HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref))
1840 DEFINE_CALLMETHODV(jlong, Long, T_LONG
1841 , HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1842 HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref))
1843 // Float and double probes don't return value because dtrace doesn't currently support it
1844 DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT
1845 , HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1846 HOTSPOT_JNI_CALLFLOATMETHODV_RETURN())
1847 DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE
1848 , HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1849 HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN())
1850
1851 #define DEFINE_CALLMETHODA(ResultType, Result, Tag \
1852 , EntryProbe, ReturnProbe) \
1853 \
1854 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \
1855 , ReturnProbe); \
1856 \
1857 JNI_ENTRY(ResultType, \
1858 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
1859 JNIWrapper("Call" XSTR(Result) "MethodA"); \
1860 EntryProbe; \
1861 ResultType ret = 0;\
1862 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
1863 (const ResultType&)ret);\
1864 \
1865 JavaValue jvalue(Tag); \
1866 JNI_ArgumentPusherArray ap(methodID, args); \
1867 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1868 ret = jvalue.get_##ResultType(); \
1869 return ret;\
1870 JNI_END
1871
1872 // the runtime type of subword integral basic types is integer
1873 DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
1874 , HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1875 HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref))
1876 DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE
1877 , HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1878 HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref))
1879 DEFINE_CALLMETHODA(jchar, Char, T_CHAR
1880 , HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1881 HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref))
1882 DEFINE_CALLMETHODA(jshort, Short, T_SHORT
1883 , HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1884 HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref))
1885
1886 DEFINE_CALLMETHODA(jobject, Object, T_OBJECT
1887 , HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1888 HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref))
1889 DEFINE_CALLMETHODA(jint, Int, T_INT,
1890 HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1891 HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref))
1892 DEFINE_CALLMETHODA(jlong, Long, T_LONG
1893 , HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1894 HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref))
1895 // Float and double probes don't return value because dtrace doesn't currently support it
1896 DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT
1897 , HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1898 HOTSPOT_JNI_CALLFLOATMETHODA_RETURN())
1899 DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE
1900 , HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1901 HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN())
1902
1903 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
1904 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
1905 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
1906
1907 #endif /* USDT2 */
1908
1909 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
1910 JNIWrapper("CallVoidMethod");
1911 #ifndef USDT2
1912 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID);
1913 #else /* USDT2 */
1914 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(
1915 env, obj, (uintptr_t) methodID);
1916 #endif /* USDT2 */
1917 DT_VOID_RETURN_MARK(CallVoidMethod);
1918
1919 va_list args;
1920 va_start(args, methodID);
1921 JavaValue jvalue(T_VOID);
1922 JNI_ArgumentPusherVaArg ap(methodID, args);
1923 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1924 va_end(args);
1925 JNI_END
1926
1927
1928 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
1929 JNIWrapper("CallVoidMethodV");
1930 #ifndef USDT2
1931 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
1932 #else /* USDT2 */
1933 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(
1934 env, obj, (uintptr_t) methodID);
1935 #endif /* USDT2 */
1936 DT_VOID_RETURN_MARK(CallVoidMethodV);
1937
1938 JavaValue jvalue(T_VOID);
1939 JNI_ArgumentPusherVaArg ap(methodID, args);
1940 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1941 JNI_END
1942
1943
1944 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
1945 JNIWrapper("CallVoidMethodA");
1946 #ifndef USDT2
1947 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
1948 #else /* USDT2 */
1949 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(
1950 env, obj, (uintptr_t) methodID);
1951 #endif /* USDT2 */
1952 DT_VOID_RETURN_MARK(CallVoidMethodA);
1953
1954 JavaValue jvalue(T_VOID);
1955 JNI_ArgumentPusherArray ap(methodID, args);
1956 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1957 JNI_END
1958
1959
1960 #ifndef USDT2
1961 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \
1962 \
1963 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\
1964 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\
1965 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\
1966 \
1967 JNI_ENTRY(ResultType, \
1968 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
1969 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
1970 \
1971 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\
1972 ResultType ret;\
1973 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
1974 (const ResultType&)ret);\
1975 \
1976 va_list args; \
1977 va_start(args, methodID); \
1978 JavaValue jvalue(Tag); \
1979 JNI_ArgumentPusherVaArg ap(methodID, args); \
1980 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1981 va_end(args); \
1982 ret = jvalue.get_##ResultType(); \
1983 return ret;\
1984 JNI_END \
1985 \
1986 JNI_ENTRY(ResultType, \
1987 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
1988 JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \
1989 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\
1990 ResultType ret;\
1991 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
1992 (const ResultType&)ret);\
1993 \
1994 JavaValue jvalue(Tag); \
1995 JNI_ArgumentPusherVaArg ap(methodID, args); \
1996 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1997 ret = jvalue.get_##ResultType(); \
1998 return ret;\
1999 JNI_END \
2000 \
2001 JNI_ENTRY(ResultType, \
2002 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
2003 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
2004 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\
2005 ResultType ret;\
2006 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
2007 (const ResultType&)ret);\
2008 \
2009 JavaValue jvalue(Tag); \
2010 JNI_ArgumentPusherArray ap(methodID, args); \
2011 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
2012 ret = jvalue.get_##ResultType(); \
2013 return ret;\
2014 JNI_END
2015
2016 // the runtime type of subword integral basic types is integer
2017 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN)
2018 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE)
2019 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR)
2020 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT)
2021
2022 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT)
2023 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT)
2024 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG)
2025 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT)
2026 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE)
2027
2028
2029 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod);
2030 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV);
2031 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA);
2032
2033 #else /* USDT2 */
2034
2035 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
2036 , EntryProbe, ReturnProbe) \
2037 \
2038 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
2039 , ReturnProbe);\
2040 \
2041 JNI_ENTRY(ResultType, \
2042 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
2043 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
2044 \
2045 EntryProbe;\
2046 ResultType ret;\
2047 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
2048 (const ResultType&)ret);\
2049 \
2050 va_list args; \
2051 va_start(args, methodID); \
2052 JavaValue jvalue(Tag); \
2053 JNI_ArgumentPusherVaArg ap(methodID, args); \
2054 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
2055 va_end(args); \
2056 ret = jvalue.get_##ResultType(); \
2057 return ret;\
2058 JNI_END
2059
2060 // the runtime type of subword integral basic types is integer
2061 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN
2062 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2063 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(_ret_ref))
2064 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE
2065 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2066 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(_ret_ref))
2067 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR
2068 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2069 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(_ret_ref))
2070 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT
2071 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2072 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(_ret_ref))
2073
2074 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT
2075 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2076 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(_ret_ref))
2077 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT
2078 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2079 HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(_ret_ref))
2080 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG
2081 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2082 // Float and double probes don't return value because dtrace doesn't currently support it
2083 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(_ret_ref))
2084 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT
2085 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2086 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN())
2087 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE
2088 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
2089 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN())
2090
2091 #define DEFINE_CALLNONVIRTUALMETHODV(ResultType, Result, Tag \
2092 , EntryProbe, ReturnProbe) \
2093 \
2094 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType \
2095 , ReturnProbe);\
2096 \
2097 JNI_ENTRY(ResultType, \
2098 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
2099 JNIWrapper("CallNonvitual" XSTR(Result) "MethodV"); \
2100 \
2101 EntryProbe;\
2102 ResultType ret;\
2103 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
2104 (const ResultType&)ret);\
2105 \
2106 JavaValue jvalue(Tag); \
2107 JNI_ArgumentPusherVaArg ap(methodID, args); \
2108 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
2109 ret = jvalue.get_##ResultType(); \
2110 return ret;\
2111 JNI_END
2112
2113 // the runtime type of subword integral basic types is integer
2114 DEFINE_CALLNONVIRTUALMETHODV(jboolean, Boolean, T_BOOLEAN
2115 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2116 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(_ret_ref))
2117 DEFINE_CALLNONVIRTUALMETHODV(jbyte, Byte, T_BYTE
2118 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2119 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(_ret_ref))
2120 DEFINE_CALLNONVIRTUALMETHODV(jchar, Char, T_CHAR
2121 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2122 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(_ret_ref))
2123 DEFINE_CALLNONVIRTUALMETHODV(jshort, Short, T_SHORT
2124 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2125 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(_ret_ref))
2126
2127 DEFINE_CALLNONVIRTUALMETHODV(jobject, Object, T_OBJECT
2128 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2129 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(_ret_ref))
2130 DEFINE_CALLNONVIRTUALMETHODV(jint, Int, T_INT
2131 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2132 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(_ret_ref))
2133 DEFINE_CALLNONVIRTUALMETHODV(jlong, Long, T_LONG
2134 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2135 // Float and double probes don't return value because dtrace doesn't currently support it
2136 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(_ret_ref))
2137 DEFINE_CALLNONVIRTUALMETHODV(jfloat, Float, T_FLOAT
2138 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2139 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN())
2140 DEFINE_CALLNONVIRTUALMETHODV(jdouble, Double, T_DOUBLE
2141 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
2142 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN())
2143
2144 #define DEFINE_CALLNONVIRTUALMETHODA(ResultType, Result, Tag \
2145 , EntryProbe, ReturnProbe) \
2146 \
2147 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType \
2148 , ReturnProbe);\
2149 \
2150 JNI_ENTRY(ResultType, \
2151 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
2152 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
2153 \
2154 EntryProbe;\
2155 ResultType ret;\
2156 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
2157 (const ResultType&)ret);\
2158 \
2159 JavaValue jvalue(Tag); \
2160 JNI_ArgumentPusherArray ap(methodID, args); \
2161 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
2162 ret = jvalue.get_##ResultType(); \
2163 return ret;\
2164 JNI_END
2165
2166 // the runtime type of subword integral basic types is integer
2167 DEFINE_CALLNONVIRTUALMETHODA(jboolean, Boolean, T_BOOLEAN
2168 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2169 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(_ret_ref))
2170 DEFINE_CALLNONVIRTUALMETHODA(jbyte, Byte, T_BYTE
2171 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2172 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(_ret_ref))
2173 DEFINE_CALLNONVIRTUALMETHODA(jchar, Char, T_CHAR
2174 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2175 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(_ret_ref))
2176 DEFINE_CALLNONVIRTUALMETHODA(jshort, Short, T_SHORT
2177 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2178 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(_ret_ref))
2179
2180 DEFINE_CALLNONVIRTUALMETHODA(jobject, Object, T_OBJECT
2181 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2182 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(_ret_ref))
2183 DEFINE_CALLNONVIRTUALMETHODA(jint, Int, T_INT
2184 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2185 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(_ret_ref))
2186 DEFINE_CALLNONVIRTUALMETHODA(jlong, Long, T_LONG
2187 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2188 // Float and double probes don't return value because dtrace doesn't currently support it
2189 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(_ret_ref))
2190 DEFINE_CALLNONVIRTUALMETHODA(jfloat, Float, T_FLOAT
2191 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2192 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN())
2193 DEFINE_CALLNONVIRTUALMETHODA(jdouble, Double, T_DOUBLE
2194 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
2195 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN())
2196
2197 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod
2198 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
2199 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
2200 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
2201 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
2202 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
2203 #endif /* USDT2 */
2204
2205 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
2206 JNIWrapper("CallNonvirtualVoidMethod");
2207
2208 #ifndef USDT2
2209 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
2210 env, obj, cls, methodID);
2211 #else /* USDT2 */
2212 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(
2213 env, obj, cls, (uintptr_t) methodID);
2214 #endif /* USDT2 */
2215 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
2216
2217 va_list args;
2218 va_start(args, methodID);
2219 JavaValue jvalue(T_VOID);
2220 JNI_ArgumentPusherVaArg ap(methodID, args);
2221 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
2222 va_end(args);
2223 JNI_END
2224
2225
2226 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
2227 JNIWrapper("CallNonvirtualVoidMethodV");
2228
2229 #ifndef USDT2
2230 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry,
2231 env, obj, cls, methodID);
2232 #else /* USDT2 */
2233 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
2234 env, obj, cls, (uintptr_t) methodID);
2235 #endif /* USDT2 */
2236 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
2237
2238 JavaValue jvalue(T_VOID);
2239 JNI_ArgumentPusherVaArg ap(methodID, args);
2240 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
2241 JNI_END
2242
2243
2244 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
2245 JNIWrapper("CallNonvirtualVoidMethodA");
2246 #ifndef USDT2
2247 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry,
2248 env, obj, cls, methodID);
2249 #else /* USDT2 */
2250 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
2251 env, obj, cls, (uintptr_t) methodID);
2252 #endif /* USDT2 */
2253 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
2254 JavaValue jvalue(T_VOID);
2255 JNI_ArgumentPusherArray ap(methodID, args);
2256 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
2257 JNI_END
2258
2259
2260 #ifndef USDT2
2261 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \
2262 \
2263 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\
2264 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\
2265 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\
2266 \
2267 JNI_ENTRY(ResultType, \
2268 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
2269 JNIWrapper("CallStatic" XSTR(Result) "Method"); \
2270 \
2271 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\
2272 ResultType ret = 0;\
2273 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
2274 (const ResultType&)ret);\
2275 \
2276 va_list args; \
2277 va_start(args, methodID); \
2278 JavaValue jvalue(Tag); \
2279 JNI_ArgumentPusherVaArg ap(methodID, args); \
2280 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2281 va_end(args); \
2282 ret = jvalue.get_##ResultType(); \
2283 return ret;\
2284 JNI_END \
2285 \
2286 JNI_ENTRY(ResultType, \
2287 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
2288 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
2289 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\
2290 ResultType ret = 0;\
2291 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
2292 (const ResultType&)ret);\
2293 \
2294 JavaValue jvalue(Tag); \
2295 JNI_ArgumentPusherVaArg ap(methodID, args); \
2296 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2297 ret = jvalue.get_##ResultType(); \
2298 return ret;\
2299 JNI_END \
2300 \
2301 JNI_ENTRY(ResultType, \
2302 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
2303 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
2304 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\
2305 ResultType ret = 0;\
2306 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
2307 (const ResultType&)ret);\
2308 \
2309 JavaValue jvalue(Tag); \
2310 JNI_ArgumentPusherArray ap(methodID, args); \
2311 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2312 ret = jvalue.get_##ResultType(); \
2313 return ret;\
2314 JNI_END
2315
2316 // the runtime type of subword integral basic types is integer
2317 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN)
2318 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE)
2319 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR)
2320 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT)
2321
2322 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT)
2323 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT)
2324 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG)
2325 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT)
2326 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE)
2327
2328
2329 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod);
2330 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV);
2331 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA);
2332
2333 #else /* USDT2 */
2334
2335 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
2336 , EntryProbe, ResultProbe) \
2337 \
2338 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
2339 , ResultProbe); \
2340 \
2341 JNI_ENTRY(ResultType, \
2342 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
2343 JNIWrapper("CallStatic" XSTR(Result) "Method"); \
2344 \
2345 EntryProbe; \
2346 ResultType ret = 0;\
2347 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
2348 (const ResultType&)ret);\
2349 \
2350 va_list args; \
2351 va_start(args, methodID); \
2352 JavaValue jvalue(Tag); \
2353 JNI_ArgumentPusherVaArg ap(methodID, args); \
2354 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2355 va_end(args); \
2356 ret = jvalue.get_##ResultType(); \
2357 return ret;\
2358 JNI_END
2359
2360 // the runtime type of subword integral basic types is integer
2361 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN
2362 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2363 HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(_ret_ref));
2364 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE
2365 , HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2366 HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(_ret_ref));
2367 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR
2368 , HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2369 HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(_ret_ref));
2370 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT
2371 , HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2372 HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(_ret_ref));
2373
2374 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT
2375 , HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2376 HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(_ret_ref));
2377 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT
2378 , HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2379 HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(_ret_ref));
2380 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG
2381 , HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2382 HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(_ret_ref));
2383 // Float and double probes don't return value because dtrace doesn't currently support it
2384 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT
2385 , HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2386 HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN());
2387 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE
2388 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
2389 HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN());
2390
2391 #define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \
2392 , EntryProbe, ResultProbe) \
2393 \
2394 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \
2395 , ResultProbe); \
2396 \
2397 JNI_ENTRY(ResultType, \
2398 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
2399 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
2400 \
2401 EntryProbe; \
2402 ResultType ret = 0;\
2403 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
2404 (const ResultType&)ret);\
2405 \
2406 JavaValue jvalue(Tag); \
2407 JNI_ArgumentPusherVaArg ap(methodID, args); \
2408 /* Make sure class is initialized before trying to invoke its method */ \
2409 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls))); \
2410 k()->initialize(CHECK_0); \
2411 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2412 va_end(args); \
2413 ret = jvalue.get_##ResultType(); \
2414 return ret;\
2415 JNI_END
2416
2417 // the runtime type of subword integral basic types is integer
2418 DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN
2419 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2420 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref));
2421 DEFINE_CALLSTATICMETHODV(jbyte, Byte, T_BYTE
2422 , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2423 HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref));
2424 DEFINE_CALLSTATICMETHODV(jchar, Char, T_CHAR
2425 , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2426 HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref));
2427 DEFINE_CALLSTATICMETHODV(jshort, Short, T_SHORT
2428 , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2429 HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref));
2430
2431 DEFINE_CALLSTATICMETHODV(jobject, Object, T_OBJECT
2432 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2433 HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(_ret_ref));
2434 DEFINE_CALLSTATICMETHODV(jint, Int, T_INT
2435 , HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2436 HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(_ret_ref));
2437 DEFINE_CALLSTATICMETHODV(jlong, Long, T_LONG
2438 , HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2439 HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(_ret_ref));
2440 // Float and double probes don't return value because dtrace doesn't currently support it
2441 DEFINE_CALLSTATICMETHODV(jfloat, Float, T_FLOAT
2442 , HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2443 HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN());
2444 DEFINE_CALLSTATICMETHODV(jdouble, Double, T_DOUBLE
2445 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
2446 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN());
2447
2448 #define DEFINE_CALLSTATICMETHODA(ResultType, Result, Tag \
2449 , EntryProbe, ResultProbe) \
2450 \
2451 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType \
2452 , ResultProbe); \
2453 \
2454 JNI_ENTRY(ResultType, \
2455 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
2456 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
2457 \
2458 EntryProbe; \
2459 ResultType ret = 0;\
2460 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
2461 (const ResultType&)ret);\
2462 \
2463 JavaValue jvalue(Tag); \
2464 JNI_ArgumentPusherArray ap(methodID, args); \
2465 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
2466 ret = jvalue.get_##ResultType(); \
2467 return ret;\
2468 JNI_END
2469
2470 // the runtime type of subword integral basic types is integer
2471 DEFINE_CALLSTATICMETHODA(jboolean, Boolean, T_BOOLEAN
2472 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2473 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(_ret_ref));
2474 DEFINE_CALLSTATICMETHODA(jbyte, Byte, T_BYTE
2475 , HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2476 HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(_ret_ref));
2477 DEFINE_CALLSTATICMETHODA(jchar, Char, T_CHAR
2478 , HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2479 HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(_ret_ref));
2480 DEFINE_CALLSTATICMETHODA(jshort, Short, T_SHORT
2481 , HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2482 HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(_ret_ref));
2483
2484 DEFINE_CALLSTATICMETHODA(jobject, Object, T_OBJECT
2485 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2486 HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(_ret_ref));
2487 DEFINE_CALLSTATICMETHODA(jint, Int, T_INT
2488 , HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2489 HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(_ret_ref));
2490 DEFINE_CALLSTATICMETHODA(jlong, Long, T_LONG
2491 , HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2492 HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(_ret_ref));
2493 // Float and double probes don't return value because dtrace doesn't currently support it
2494 DEFINE_CALLSTATICMETHODA(jfloat, Float, T_FLOAT
2495 , HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2496 HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN());
2497 DEFINE_CALLSTATICMETHODA(jdouble, Double, T_DOUBLE
2498 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
2499 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN());
2500
2501 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod
2502 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
2503 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
2504 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
2505 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
2506 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
2507 #endif /* USDT2 */
2508
2509 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
2510 JNIWrapper("CallStaticVoidMethod");
2511 #ifndef USDT2
2512 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID);
2513 #else /* USDT2 */
2514 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(
2515 env, cls, (uintptr_t) methodID);
2516 #endif /* USDT2 */
2517 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
2518
2519 va_list args;
2520 va_start(args, methodID);
2521 JavaValue jvalue(T_VOID);
2522 JNI_ArgumentPusherVaArg ap(methodID, args);
2523 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2524 va_end(args);
2525 JNI_END
2526
2527
2528 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
2529 JNIWrapper("CallStaticVoidMethodV");
2530 #ifndef USDT2
2531 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
2532 #else /* USDT2 */
2533 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(
2534 env, cls, (uintptr_t) methodID);
2535 #endif /* USDT2 */
2536 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
2537
2538 JavaValue jvalue(T_VOID);
2539 JNI_ArgumentPusherVaArg ap(methodID, args);
2540 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2541 JNI_END
2542
2543
2544 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
2545 JNIWrapper("CallStaticVoidMethodA");
2546 #ifndef USDT2
2547 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
2548 #else /* USDT2 */
2549 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(
2550 env, cls, (uintptr_t) methodID);
2551 #endif /* USDT2 */
2552 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
2553
2554 JavaValue jvalue(T_VOID);
2555 JNI_ArgumentPusherArray ap(methodID, args);
2556 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
2557 JNI_END
2558
2559
2560 //
2561 // Accessing Fields
2562 //
2563
2564
2565 #ifndef USDT2
2566 DT_RETURN_MARK_DECL(GetFieldID, jfieldID);
2567 #else /* USDT2 */
2568 DT_RETURN_MARK_DECL(GetFieldID, jfieldID
2569 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
2570 #endif /* USDT2 */
2571
2572 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
2573 const char *name, const char *sig))
2574 JNIWrapper("GetFieldID");
2575 #ifndef USDT2
2576 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig);
2577 #else /* USDT2 */
2578 HOTSPOT_JNI_GETFIELDID_ENTRY(
2579 env, clazz, (char *) name, (char *) sig);
2580 #endif /* USDT2 */
2581 jfieldID ret = 0;
2582 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
2583
2584 // The class should have been loaded (we have an instance of the class
2585 // passed in) so the field and signature should already be in the symbol
2586 // table. If they're not there, the field doesn't exist.
2587 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
2588 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
2589 if (fieldname == NULL || signame == NULL) {
2590 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2591 }
2592 KlassHandle k(THREAD,
2593 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
2594 // Make sure class is initialized before handing id's out to fields
2595 k()->initialize(CHECK_NULL);
2596
2597 fieldDescriptor fd;
2598 if (!k()->oop_is_instance() ||
2599 !InstanceKlass::cast(k())->find_field(fieldname, signame, false, &fd)) {
2600 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2601 }
2602
2603 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
2604 // It may also have hash bits for k, if VerifyJNIFields is turned on.
2605 ret = jfieldIDWorkaround::to_instance_jfieldID(k(), fd.offset());
2606 return ret;
2607 JNI_END
2608
2609
2610 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
2611 JNIWrapper("GetObjectField");
2612 #ifndef USDT2
2613 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID);
2614 #else /* USDT2 */
2615 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(
2616 env, obj, (uintptr_t) fieldID);
2617 #endif /* USDT2 */
2618 oop o = JNIHandles::resolve_non_null(obj);
2619 Klass* k = o->klass();
2620 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2621 // Keep JVMTI addition small and only check enabled flag here.
2622 // jni_GetField_probe() assumes that is okay to create handles.
2623 if (JvmtiExport::should_post_field_access()) {
2624 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
2625 }
2626 jobject ret = JNIHandles::make_local(env, o->obj_field(offset));
2627 #if INCLUDE_ALL_GCS
2628 // If G1 is enabled and we are accessing the value of the referent
2629 // field in a reference object then we need to register a non-null
2630 // referent with the SATB barrier.
2631 if (UseG1GC) {
2632 bool needs_barrier = false;
2633
2634 if (ret != NULL &&
2635 offset == java_lang_ref_Reference::referent_offset &&
2636 InstanceKlass::cast(k)->reference_type() != REF_NONE) {
2637 assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
2638 needs_barrier = true;
2639 }
2640
2641 if (needs_barrier) {
2642 oop referent = JNIHandles::resolve(ret);
2643 G1SATBCardTableModRefBS::enqueue(referent);
2644 }
2645 }
2646 #endif // INCLUDE_ALL_GCS
2647 #ifndef USDT2
2648 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
2649 #else /* USDT2 */
2650 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(
2651 ret);
2652 #endif /* USDT2 */
2653 return ret;
2654 JNI_END
2655
2656
2657 #ifndef USDT2
2658 #define DEFINE_GETFIELD(Return,Fieldname,Result) \
2659 \
2660 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\
2661 \
2662 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
2663 JNIWrapper("Get" XSTR(Result) "Field"); \
2664 \
2665 DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\
2666 Return ret = 0;\
2667 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
2668 \
2669 oop o = JNIHandles::resolve_non_null(obj); \
2670 Klass* k = o->klass(); \
2671 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2672 /* Keep JVMTI addition small and only check enabled flag here. */ \
2673 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
2674 /* and creates a ResetNoHandleMark. */ \
2675 if (JvmtiExport::should_post_field_access()) { \
2676 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
2677 } \
2678 ret = o->Fieldname##_field(offset); \
2679 return ret; \
2680 JNI_END
2681
2682 DEFINE_GETFIELD(jboolean, bool, Boolean)
2683 DEFINE_GETFIELD(jbyte, byte, Byte)
2684 DEFINE_GETFIELD(jchar, char, Char)
2685 DEFINE_GETFIELD(jshort, short, Short)
2686 DEFINE_GETFIELD(jint, int, Int)
2687 DEFINE_GETFIELD(jlong, long, Long)
2688 DEFINE_GETFIELD(jfloat, float, Float)
2689 DEFINE_GETFIELD(jdouble, double, Double)
2690
2691 #else /* USDT2 */
2692
2693 #define DEFINE_GETFIELD(Return,Fieldname,Result \
2694 , EntryProbe, ReturnProbe) \
2695 \
2696 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
2697 , ReturnProbe); \
2698 \
2699 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
2700 JNIWrapper("Get" XSTR(Result) "Field"); \
2701 \
2702 EntryProbe; \
2703 Return ret = 0;\
2704 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
2705 \
2706 oop o = JNIHandles::resolve_non_null(obj); \
2707 Klass* k = o->klass(); \
2708 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2709 /* Keep JVMTI addition small and only check enabled flag here. */ \
2710 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
2711 /* and creates a ResetNoHandleMark. */ \
2712 if (JvmtiExport::should_post_field_access()) { \
2713 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
2714 } \
2715 ret = o->Fieldname##_field(offset); \
2716 return ret; \
2717 JNI_END
2718
2719 DEFINE_GETFIELD(jboolean, bool, Boolean
2720 , HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2721 HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(_ret_ref))
2722 DEFINE_GETFIELD(jbyte, byte, Byte
2723 , HOTSPOT_JNI_GETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2724 HOTSPOT_JNI_GETBYTEFIELD_RETURN(_ret_ref))
2725 DEFINE_GETFIELD(jchar, char, Char
2726 , HOTSPOT_JNI_GETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2727 HOTSPOT_JNI_GETCHARFIELD_RETURN(_ret_ref))
2728 DEFINE_GETFIELD(jshort, short, Short
2729 , HOTSPOT_JNI_GETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2730 HOTSPOT_JNI_GETSHORTFIELD_RETURN(_ret_ref))
2731 DEFINE_GETFIELD(jint, int, Int
2732 , HOTSPOT_JNI_GETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2733 HOTSPOT_JNI_GETINTFIELD_RETURN(_ret_ref))
2734 DEFINE_GETFIELD(jlong, long, Long
2735 , HOTSPOT_JNI_GETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2736 HOTSPOT_JNI_GETLONGFIELD_RETURN(_ret_ref))
2737 // Float and double probes don't return value because dtrace doesn't currently support it
2738 DEFINE_GETFIELD(jfloat, float, Float
2739 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2740 HOTSPOT_JNI_GETFLOATFIELD_RETURN())
2741 DEFINE_GETFIELD(jdouble, double, Double
2742 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2743 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
2744 #endif /* USDT2 */
2745
2746 address jni_GetBooleanField_addr() {
2747 return (address)jni_GetBooleanField;
2748 }
2749 address jni_GetByteField_addr() {
2750 return (address)jni_GetByteField;
2751 }
2752 address jni_GetCharField_addr() {
2753 return (address)jni_GetCharField;
2754 }
2755 address jni_GetShortField_addr() {
2756 return (address)jni_GetShortField;
2757 }
2758 address jni_GetIntField_addr() {
2759 return (address)jni_GetIntField;
2760 }
2761 address jni_GetLongField_addr() {
2762 return (address)jni_GetLongField;
2763 }
2764 address jni_GetFloatField_addr() {
2765 return (address)jni_GetFloatField;
2766 }
2767 address jni_GetDoubleField_addr() {
2768 return (address)jni_GetDoubleField;
2769 }
2770
2771 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
2772 JNIWrapper("SetObjectField");
2773 #ifndef USDT2
2774 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value);
2775 #else /* USDT2 */
2776 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(
2777 env, obj, (uintptr_t) fieldID, value);
2778 #endif /* USDT2 */
2779 oop o = JNIHandles::resolve_non_null(obj);
2780 Klass* k = o->klass();
2781 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2782 // Keep JVMTI addition small and only check enabled flag here.
2783 // jni_SetField_probe_nh() assumes that is not okay to create handles
2784 // and creates a ResetNoHandleMark.
2785 if (JvmtiExport::should_post_field_modification()) {
2786 jvalue field_value;
2787 field_value.l = value;
2788 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
2789 }
2790 o->obj_field_put(offset, JNIHandles::resolve(value));
2791 #ifndef USDT2
2792 DTRACE_PROBE(hotspot_jni, SetObjectField__return);
2793 #else /* USDT2 */
2794 HOTSPOT_JNI_SETOBJECTFIELD_RETURN(
2795 );
2796 #endif /* USDT2 */
2797 JNI_END
2798
2799 #ifndef USDT2
2800 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
2801 \
2802 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
2803 JNIWrapper("Set" XSTR(Result) "Field"); \
2804 \
2805 FP_SELECT_##Result( \
2806 DTRACE_PROBE4(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID, value), \
2807 DTRACE_PROBE3(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID)); \
2808 \
2809 oop o = JNIHandles::resolve_non_null(obj); \
2810 Klass* k = o->klass(); \
2811 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2812 /* Keep JVMTI addition small and only check enabled flag here. */ \
2813 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
2814 /* and creates a ResetNoHandleMark. */ \
2815 if (JvmtiExport::should_post_field_modification()) { \
2816 jvalue field_value; \
2817 field_value.unionType = value; \
2818 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
2819 } \
2820 o->Fieldname##_field_put(offset, value); \
2821 DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\
2822 JNI_END
2823
2824 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z)
2825 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b)
2826 DEFINE_SETFIELD(jchar, char, Char, 'C', c)
2827 DEFINE_SETFIELD(jshort, short, Short, 'S', s)
2828 DEFINE_SETFIELD(jint, int, Int, 'I', i)
2829 DEFINE_SETFIELD(jlong, long, Long, 'J', j)
2830 DEFINE_SETFIELD(jfloat, float, Float, 'F', f)
2831 DEFINE_SETFIELD(jdouble, double, Double, 'D', d)
2832
2833 #else /* USDT2 */
2834
2835 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
2836 , EntryProbe, ReturnProbe) \
2837 \
2838 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
2839 JNIWrapper("Set" XSTR(Result) "Field"); \
2840 \
2841 EntryProbe; \
2842 \
2843 oop o = JNIHandles::resolve_non_null(obj); \
2844 Klass* k = o->klass(); \
2845 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
2846 /* Keep JVMTI addition small and only check enabled flag here. */ \
2847 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
2848 /* and creates a ResetNoHandleMark. */ \
2849 if (JvmtiExport::should_post_field_modification()) { \
2850 jvalue field_value; \
2851 field_value.unionType = value; \
2852 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
2853 } \
2854 if (SigType == 'Z') { value = ((jboolean)value) & 1; } \
2855 o->Fieldname##_field_put(offset, value); \
2856 ReturnProbe; \
2857 JNI_END
2858
2859 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z
2860 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
2861 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
2862 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b
2863 , HOTSPOT_JNI_SETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
2864 HOTSPOT_JNI_SETBYTEFIELD_RETURN())
2865 DEFINE_SETFIELD(jchar, char, Char, 'C', c
2866 , HOTSPOT_JNI_SETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
2867 HOTSPOT_JNI_SETCHARFIELD_RETURN())
2868 DEFINE_SETFIELD(jshort, short, Short, 'S', s
2869 , HOTSPOT_JNI_SETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
2870 HOTSPOT_JNI_SETSHORTFIELD_RETURN())
2871 DEFINE_SETFIELD(jint, int, Int, 'I', i
2872 , HOTSPOT_JNI_SETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
2873 HOTSPOT_JNI_SETINTFIELD_RETURN())
2874 DEFINE_SETFIELD(jlong, long, Long, 'J', j
2875 , HOTSPOT_JNI_SETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
2876 HOTSPOT_JNI_SETLONGFIELD_RETURN())
2877 // Float and double probes don't return value because dtrace doesn't currently support it
2878 DEFINE_SETFIELD(jfloat, float, Float, 'F', f
2879 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2880 HOTSPOT_JNI_SETFLOATFIELD_RETURN())
2881 DEFINE_SETFIELD(jdouble, double, Double, 'D', d
2882 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
2883 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
2884 #endif /* USDT2 */
2885
2886 #ifndef USDT2
2887 DT_RETURN_MARK_DECL(ToReflectedField, jobject);
2888 #else /* USDT2 */
2889 DT_RETURN_MARK_DECL(ToReflectedField, jobject
2890 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
2891 #endif /* USDT2 */
2892
2893 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
2894 JNIWrapper("ToReflectedField");
2895 #ifndef USDT2
2896 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
2897 env, cls, fieldID, isStatic);
2898 #else /* USDT2 */
2899 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(
2900 env, cls, (uintptr_t) fieldID, isStatic);
2901 #endif /* USDT2 */
2902 jobject ret = NULL;
2903 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
2904
2905 fieldDescriptor fd;
2906 bool found = false;
2907 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2908
2909 assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
2910
2911 if (isStatic) {
2912 // Static field. The fieldID a JNIid specifying the field holder and the offset within the Klass*.
2913 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2914 assert(id->is_static_field_id(), "invalid static field id");
2915 found = id->find_local_field(&fd);
2916 } else {
2917 // Non-static field. The fieldID is really the offset of the field within the instanceOop.
2918 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2919 found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
2920 }
2921 assert(found, "bad fieldID passed into jni_ToReflectedField");
2922 oop reflected = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL);
2923 ret = JNIHandles::make_local(env, reflected);
2924 return ret;
2925 JNI_END
2926
2927
2928 //
2929 // Accessing Static Fields
2930 //
2931 #ifndef USDT2
2932 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID);
2933 #else /* USDT2 */
2934 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2935 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2936 #endif /* USDT2 */
2937
2938 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2939 const char *name, const char *sig))
2940 JNIWrapper("GetStaticFieldID");
2941 #ifndef USDT2
2942 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig);
2943 #else /* USDT2 */
2944 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(
2945 env, clazz, (char *) name, (char *) sig);
2946 #endif /* USDT2 */
2947 jfieldID ret = NULL;
2948 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2949
2950 // The class should have been loaded (we have an instance of the class
2951 // passed in) so the field and signature should already be in the symbol
2952 // table. If they're not there, the field doesn't exist.
2953 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
2954 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
2955 if (fieldname == NULL || signame == NULL) {
2956 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2957 }
2958 KlassHandle k(THREAD,
2959 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
2960 // Make sure class is initialized before handing id's out to static fields
2961 k()->initialize(CHECK_NULL);
2962
2963 fieldDescriptor fd;
2964 if (!k()->oop_is_instance() ||
2965 !InstanceKlass::cast(k())->find_field(fieldname, signame, true, &fd)) {
2966 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2967 }
2968
2969 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
2970 JNIid* id = fd.field_holder()->jni_id_for(fd.offset());
2971 debug_only(id->set_is_static_field_id();)
2972
2973 debug_only(id->verify(fd.field_holder()));
2974
2975 ret = jfieldIDWorkaround::to_static_jfieldID(id);
2976 return ret;
2977 JNI_END
2978
2979
2980 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2981 JNIWrapper("GetStaticObjectField");
2982 #ifndef USDT2
2983 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID);
2984 #else /* USDT2 */
2985 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(
2986 env, clazz, (uintptr_t) fieldID);
2987 #endif /* USDT2 */
2988 #if INCLUDE_JNI_CHECK
2989 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2990 #endif // INCLUDE_JNI_CHECK
2991 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2992 assert(id->is_static_field_id(), "invalid static field id");
2993 // Keep JVMTI addition small and only check enabled flag here.
2994 // jni_GetField_probe() assumes that is okay to create handles.
2995 if (JvmtiExport::should_post_field_access()) {
2996 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
2997 }
2998 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
2999 #ifndef USDT2
3000 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret);
3001 #else /* USDT2 */
3002 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(
3003 ret);
3004 #endif /* USDT2 */
3005 return ret;
3006 JNI_END
3007
3008 #ifndef USDT2
3009 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \
3010 \
3011 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\
3012 \
3013 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
3014 JNIWrapper("GetStatic" XSTR(Result) "Field"); \
3015 DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\
3016 Return ret = 0;\
3017 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
3018 (const Return&)ret);\
3019 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3020 assert(id->is_static_field_id(), "invalid static field id"); \
3021 /* Keep JVMTI addition small and only check enabled flag here. */ \
3022 /* jni_GetField_probe() assumes that is okay to create handles. */ \
3023 if (JvmtiExport::should_post_field_access()) { \
3024 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
3025 } \
3026 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
3027 return ret;\
3028 JNI_END
3029
3030 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean)
3031 DEFINE_GETSTATICFIELD(jbyte, byte, Byte)
3032 DEFINE_GETSTATICFIELD(jchar, char, Char)
3033 DEFINE_GETSTATICFIELD(jshort, short, Short)
3034 DEFINE_GETSTATICFIELD(jint, int, Int)
3035 DEFINE_GETSTATICFIELD(jlong, long, Long)
3036 DEFINE_GETSTATICFIELD(jfloat, float, Float)
3037 DEFINE_GETSTATICFIELD(jdouble, double, Double)
3038
3039 #else /* USDT2 */
3040
3041 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
3042 , EntryProbe, ReturnProbe) \
3043 \
3044 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
3045 , ReturnProbe); \
3046 \
3047 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
3048 JNIWrapper("GetStatic" XSTR(Result) "Field"); \
3049 EntryProbe; \
3050 Return ret = 0;\
3051 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
3052 (const Return&)ret);\
3053 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3054 assert(id->is_static_field_id(), "invalid static field id"); \
3055 /* Keep JVMTI addition small and only check enabled flag here. */ \
3056 /* jni_GetField_probe() assumes that is okay to create handles. */ \
3057 if (JvmtiExport::should_post_field_access()) { \
3058 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
3059 } \
3060 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
3061 return ret;\
3062 JNI_END
3063
3064 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean
3065 , HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(_ret_ref))
3066 DEFINE_GETSTATICFIELD(jbyte, byte, Byte
3067 , HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(_ret_ref) )
3068 DEFINE_GETSTATICFIELD(jchar, char, Char
3069 , HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(_ret_ref) )
3070 DEFINE_GETSTATICFIELD(jshort, short, Short
3071 , HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(_ret_ref) )
3072 DEFINE_GETSTATICFIELD(jint, int, Int
3073 , HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(_ret_ref) )
3074 DEFINE_GETSTATICFIELD(jlong, long, Long
3075 , HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(_ret_ref) )
3076 // Float and double probes don't return value because dtrace doesn't currently support it
3077 DEFINE_GETSTATICFIELD(jfloat, float, Float
3078 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() )
3079 DEFINE_GETSTATICFIELD(jdouble, double, Double
3080 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() )
3081 #endif /* USDT2 */
3082
3083 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
3084 JNIWrapper("SetStaticObjectField");
3085 #ifndef USDT2
3086 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value);
3087 #else /* USDT2 */
3088 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(
3089 env, clazz, (uintptr_t) fieldID, value);
3090 #endif /* USDT2 */
3091 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
3092 assert(id->is_static_field_id(), "invalid static field id");
3093 // Keep JVMTI addition small and only check enabled flag here.
3094 // jni_SetField_probe() assumes that is okay to create handles.
3095 if (JvmtiExport::should_post_field_modification()) {
3096 jvalue field_value;
3097 field_value.l = value;
3098 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
3099 }
3100 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
3101 #ifndef USDT2
3102 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return);
3103 #else /* USDT2 */
3104 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN(
3105 );
3106 #endif /* USDT2 */
3107 JNI_END
3108
3109
3110 #ifndef USDT2
3111 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \
3112 \
3113 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
3114 JNIWrapper("SetStatic" XSTR(Result) "Field"); \
3115 FP_SELECT_##Result( \
3116 DTRACE_PROBE4(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID, value), \
3117 DTRACE_PROBE3(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID)); \
3118 \
3119 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3120 assert(id->is_static_field_id(), "invalid static field id"); \
3121 /* Keep JVMTI addition small and only check enabled flag here. */ \
3122 /* jni_SetField_probe() assumes that is okay to create handles. */ \
3123 if (JvmtiExport::should_post_field_modification()) { \
3124 jvalue field_value; \
3125 field_value.unionType = value; \
3126 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
3127 } \
3128 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
3129 DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\
3130 JNI_END
3131
3132 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z)
3133 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b)
3134 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c)
3135 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s)
3136 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i)
3137 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j)
3138 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f)
3139 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d)
3140
3141 #else /* USDT2 */
3142
3143 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
3144 , EntryProbe, ReturnProbe) \
3145 \
3146 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
3147 JNIWrapper("SetStatic" XSTR(Result) "Field"); \
3148 EntryProbe; \
3149 \
3150 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
3151 assert(id->is_static_field_id(), "invalid static field id"); \
3152 /* Keep JVMTI addition small and only check enabled flag here. */ \
3153 /* jni_SetField_probe() assumes that is okay to create handles. */ \
3154 if (JvmtiExport::should_post_field_modification()) { \
3155 jvalue field_value; \
3156 field_value.unionType = value; \
3157 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
3158 } \
3159 if (SigType == 'Z') { value = ((jboolean)value) & 1; } \
3160 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
3161 ReturnProbe;\
3162 JNI_END
3163
3164 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z
3165 , HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value),
3166 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
3167 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b
3168 , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
3169 HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN())
3170 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c
3171 , HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
3172 HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN())
3173 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s
3174 , HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
3175 HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN())
3176 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i
3177 , HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
3178 HOTSPOT_JNI_SETSTATICINTFIELD_RETURN())
3179 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j
3180 , HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
3181 HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN())
3182 // Float and double probes don't return value because dtrace doesn't currently support it
3183 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f
3184 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
3185 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
3186 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d
3187 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
3188 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
3189 #endif /* USDT2 */
3190
3191 //
3192 // String Operations
3193 //
3194
3195 // Unicode Interface
3196
3197 #ifndef USDT2
3198 DT_RETURN_MARK_DECL(NewString, jstring);
3199 #else /* USDT2 */
3200 DT_RETURN_MARK_DECL(NewString, jstring
3201 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
3202 #endif /* USDT2 */
3203
3204 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
3205 JNIWrapper("NewString");
3206 #ifndef USDT2
3207 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len);
3208 #else /* USDT2 */
3209 HOTSPOT_JNI_NEWSTRING_ENTRY(
3210 env, (uint16_t *) unicodeChars, len);
3211 #endif /* USDT2 */
3212 jstring ret = NULL;
3213 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
3214 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
3215 ret = (jstring) JNIHandles::make_local(env, string);
3216 return ret;
3217 JNI_END
3218
3219
3220 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
3221 JNIWrapper("GetStringLength");
3222 #ifndef USDT2
3223 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string);
3224 #else /* USDT2 */
3225 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(
3226 env, string);
3227 #endif /* USDT2 */
3228 jsize ret = 0;
3229 oop s = JNIHandles::resolve_non_null(string);
3230 if (java_lang_String::value(s) != NULL) {
3231 ret = java_lang_String::length(s);
3232 }
3233 #ifndef USDT2
3234 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
3235 #else /* USDT2 */
3236 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(
3237 ret);
3238 #endif /* USDT2 */
3239 return ret;
3240 JNI_END
3241
3242
3243 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
3244 JNIEnv *env, jstring string, jboolean *isCopy))
3245 JNIWrapper("GetStringChars");
3246 #ifndef USDT2
3247 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
3248 #else /* USDT2 */
3249 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(
3250 env, string, (uintptr_t *) isCopy);
3251 #endif /* USDT2 */
3252 jchar* buf = NULL;
3253 oop s = JNIHandles::resolve_non_null(string);
3254 typeArrayOop s_value = java_lang_String::value(s);
3255 if (s_value != NULL) {
3256 int s_len = java_lang_String::length(s);
3257 int s_offset = java_lang_String::offset(s);
3258 buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal); // add one for zero termination
3259 /* JNI Specification states return NULL on OOM */
3260 if (buf != NULL) {
3261 if (s_len > 0) {
3262 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len);
3263 }
3264 buf[s_len] = 0;
3265 //%note jni_5
3266 if (isCopy != NULL) {
3267 *isCopy = JNI_TRUE;
3268 }
3269 }
3270 }
3271 #ifndef USDT2
3272 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
3273 #else /* USDT2 */
3274 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(
3275 buf);
3276 #endif /* USDT2 */
3277 return buf;
3278 JNI_END
3279
3280
3281 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
3282 JNIWrapper("ReleaseStringChars");
3283 #ifndef USDT2
3284 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars);
3285 #else /* USDT2 */
3286 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(
3287 env, str, (uint16_t *) chars);
3288 #endif /* USDT2 */
3289 //%note jni_6
3290 if (chars != NULL) {
3291 // Since String objects are supposed to be immutable, don't copy any
3292 // new data back. A bad user will have to go after the char array.
3293 FreeHeap((void*) chars);
3294 }
3295 #ifndef USDT2
3296 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return);
3297 #else /* USDT2 */
3298 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN(
3299 );
3300 #endif /* USDT2 */
3301 JNI_END
3302
3303
3304 // UTF Interface
3305
3306 #ifndef USDT2
3307 DT_RETURN_MARK_DECL(NewStringUTF, jstring);
3308 #else /* USDT2 */
3309 DT_RETURN_MARK_DECL(NewStringUTF, jstring
3310 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
3311 #endif /* USDT2 */
3312
3313 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
3314 JNIWrapper("NewStringUTF");
3315 #ifndef USDT2
3316 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes);
3317 #else /* USDT2 */
3318 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(
3319 env, (char *) bytes);
3320 #endif /* USDT2 */
3321 jstring ret;
3322 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
3323
3324 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
3325 ret = (jstring) JNIHandles::make_local(env, result);
3326 return ret;
3327 JNI_END
3328
3329
3330 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
3331 JNIWrapper("GetStringUTFLength");
3332 #ifndef USDT2
3333 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string);
3334 #else /* USDT2 */
3335 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(
3336 env, string);
3337 #endif /* USDT2 */
3338 jsize ret = 0;
3339 oop java_string = JNIHandles::resolve_non_null(string);
3340 if (java_lang_String::value(java_string) != NULL) {
3341 ret = java_lang_String::utf8_length(java_string);
3342 }
3343 #ifndef USDT2
3344 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
3345 #else /* USDT2 */
3346 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(
3347 ret);
3348 #endif /* USDT2 */
3349 return ret;
3350 JNI_END
3351
3352
3353 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
3354 JNIWrapper("GetStringUTFChars");
3355 #ifndef USDT2
3356 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy);
3357 #else /* USDT2 */
3358 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(
3359 env, string, (uintptr_t *) isCopy);
3360 #endif /* USDT2 */
3361 char* result = NULL;
3362 oop java_string = JNIHandles::resolve_non_null(string);
3363 if (java_lang_String::value(java_string) != NULL) {
3364 size_t length = java_lang_String::utf8_length(java_string);
3365 /* JNI Specification states return NULL on OOM */
3366 result = AllocateHeap(length + 1, mtInternal, 0, AllocFailStrategy::RETURN_NULL);
3367 if (result != NULL) {
3368 java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
3369 if (isCopy != NULL) {
3370 *isCopy = JNI_TRUE;
3371 }
3372 }
3373 }
3374 #ifndef USDT2
3375 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
3376 #else /* USDT2 */
3377 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(
3378 result);
3379 #endif /* USDT2 */
3380 return result;
3381 JNI_END
3382
3383
3384 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
3385 JNIWrapper("ReleaseStringUTFChars");
3386 #ifndef USDT2
3387 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars);
3388 #else /* USDT2 */
3389 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(
3390 env, str, (char *) chars);
3391 #endif /* USDT2 */
3392 if (chars != NULL) {
3393 FreeHeap((char*) chars);
3394 }
3395 #ifndef USDT2
3396 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return);
3397 #else /* USDT2 */
3398 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN(
3399 );
3400 #endif /* USDT2 */
3401 JNI_END
3402
3403
3404 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
3405 JNIWrapper("GetArrayLength");
3406 #ifndef USDT2
3407 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array);
3408 #else /* USDT2 */
3409 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(
3410 env, array);
3411 #endif /* USDT2 */
3412 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
3413 assert(a->is_array(), "must be array");
3414 jsize ret = a->length();
3415 #ifndef USDT2
3416 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret);
3417 #else /* USDT2 */
3418 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(
3419 ret);
3420 #endif /* USDT2 */
3421 return ret;
3422 JNI_END
3423
3424
3425 //
3426 // Object Array Operations
3427 //
3428
3429 #ifndef USDT2
3430 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray);
3431 #else /* USDT2 */
3432 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
3433 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
3434 #endif /* USDT2 */
3435
3436 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
3437 JNIWrapper("NewObjectArray");
3438 #ifndef USDT2
3439 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement);
3440 #else /* USDT2 */
3441 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(
3442 env, length, elementClass, initialElement);
3443 #endif /* USDT2 */
3444 jobjectArray ret = NULL;
3445 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
3446 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
3447 Klass* ako = ek()->array_klass(CHECK_NULL);
3448 KlassHandle ak = KlassHandle(THREAD, ako);
3449 ObjArrayKlass::cast(ak())->initialize(CHECK_NULL);
3450 objArrayOop result = ObjArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
3451 oop initial_value = JNIHandles::resolve(initialElement);
3452 if (initial_value != NULL) { // array already initialized with NULL
3453 for (int index = 0; index < length; index++) {
3454 result->obj_at_put(index, initial_value);
3455 }
3456 }
3457 ret = (jobjectArray) JNIHandles::make_local(env, result);
3458 return ret;
3459 JNI_END
3460
3461 #ifndef USDT2
3462 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject);
3463 #else /* USDT2 */
3464 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
3465 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
3466 #endif /* USDT2 */
3467
3468 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
3469 JNIWrapper("GetObjectArrayElement");
3470 #ifndef USDT2
3471 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index);
3472 #else /* USDT2 */
3473 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(
3474 env, array, index);
3475 #endif /* USDT2 */
3476 jobject ret = NULL;
3477 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
3478 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
3479 if (a->is_within_bounds(index)) {
3480 ret = JNIHandles::make_local(env, a->obj_at(index));
3481 return ret;
3482 } else {
3483 char buf[jintAsStringSize];
3484 sprintf(buf, "%d", index);
3485 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
3486 }
3487 JNI_END
3488
3489 #ifndef USDT2
3490 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement);
3491 #else /* USDT2 */
3492 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
3493 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
3494 #endif /* USDT2 */
3495
3496 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
3497 JNIWrapper("SetObjectArrayElement");
3498 #ifndef USDT2
3499 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value);
3500 #else /* USDT2 */
3501 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(
3502 env, array, index, value);
3503 #endif /* USDT2 */
3504 DT_VOID_RETURN_MARK(SetObjectArrayElement);
3505
3506 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
3507 oop v = JNIHandles::resolve(value);
3508 if (a->is_within_bounds(index)) {
3509 if (v == NULL || v->is_a(ObjArrayKlass::cast(a->klass())->element_klass())) {
3510 a->obj_at_put(index, v);
3511 } else {
3512 THROW(vmSymbols::java_lang_ArrayStoreException());
3513 }
3514 } else {
3515 char buf[jintAsStringSize];
3516 sprintf(buf, "%d", index);
3517 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
3518 }
3519 JNI_END
3520
3521
3522 #ifndef USDT2
3523 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \
3524 \
3525 DT_RETURN_MARK_DECL(New##Result##Array, Return); \
3526 \
3527 JNI_ENTRY(Return, \
3528 jni_New##Result##Array(JNIEnv *env, jsize len)) \
3529 JNIWrapper("New" XSTR(Result) "Array"); \
3530 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\
3531 Return ret = NULL;\
3532 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
3533 \
3534 oop obj= oopFactory::Allocator(len, CHECK_0); \
3535 ret = (Return) JNIHandles::make_local(env, obj); \
3536 return ret;\
3537 JNI_END
3538
3539 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean)
3540 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte)
3541 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short)
3542 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char)
3543 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int)
3544 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long)
3545 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float)
3546 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double)
3547
3548 #else /* USDT2 */
3549
3550 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
3551 ,EntryProbe,ReturnProbe) \
3552 \
3553 DT_RETURN_MARK_DECL(New##Result##Array, Return \
3554 , ReturnProbe); \
3555 \
3556 JNI_ENTRY(Return, \
3557 jni_New##Result##Array(JNIEnv *env, jsize len)) \
3558 JNIWrapper("New" XSTR(Result) "Array"); \
3559 EntryProbe; \
3560 Return ret = NULL;\
3561 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
3562 \
3563 oop obj= oopFactory::Allocator(len, CHECK_0); \
3564 ret = (Return) JNIHandles::make_local(env, obj); \
3565 return ret;\
3566 JNI_END
3567
3568 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean,
3569 HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len),
3570 HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref))
3571 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte,
3572 HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len),
3573 HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref))
3574 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short,
3575 HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len),
3576 HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref))
3577 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char,
3578 HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len),
3579 HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref))
3580 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int,
3581 HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len),
3582 HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref))
3583 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long,
3584 HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
3585 HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref))
3586 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float,
3587 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
3588 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
3589 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double,
3590 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
3591 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
3592 #endif /* USDT2 */
3593
3594 // Return an address which will fault if the caller writes to it.
3595
3596 static char* get_bad_address() {
3597 static char* bad_address = NULL;
3598 if (bad_address == NULL) {
3599 size_t size = os::vm_allocation_granularity();
3600 bad_address = os::reserve_memory(size);
3601 if (bad_address != NULL) {
3602 os::protect_memory(bad_address, size, os::MEM_PROT_READ,
3603 /*is_committed*/false);
3604 MemTracker::record_virtual_memory_type((void*)bad_address, mtInternal);
3605 }
3606 }
3607 return bad_address;
3608 }
3609
3610
3611 #ifndef USDT2
3612 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \
3613 \
3614 JNI_QUICK_ENTRY(ElementType*, \
3615 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
3616 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
3617 DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\
3618 /* allocate an chunk of memory in c land */ \
3619 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3620 ElementType* result; \
3621 int len = a->length(); \
3622 if (len == 0) { \
3623 /* Empty array: legal but useless, can't return NULL. \
3624 * Return a pointer to something useless. \
3625 * Avoid asserts in typeArrayOop. */ \
3626 result = (ElementType*)get_bad_address(); \
3627 } else { \
3628 /* JNI Specification states return NULL on OOM */ \
3629 result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
3630 if (result != NULL) { \
3631 /* copy the array to the c chunk */ \
3632 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
3633 if (isCopy) { \
3634 *isCopy = JNI_TRUE; \
3635 } \
3636 } \
3637 } \
3638 DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
3639 return result; \
3640 JNI_END
3641
3642 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
3643 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
3644 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
3645 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
3646 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int)
3647 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
3648 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
3649 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
3650
3651 #else /* USDT2 */
3652
3653 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
3654 , EntryProbe, ReturnProbe) \
3655 \
3656 JNI_QUICK_ENTRY(ElementType*, \
3657 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
3658 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
3659 EntryProbe; \
3660 /* allocate an chunk of memory in c land */ \
3661 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3662 ElementType* result; \
3663 int len = a->length(); \
3664 if (len == 0) { \
3665 /* Empty array: legal but useless, can't return NULL. \
3666 * Return a pointer to something useless. \
3667 * Avoid asserts in typeArrayOop. */ \
3668 result = (ElementType*)get_bad_address(); \
3669 } else { \
3670 /* JNI Specification states return NULL on OOM */ \
3671 result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
3672 if (result != NULL) { \
3673 /* copy the array to the c chunk */ \
3674 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
3675 if (isCopy) { \
3676 *isCopy = JNI_TRUE; \
3677 } \
3678 } \
3679 } \
3680 ReturnProbe; \
3681 return result; \
3682 JNI_END
3683
3684 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
3685 , HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3686 HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN((uintptr_t*)result))
3687 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte
3688 , HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3689 HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN((char*)result))
3690 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short
3691 , HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
3692 HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN((uint16_t*)result))
3693 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char
3694 , HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
3695 HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(result))
3696 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int
3697 , HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3698 HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN((uint32_t*)result))
3699 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long
3700 , HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3701 HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(((uintptr_t*)result)))
3702 // Float and double probes don't return value because dtrace doesn't currently support it
3703 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float
3704 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3705 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
3706 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
3707 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
3708 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
3709 #endif /* USDT2 */
3710
3711 #ifndef USDT2
3712 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \
3713 \
3714 JNI_QUICK_ENTRY(void, \
3715 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
3716 ElementType *buf, jint mode)) \
3717 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
3718 DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\
3719 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3720 int len = a->length(); \
3721 if (len != 0) { /* Empty array: nothing to free or copy. */ \
3722 if ((mode == 0) || (mode == JNI_COMMIT)) { \
3723 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
3724 } \
3725 if ((mode == 0) || (mode == JNI_ABORT)) { \
3726 FreeHeap(buf); \
3727 } \
3728 } \
3729 DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\
3730 JNI_END
3731
3732 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
3733 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
3734 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
3735 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
3736 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int)
3737 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
3738 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
3739 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
3740
3741 #else /* USDT2 */
3742
3743 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
3744 , EntryProbe, ReturnProbe);\
3745 \
3746 JNI_QUICK_ENTRY(void, \
3747 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
3748 ElementType *buf, jint mode)) \
3749 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
3750 EntryProbe; \
3751 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3752 int len = a->length(); \
3753 if (len != 0) { /* Empty array: nothing to free or copy. */ \
3754 if ((mode == 0) || (mode == JNI_COMMIT)) { \
3755 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
3756 } \
3757 if ((mode == 0) || (mode == JNI_ABORT)) { \
3758 FreeHeap(buf); \
3759 } \
3760 } \
3761 ReturnProbe; \
3762 JNI_END
3763
3764 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
3765 , HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
3766 HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN())
3767 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte
3768 , HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(env, array, (char *) buf, mode),
3769 HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN())
3770 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short
3771 , HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
3772 HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN())
3773 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char
3774 , HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
3775 HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN())
3776 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int
3777 , HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(env, array, (uint32_t *) buf, mode),
3778 HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN())
3779 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long
3780 , HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
3781 HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN())
3782 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float
3783 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
3784 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
3785 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
3786 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
3787 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
3788 #endif /* USDT2 */
3789
3790 #ifndef USDT2
3791 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
3792 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\
3793 \
3794 JNI_ENTRY(void, \
3795 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3796 jsize len, ElementType *buf)) \
3797 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
3798 DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\
3799 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
3800 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3801 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
3802 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3803 } else { \
3804 if (len > 0) { \
3805 int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
3806 memcpy((u_char*) buf, \
3807 (u_char*) src->Tag##_at_addr(start), \
3808 len << sc); \
3809 } \
3810 } \
3811 JNI_END
3812
3813 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool)
3814 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
3815 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
3816 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
3817 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int)
3818 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long)
3819 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
3820 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
3821
3822 #else /* USDT2 */
3823
3824 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
3825 , EntryProbe, ReturnProbe); \
3826 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
3827 , ReturnProbe); \
3828 \
3829 JNI_ENTRY(void, \
3830 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3831 jsize len, ElementType *buf)) \
3832 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
3833 EntryProbe; \
3834 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
3835 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3836 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
3837 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3838 } else { \
3839 if (len > 0) { \
3840 int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
3841 memcpy((u_char*) buf, \
3842 (u_char*) src->Tag##_at_addr(start), \
3843 len << sc); \
3844 } \
3845 } \
3846 JNI_END
3847
3848 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool
3849 , HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
3850 HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN());
3851 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte
3852 , HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
3853 HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN());
3854 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short
3855 , HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
3856 HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN());
3857 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char
3858 , HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t*) buf),
3859 HOTSPOT_JNI_GETCHARARRAYREGION_RETURN());
3860 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int
3861 , HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t*) buf),
3862 HOTSPOT_JNI_GETINTARRAYREGION_RETURN());
3863 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long
3864 , HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
3865 HOTSPOT_JNI_GETLONGARRAYREGION_RETURN());
3866 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float
3867 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
3868 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
3869 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
3870 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
3871 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
3872 #endif /* USDT2 */
3873
3874 #ifndef USDT2
3875 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
3876 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\
3877 \
3878 JNI_ENTRY(void, \
3879 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3880 jsize len, const ElementType *buf)) \
3881 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
3882 DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\
3883 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
3884 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3885 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
3886 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3887 } else { \
3888 if (len > 0) { \
3889 int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
3890 memcpy((u_char*) dst->Tag##_at_addr(start), \
3891 (u_char*) buf, \
3892 len << sc); \
3893 } \
3894 } \
3895 JNI_END
3896
3897 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool)
3898 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
3899 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
3900 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
3901 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int)
3902 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long)
3903 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
3904 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
3905
3906 #else /* USDT2 */
3907
3908 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
3909 , EntryProbe, ReturnProbe); \
3910 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
3911 ,ReturnProbe); \
3912 \
3913 JNI_ENTRY(void, \
3914 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
3915 jsize len, const ElementType *buf)) \
3916 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
3917 EntryProbe; \
3918 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
3919 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
3920 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
3921 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
3922 } else { \
3923 if (len > 0) { \
3924 int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
3925 memcpy((u_char*) dst->Tag##_at_addr(start), \
3926 (u_char*) buf, \
3927 len << sc); \
3928 } \
3929 } \
3930 JNI_END
3931
3932 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool
3933 , HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *)buf),
3934 HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN())
3935 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte
3936 , HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
3937 HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN())
3938 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short
3939 , HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
3940 HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN())
3941 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char
3942 , HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
3943 HOTSPOT_JNI_SETCHARARRAYREGION_RETURN())
3944 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int
3945 , HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t *) buf),
3946 HOTSPOT_JNI_SETINTARRAYREGION_RETURN())
3947 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long
3948 , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
3949 HOTSPOT_JNI_SETLONGARRAYREGION_RETURN())
3950 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float
3951 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
3952 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
3953 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
3954 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
3955 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
3956 #endif /* USDT2 */
3957
3958
3959 //
3960 // Interception of natives
3961 //
3962
3963 // The RegisterNatives call being attempted tried to register with a method that
3964 // is not native. Ask JVM TI what prefixes have been specified. Then check
3965 // to see if the native method is now wrapped with the prefixes. See the
3966 // SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
3967 static Method* find_prefixed_native(KlassHandle k,
3968 Symbol* name, Symbol* signature, TRAPS) {
3969 #if INCLUDE_JVMTI
3970 ResourceMark rm(THREAD);
3971 Method* method;
3972 int name_len = name->utf8_length();
3973 char* name_str = name->as_utf8();
3974 int prefix_count;
3975 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
3976 for (int i = 0; i < prefix_count; i++) {
3977 char* prefix = prefixes[i];
3978 int prefix_len = (int)strlen(prefix);
3979
3980 // try adding this prefix to the method name and see if it matches another method name
3981 int trial_len = name_len + prefix_len;
3982 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
3983 strcpy(trial_name_str, prefix);
3984 strcat(trial_name_str, name_str);
3985 TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
3986 if (trial_name == NULL) {
3987 continue; // no such symbol, so this prefix wasn't used, try the next prefix
3988 }
3989 method = k()->lookup_method(trial_name, signature);
3990 if (method == NULL) {
3991 continue; // signature doesn't match, try the next prefix
3992 }
3993 if (method->is_native()) {
3994 method->set_is_prefixed_native();
3995 return method; // wahoo, we found a prefixed version of the method, return it
3996 }
3997 // found as non-native, so prefix is good, add it, probably just need more prefixes
3998 name_len = trial_len;
3999 name_str = trial_name_str;
4000 }
4001 #endif // INCLUDE_JVMTI
4002 return NULL; // not found
4003 }
4004
4005 static bool register_native(KlassHandle k, Symbol* name, Symbol* signature, address entry, TRAPS) {
4006 Method* method = k()->lookup_method(name, signature);
4007 if (method == NULL) {
4008 ResourceMark rm;
4009 stringStream st;
4010 st.print("Method %s name or signature does not match",
4011 Method::name_and_sig_as_C_string(k(), name, signature));
4012 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
4013 }
4014 if (!method->is_native()) {
4015 // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
4016 method = find_prefixed_native(k, name, signature, THREAD);
4017 if (method == NULL) {
4018 ResourceMark rm;
4019 stringStream st;
4020 st.print("Method %s is not declared as native",
4021 Method::name_and_sig_as_C_string(k(), name, signature));
4022 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
4023 }
4024 }
4025
4026 if (entry != NULL) {
4027 method->set_native_function(entry,
4028 Method::native_bind_event_is_interesting);
4029 } else {
4030 method->clear_native_function();
4031 }
4032 if (PrintJNIResolving) {
4033 ResourceMark rm(THREAD);
4034 tty->print_cr("[Registering JNI native method %s.%s]",
4035 method->method_holder()->external_name(),
4036 method->name()->as_C_string());
4037 }
4038 return true;
4039 }
4040
4041 #ifndef USDT2
4042 DT_RETURN_MARK_DECL(RegisterNatives, jint);
4043 #else /* USDT2 */
4044 DT_RETURN_MARK_DECL(RegisterNatives, jint
4045 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
4046 #endif /* USDT2 */
4047
4048 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
4049 const JNINativeMethod *methods,
4050 jint nMethods))
4051 JNIWrapper("RegisterNatives");
4052 #ifndef USDT2
4053 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
4054 #else /* USDT2 */
4055 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(
4056 env, clazz, (void *) methods, nMethods);
4057 #endif /* USDT2 */
4058 jint ret = 0;
4059 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
4060
4061 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
4062
4063 for (int index = 0; index < nMethods; index++) {
4064 const char* meth_name = methods[index].name;
4065 const char* meth_sig = methods[index].signature;
4066 int meth_name_len = (int)strlen(meth_name);
4067
4068 // The class should have been loaded (we have an instance of the class
4069 // passed in) so the method and signature should already be in the symbol
4070 // table. If they're not there, the method doesn't exist.
4071 TempNewSymbol name = SymbolTable::probe(meth_name, meth_name_len);
4072 TempNewSymbol signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
4073
4074 if (name == NULL || signature == NULL) {
4075 ResourceMark rm;
4076 stringStream st;
4077 st.print("Method %s.%s%s not found", h_k()->external_name(), meth_name, meth_sig);
4078 // Must return negative value on failure
4079 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
4080 }
4081
4082 bool res = register_native(h_k, name, signature,
4083 (address) methods[index].fnPtr, THREAD);
4084 if (!res) {
4085 ret = -1;
4086 break;
4087 }
4088 }
4089 return ret;
4090 JNI_END
4091
4092
4093 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
4094 JNIWrapper("UnregisterNatives");
4095 #ifndef USDT2
4096 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz);
4097 #else /* USDT2 */
4098 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(
4099 env, clazz);
4100 #endif /* USDT2 */
4101 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
4102 //%note jni_2
4103 if (k->oop_is_instance()) {
4104 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
4105 Method* m = InstanceKlass::cast(k)->methods()->at(index);
4106 if (m->is_native()) {
4107 m->clear_native_function();
4108 m->set_signature_handler(NULL);
4109 }
4110 }
4111 }
4112 #ifndef USDT2
4113 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
4114 #else /* USDT2 */
4115 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(
4116 0);
4117 #endif /* USDT2 */
4118 return 0;
4119 JNI_END
4120
4121 //
4122 // Monitor functions
4123 //
4124
4125 #ifndef USDT2
4126 DT_RETURN_MARK_DECL(MonitorEnter, jint);
4127 #else /* USDT2 */
4128 DT_RETURN_MARK_DECL(MonitorEnter, jint
4129 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
4130 #endif /* USDT2 */
4131
4132 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
4133 #ifndef USDT2
4134 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj);
4135 #else /* USDT2 */
4136 HOTSPOT_JNI_MONITORENTER_ENTRY(
4137 env, jobj);
4138 #endif /* USDT2 */
4139 jint ret = JNI_ERR;
4140 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
4141
4142 // If the object is null, we can't do anything with it
4143 if (jobj == NULL) {
4144 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
4145 }
4146
4147 Handle obj(thread, JNIHandles::resolve_non_null(jobj));
4148 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
4149 ret = JNI_OK;
4150 return ret;
4151 JNI_END
4152
4153 #ifndef USDT2
4154 DT_RETURN_MARK_DECL(MonitorExit, jint);
4155 #else /* USDT2 */
4156 DT_RETURN_MARK_DECL(MonitorExit, jint
4157 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
4158 #endif /* USDT2 */
4159
4160 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
4161 #ifndef USDT2
4162 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj);
4163 #else /* USDT2 */
4164 HOTSPOT_JNI_MONITOREXIT_ENTRY(
4165 env, jobj);
4166 #endif /* USDT2 */
4167 jint ret = JNI_ERR;
4168 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
4169
4170 // Don't do anything with a null object
4171 if (jobj == NULL) {
4172 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
4173 }
4174
4175 Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
4176 ObjectSynchronizer::jni_exit(obj(), CHECK_(JNI_ERR));
4177
4178 ret = JNI_OK;
4179 return ret;
4180 JNI_END
4181
4182 //
4183 // Extensions
4184 //
4185
4186 #ifndef USDT2
4187 DT_VOID_RETURN_MARK_DECL(GetStringRegion);
4188 #else /* USDT2 */
4189 DT_VOID_RETURN_MARK_DECL(GetStringRegion
4190 , HOTSPOT_JNI_GETSTRINGREGION_RETURN());
4191 #endif /* USDT2 */
4192
4193 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
4194 JNIWrapper("GetStringRegion");
4195 #ifndef USDT2
4196 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf);
4197 #else /* USDT2 */
4198 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(
4199 env, string, start, len, buf);
4200 #endif /* USDT2 */
4201 DT_VOID_RETURN_MARK(GetStringRegion);
4202 oop s = JNIHandles::resolve_non_null(string);
4203 int s_len = java_lang_String::length(s);
4204 if (start < 0 || len < 0 || start + len > s_len) {
4205 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
4206 } else {
4207 if (len > 0) {
4208 int s_offset = java_lang_String::offset(s);
4209 typeArrayOop s_value = java_lang_String::value(s);
4210 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len);
4211 }
4212 }
4213 JNI_END
4214
4215 #ifndef USDT2
4216 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion);
4217 #else /* USDT2 */
4218 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
4219 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
4220 #endif /* USDT2 */
4221
4222 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
4223 JNIWrapper("GetStringUTFRegion");
4224 #ifndef USDT2
4225 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf);
4226 #else /* USDT2 */
4227 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(
4228 env, string, start, len, buf);
4229 #endif /* USDT2 */
4230 DT_VOID_RETURN_MARK(GetStringUTFRegion);
4231 oop s = JNIHandles::resolve_non_null(string);
4232 int s_len = java_lang_String::length(s);
4233 if (start < 0 || len < 0 || start + len > s_len) {
4234 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
4235 } else {
4236 //%note jni_7
4237 if (len > 0) {
4238 ResourceMark rm(THREAD);
4239 char *utf_region = java_lang_String::as_utf8_string(s, start, len);
4240 int utf_len = (int)strlen(utf_region);
4241 memcpy(buf, utf_region, utf_len);
4242 buf[utf_len] = 0;
4243 } else {
4244 // JDK null-terminates the buffer even in len is zero
4245 if (buf != NULL) {
4246 buf[0] = 0;
4247 }
4248 }
4249 }
4250 JNI_END
4251
4252
4253 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
4254 JNIWrapper("GetPrimitiveArrayCritical");
4255 #ifndef USDT2
4256 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy);
4257 #else /* USDT2 */
4258 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(
4259 env, array, (uintptr_t *) isCopy);
4260 #endif /* USDT2 */
4261 GC_locker::lock_critical(thread);
4262 if (isCopy != NULL) {
4263 *isCopy = JNI_FALSE;
4264 }
4265 oop a = JNIHandles::resolve_non_null(array);
4266 assert(a->is_array(), "just checking");
4267 BasicType type;
4268 if (a->is_objArray()) {
4269 type = T_OBJECT;
4270 } else {
4271 type = TypeArrayKlass::cast(a->klass())->element_type();
4272 }
4273 void* ret = arrayOop(a)->base(type);
4274 #ifndef USDT2
4275 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
4276 #else /* USDT2 */
4277 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(
4278 ret);
4279 #endif /* USDT2 */
4280 return ret;
4281 JNI_END
4282
4283
4284 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
4285 JNIWrapper("ReleasePrimitiveArrayCritical");
4286 #ifndef USDT2
4287 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode);
4288 #else /* USDT2 */
4289 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(
4290 env, array, carray, mode);
4291 #endif /* USDT2 */
4292 // The array, carray and mode arguments are ignored
4293 GC_locker::unlock_critical(thread);
4294 #ifndef USDT2
4295 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return);
4296 #else /* USDT2 */
4297 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(
4298 );
4299 #endif /* USDT2 */
4300 JNI_END
4301
4302
4303 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
4304 JNIWrapper("GetStringCritical");
4305 #ifndef USDT2
4306 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy);
4307 #else /* USDT2 */
4308 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(
4309 env, string, (uintptr_t *) isCopy);
4310 #endif /* USDT2 */
4311 GC_locker::lock_critical(thread);
4312 if (isCopy != NULL) {
4313 *isCopy = JNI_FALSE;
4314 }
4315 oop s = JNIHandles::resolve_non_null(string);
4316 int s_len = java_lang_String::length(s);
4317 typeArrayOop s_value = java_lang_String::value(s);
4318 int s_offset = java_lang_String::offset(s);
4319 const jchar* ret;
4320 if (s_len > 0) {
4321 ret = s_value->char_at_addr(s_offset);
4322 } else {
4323 ret = (jchar*) s_value->base(T_CHAR);
4324 }
4325 #ifndef USDT2
4326 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
4327 #else /* USDT2 */
4328 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN(
4329 (uint16_t *) ret);
4330 #endif /* USDT2 */
4331 return ret;
4332 JNI_END
4333
4334
4335 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
4336 JNIWrapper("ReleaseStringCritical");
4337 #ifndef USDT2
4338 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars);
4339 #else /* USDT2 */
4340 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(
4341 env, str, (uint16_t *) chars);
4342 #endif /* USDT2 */
4343 // The str and chars arguments are ignored
4344 GC_locker::unlock_critical(thread);
4345 #ifndef USDT2
4346 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return);
4347 #else /* USDT2 */
4348 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(
4349 );
4350 #endif /* USDT2 */
4351 JNI_END
4352
4353
4354 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
4355 JNIWrapper("jni_NewWeakGlobalRef");
4356 #ifndef USDT2
4357 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref);
4358 #else /* USDT2 */
4359 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(
4360 env, ref);
4361 #endif /* USDT2 */
4362 Handle ref_handle(thread, JNIHandles::resolve(ref));
4363 jweak ret = JNIHandles::make_weak_global(ref_handle);
4364 #ifndef USDT2
4365 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret);
4366 #else /* USDT2 */
4367 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(
4368 ret);
4369 #endif /* USDT2 */
4370 return ret;
4371 JNI_END
4372
4373 // Must be JNI_ENTRY (with HandleMark)
4374 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
4375 JNIWrapper("jni_DeleteWeakGlobalRef");
4376 #ifndef USDT2
4377 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref);
4378 #else /* USDT2 */
4379 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(
4380 env, ref);
4381 #endif /* USDT2 */
4382 JNIHandles::destroy_weak_global(ref);
4383 #ifndef USDT2
4384 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
4385 #else /* USDT2 */
4386 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(
4387 );
4388 #endif /* USDT2 */
4389 JNI_END
4390
4391
4392 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
4393 JNIWrapper("jni_ExceptionCheck");
4394 #ifndef USDT2
4395 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env);
4396 #else /* USDT2 */
4397 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(
4398 env);
4399 #endif /* USDT2 */
4400 jni_check_async_exceptions(thread);
4401 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
4402 #ifndef USDT2
4403 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret);
4404 #else /* USDT2 */
4405 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(
4406 ret);
4407 #endif /* USDT2 */
4408 return ret;
4409 JNI_END
4410
4411
4412 // Initialization state for three routines below relating to
4413 // java.nio.DirectBuffers
4414 static jint directBufferSupportInitializeStarted = 0;
4415 static volatile jint directBufferSupportInitializeEnded = 0;
4416 static volatile jint directBufferSupportInitializeFailed = 0;
4417 static jclass bufferClass = NULL;
4418 static jclass directBufferClass = NULL;
4419 static jclass directByteBufferClass = NULL;
4420 static jmethodID directByteBufferConstructor = NULL;
4421 static jfieldID directBufferAddressField = NULL;
4422 static jfieldID bufferCapacityField = NULL;
4423
4424 static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) {
4425 Handle loader; // null (bootstrap) loader
4426 Handle protection_domain; // null protection domain
4427
4428 TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
4429 jclass result = find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL);
4430
4431 if (TraceClassResolution && result != NULL) {
4432 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
4433 }
4434 return result;
4435 }
4436
4437 // These lookups are done with the NULL (bootstrap) ClassLoader to
4438 // circumvent any security checks that would be done by jni_FindClass.
4439 JNI_ENTRY(bool, lookupDirectBufferClasses(JNIEnv* env))
4440 {
4441 if ((bufferClass = lookupOne(env, "java/nio/Buffer", thread)) == NULL) { return false; }
4442 if ((directBufferClass = lookupOne(env, "sun/nio/ch/DirectBuffer", thread)) == NULL) { return false; }
4443 if ((directByteBufferClass = lookupOne(env, "java/nio/DirectByteBuffer", thread)) == NULL) { return false; }
4444 return true;
4445 }
4446 JNI_END
4447
4448
4449 static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
4450 if (directBufferSupportInitializeFailed) {
4451 return false;
4452 }
4453
4454 if (Atomic::cmpxchg(1, &directBufferSupportInitializeStarted, 0) == 0) {
4455 if (!lookupDirectBufferClasses(env)) {
4456 directBufferSupportInitializeFailed = 1;
4457 return false;
4458 }
4459
4460 // Make global references for these
4461 bufferClass = (jclass) env->NewGlobalRef(bufferClass);
4462 directBufferClass = (jclass) env->NewGlobalRef(directBufferClass);
4463 directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
4464
4465 // Get needed field and method IDs
4466 directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
4467 if (env->ExceptionCheck()) {
4468 env->ExceptionClear();
4469 directBufferSupportInitializeFailed = 1;
4470 return false;
4471 }
4472 directBufferAddressField = env->GetFieldID(bufferClass, "address", "J");
4473 if (env->ExceptionCheck()) {
4474 env->ExceptionClear();
4475 directBufferSupportInitializeFailed = 1;
4476 return false;
4477 }
4478 bufferCapacityField = env->GetFieldID(bufferClass, "capacity", "I");
4479 if (env->ExceptionCheck()) {
4480 env->ExceptionClear();
4481 directBufferSupportInitializeFailed = 1;
4482 return false;
4483 }
4484
4485 if ((directByteBufferConstructor == NULL) ||
4486 (directBufferAddressField == NULL) ||
4487 (bufferCapacityField == NULL)) {
4488 directBufferSupportInitializeFailed = 1;
4489 return false;
4490 }
4491
4492 directBufferSupportInitializeEnded = 1;
4493 } else {
4494 while (!directBufferSupportInitializeEnded && !directBufferSupportInitializeFailed) {
4495 // Set state as yield_all can call os:sleep. On Solaris, yield_all calls
4496 // os::sleep which requires the VM state transition. On other platforms, it
4497 // is not necessary. The following call to change the VM state is purposely
4498 // put inside the loop to avoid potential deadlock when multiple threads
4499 // try to call this method. See 6791815 for more details.
4500 ThreadInVMfromNative tivn(thread);
4501 os::yield_all();
4502 }
4503 }
4504
4505 return !directBufferSupportInitializeFailed;
4506 }
4507
4508 extern "C" jobject JNICALL jni_NewDirectByteBuffer(JNIEnv *env, void* address, jlong capacity)
4509 {
4510 // thread_from_jni_environment() will block if VM is gone.
4511 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
4512
4513 JNIWrapper("jni_NewDirectByteBuffer");
4514 #ifndef USDT2
4515 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
4516 #else /* USDT2 */
4517 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(
4518 env, address, capacity);
4519 #endif /* USDT2 */
4520
4521 if (!directBufferSupportInitializeEnded) {
4522 if (!initializeDirectBufferSupport(env, thread)) {
4523 #ifndef USDT2
4524 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL);
4525 #else /* USDT2 */
4526 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(
4527 NULL);
4528 #endif /* USDT2 */
4529 return NULL;
4530 }
4531 }
4532
4533 // Being paranoid about accidental sign extension on address
4534 jlong addr = (jlong) ((uintptr_t) address);
4535 // NOTE that package-private DirectByteBuffer constructor currently
4536 // takes int capacity
4537 jint cap = (jint) capacity;
4538 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
4539 #ifndef USDT2
4540 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret);
4541 #else /* USDT2 */
4542 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(
4543 ret);
4544 #endif /* USDT2 */
4545 return ret;
4546 }
4547
4548 #ifndef USDT2
4549 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*);
4550 #else /* USDT2 */
4551 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
4552 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
4553 #endif /* USDT2 */
4554
4555 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
4556 {
4557 // thread_from_jni_environment() will block if VM is gone.
4558 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
4559
4560 JNIWrapper("jni_GetDirectBufferAddress");
4561 #ifndef USDT2
4562 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
4563 #else /* USDT2 */
4564 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(
4565 env, buf);
4566 #endif /* USDT2 */
4567 void* ret = NULL;
4568 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
4569
4570 if (!directBufferSupportInitializeEnded) {
4571 if (!initializeDirectBufferSupport(env, thread)) {
4572 return 0;
4573 }
4574 }
4575
4576 if ((buf != NULL) && (!env->IsInstanceOf(buf, directBufferClass))) {
4577 return 0;
4578 }
4579
4580 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
4581 return ret;
4582 }
4583
4584 #ifndef USDT2
4585 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong);
4586 #else /* USDT2 */
4587 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
4588 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
4589 #endif /* USDT2 */
4590
4591 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
4592 {
4593 // thread_from_jni_environment() will block if VM is gone.
4594 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
4595
4596 JNIWrapper("jni_GetDirectBufferCapacity");
4597 #ifndef USDT2
4598 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
4599 #else /* USDT2 */
4600 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(
4601 env, buf);
4602 #endif /* USDT2 */
4603 jlong ret = -1;
4604 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
4605
4606 if (!directBufferSupportInitializeEnded) {
4607 if (!initializeDirectBufferSupport(env, thread)) {
4608 ret = 0;
4609 return ret;
4610 }
4611 }
4612
4613 if (buf == NULL) {
4614 return -1;
4615 }
4616
4617 if (!env->IsInstanceOf(buf, directBufferClass)) {
4618 return -1;
4619 }
4620
4621 // NOTE that capacity is currently an int in the implementation
4622 ret = env->GetIntField(buf, bufferCapacityField);
4623 return ret;
4624 }
4625
4626
4627 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
4628 JNIWrapper("GetVersion");
4629 #ifndef USDT2
4630 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
4631 #else /* USDT2 */
4632 HOTSPOT_JNI_GETVERSION_ENTRY(
4633 env);
4634 #endif /* USDT2 */
4635 #ifndef USDT2
4636 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
4637 #else /* USDT2 */
4638 HOTSPOT_JNI_GETVERSION_RETURN(
4639 CurrentVersion);
4640 #endif /* USDT2 */
4641 return CurrentVersion;
4642 JNI_END
4643
4644 extern struct JavaVM_ main_vm;
4645
4646 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
4647 JNIWrapper("jni_GetJavaVM");
4648 #ifndef USDT2
4649 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm);
4650 #else /* USDT2 */
4651 HOTSPOT_JNI_GETJAVAVM_ENTRY(
4652 env, (void **) vm);
4653 #endif /* USDT2 */
4654 *vm = (JavaVM *)(&main_vm);
4655 #ifndef USDT2
4656 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK);
4657 #else /* USDT2 */
4658 HOTSPOT_JNI_GETJAVAVM_RETURN(
4659 JNI_OK);
4660 #endif /* USDT2 */
4661 return JNI_OK;
4662 JNI_END
4663
4664 // Structure containing all jni functions
4665 struct JNINativeInterface_ jni_NativeInterface = {
4666 NULL,
4667 NULL,
4668 NULL,
4669
4670 NULL,
4671
4672 jni_GetVersion,
4673
4674 jni_DefineClass,
4675 jni_FindClass,
4676
4677 jni_FromReflectedMethod,
4678 jni_FromReflectedField,
4679
4680 jni_ToReflectedMethod,
4681
4682 jni_GetSuperclass,
4683 jni_IsAssignableFrom,
4684
4685 jni_ToReflectedField,
4686
4687 jni_Throw,
4688 jni_ThrowNew,
4689 jni_ExceptionOccurred,
4690 jni_ExceptionDescribe,
4691 jni_ExceptionClear,
4692 jni_FatalError,
4693
4694 jni_PushLocalFrame,
4695 jni_PopLocalFrame,
4696
4697 jni_NewGlobalRef,
4698 jni_DeleteGlobalRef,
4699 jni_DeleteLocalRef,
4700 jni_IsSameObject,
4701
4702 jni_NewLocalRef,
4703 jni_EnsureLocalCapacity,
4704
4705 jni_AllocObject,
4706 jni_NewObject,
4707 jni_NewObjectV,
4708 jni_NewObjectA,
4709
4710 jni_GetObjectClass,
4711 jni_IsInstanceOf,
4712
4713 jni_GetMethodID,
4714
4715 jni_CallObjectMethod,
4716 jni_CallObjectMethodV,
4717 jni_CallObjectMethodA,
4718 jni_CallBooleanMethod,
4719 jni_CallBooleanMethodV,
4720 jni_CallBooleanMethodA,
4721 jni_CallByteMethod,
4722 jni_CallByteMethodV,
4723 jni_CallByteMethodA,
4724 jni_CallCharMethod,
4725 jni_CallCharMethodV,
4726 jni_CallCharMethodA,
4727 jni_CallShortMethod,
4728 jni_CallShortMethodV,
4729 jni_CallShortMethodA,
4730 jni_CallIntMethod,
4731 jni_CallIntMethodV,
4732 jni_CallIntMethodA,
4733 jni_CallLongMethod,
4734 jni_CallLongMethodV,
4735 jni_CallLongMethodA,
4736 jni_CallFloatMethod,
4737 jni_CallFloatMethodV,
4738 jni_CallFloatMethodA,
4739 jni_CallDoubleMethod,
4740 jni_CallDoubleMethodV,
4741 jni_CallDoubleMethodA,
4742 jni_CallVoidMethod,
4743 jni_CallVoidMethodV,
4744 jni_CallVoidMethodA,
4745
4746 jni_CallNonvirtualObjectMethod,
4747 jni_CallNonvirtualObjectMethodV,
4748 jni_CallNonvirtualObjectMethodA,
4749 jni_CallNonvirtualBooleanMethod,
4750 jni_CallNonvirtualBooleanMethodV,
4751 jni_CallNonvirtualBooleanMethodA,
4752 jni_CallNonvirtualByteMethod,
4753 jni_CallNonvirtualByteMethodV,
4754 jni_CallNonvirtualByteMethodA,
4755 jni_CallNonvirtualCharMethod,
4756 jni_CallNonvirtualCharMethodV,
4757 jni_CallNonvirtualCharMethodA,
4758 jni_CallNonvirtualShortMethod,
4759 jni_CallNonvirtualShortMethodV,
4760 jni_CallNonvirtualShortMethodA,
4761 jni_CallNonvirtualIntMethod,
4762 jni_CallNonvirtualIntMethodV,
4763 jni_CallNonvirtualIntMethodA,
4764 jni_CallNonvirtualLongMethod,
4765 jni_CallNonvirtualLongMethodV,
4766 jni_CallNonvirtualLongMethodA,
4767 jni_CallNonvirtualFloatMethod,
4768 jni_CallNonvirtualFloatMethodV,
4769 jni_CallNonvirtualFloatMethodA,
4770 jni_CallNonvirtualDoubleMethod,
4771 jni_CallNonvirtualDoubleMethodV,
4772 jni_CallNonvirtualDoubleMethodA,
4773 jni_CallNonvirtualVoidMethod,
4774 jni_CallNonvirtualVoidMethodV,
4775 jni_CallNonvirtualVoidMethodA,
4776
4777 jni_GetFieldID,
4778
4779 jni_GetObjectField,
4780 jni_GetBooleanField,
4781 jni_GetByteField,
4782 jni_GetCharField,
4783 jni_GetShortField,
4784 jni_GetIntField,
4785 jni_GetLongField,
4786 jni_GetFloatField,
4787 jni_GetDoubleField,
4788
4789 jni_SetObjectField,
4790 jni_SetBooleanField,
4791 jni_SetByteField,
4792 jni_SetCharField,
4793 jni_SetShortField,
4794 jni_SetIntField,
4795 jni_SetLongField,
4796 jni_SetFloatField,
4797 jni_SetDoubleField,
4798
4799 jni_GetStaticMethodID,
4800
4801 jni_CallStaticObjectMethod,
4802 jni_CallStaticObjectMethodV,
4803 jni_CallStaticObjectMethodA,
4804 jni_CallStaticBooleanMethod,
4805 jni_CallStaticBooleanMethodV,
4806 jni_CallStaticBooleanMethodA,
4807 jni_CallStaticByteMethod,
4808 jni_CallStaticByteMethodV,
4809 jni_CallStaticByteMethodA,
4810 jni_CallStaticCharMethod,
4811 jni_CallStaticCharMethodV,
4812 jni_CallStaticCharMethodA,
4813 jni_CallStaticShortMethod,
4814 jni_CallStaticShortMethodV,
4815 jni_CallStaticShortMethodA,
4816 jni_CallStaticIntMethod,
4817 jni_CallStaticIntMethodV,
4818 jni_CallStaticIntMethodA,
4819 jni_CallStaticLongMethod,
4820 jni_CallStaticLongMethodV,
4821 jni_CallStaticLongMethodA,
4822 jni_CallStaticFloatMethod,
4823 jni_CallStaticFloatMethodV,
4824 jni_CallStaticFloatMethodA,
4825 jni_CallStaticDoubleMethod,
4826 jni_CallStaticDoubleMethodV,
4827 jni_CallStaticDoubleMethodA,
4828 jni_CallStaticVoidMethod,
4829 jni_CallStaticVoidMethodV,
4830 jni_CallStaticVoidMethodA,
4831
4832 jni_GetStaticFieldID,
4833
4834 jni_GetStaticObjectField,
4835 jni_GetStaticBooleanField,
4836 jni_GetStaticByteField,
4837 jni_GetStaticCharField,
4838 jni_GetStaticShortField,
4839 jni_GetStaticIntField,
4840 jni_GetStaticLongField,
4841 jni_GetStaticFloatField,
4842 jni_GetStaticDoubleField,
4843
4844 jni_SetStaticObjectField,
4845 jni_SetStaticBooleanField,
4846 jni_SetStaticByteField,
4847 jni_SetStaticCharField,
4848 jni_SetStaticShortField,
4849 jni_SetStaticIntField,
4850 jni_SetStaticLongField,
4851 jni_SetStaticFloatField,
4852 jni_SetStaticDoubleField,
4853
4854 jni_NewString,
4855 jni_GetStringLength,
4856 jni_GetStringChars,
4857 jni_ReleaseStringChars,
4858
4859 jni_NewStringUTF,
4860 jni_GetStringUTFLength,
4861 jni_GetStringUTFChars,
4862 jni_ReleaseStringUTFChars,
4863
4864 jni_GetArrayLength,
4865
4866 jni_NewObjectArray,
4867 jni_GetObjectArrayElement,
4868 jni_SetObjectArrayElement,
4869
4870 jni_NewBooleanArray,
4871 jni_NewByteArray,
4872 jni_NewCharArray,
4873 jni_NewShortArray,
4874 jni_NewIntArray,
4875 jni_NewLongArray,
4876 jni_NewFloatArray,
4877 jni_NewDoubleArray,
4878
4879 jni_GetBooleanArrayElements,
4880 jni_GetByteArrayElements,
4881 jni_GetCharArrayElements,
4882 jni_GetShortArrayElements,
4883 jni_GetIntArrayElements,
4884 jni_GetLongArrayElements,
4885 jni_GetFloatArrayElements,
4886 jni_GetDoubleArrayElements,
4887
4888 jni_ReleaseBooleanArrayElements,
4889 jni_ReleaseByteArrayElements,
4890 jni_ReleaseCharArrayElements,
4891 jni_ReleaseShortArrayElements,
4892 jni_ReleaseIntArrayElements,
4893 jni_ReleaseLongArrayElements,
4894 jni_ReleaseFloatArrayElements,
4895 jni_ReleaseDoubleArrayElements,
4896
4897 jni_GetBooleanArrayRegion,
4898 jni_GetByteArrayRegion,
4899 jni_GetCharArrayRegion,
4900 jni_GetShortArrayRegion,
4901 jni_GetIntArrayRegion,
4902 jni_GetLongArrayRegion,
4903 jni_GetFloatArrayRegion,
4904 jni_GetDoubleArrayRegion,
4905
4906 jni_SetBooleanArrayRegion,
4907 jni_SetByteArrayRegion,
4908 jni_SetCharArrayRegion,
4909 jni_SetShortArrayRegion,
4910 jni_SetIntArrayRegion,
4911 jni_SetLongArrayRegion,
4912 jni_SetFloatArrayRegion,
4913 jni_SetDoubleArrayRegion,
4914
4915 jni_RegisterNatives,
4916 jni_UnregisterNatives,
4917
4918 jni_MonitorEnter,
4919 jni_MonitorExit,
4920
4921 jni_GetJavaVM,
4922
4923 jni_GetStringRegion,
4924 jni_GetStringUTFRegion,
4925
4926 jni_GetPrimitiveArrayCritical,
4927 jni_ReleasePrimitiveArrayCritical,
4928
4929 jni_GetStringCritical,
4930 jni_ReleaseStringCritical,
4931
4932 jni_NewWeakGlobalRef,
4933 jni_DeleteWeakGlobalRef,
4934
4935 jni_ExceptionCheck,
4936
4937 jni_NewDirectByteBuffer,
4938 jni_GetDirectBufferAddress,
4939 jni_GetDirectBufferCapacity,
4940
4941 // New 1_6 features
4942
4943 jni_GetObjectRefType
4944 };
4945
4946
4947 // For jvmti use to modify jni function table.
4948 // Java threads in native contiues to run until it is transitioned
4949 // to VM at safepoint. Before the transition or before it is blocked
4950 // for safepoint it may access jni function table. VM could crash if
4951 // any java thread access the jni function table in the middle of memcpy.
4952 // To avoid this each function pointers are copied automically.
4953 void copy_jni_function_table(const struct JNINativeInterface_ *new_jni_NativeInterface) {
4954 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
4955 intptr_t *a = (intptr_t *) jni_functions();
4956 intptr_t *b = (intptr_t *) new_jni_NativeInterface;
4957 for (uint i=0; i < sizeof(struct JNINativeInterface_)/sizeof(void *); i++) {
4958 Atomic::store_ptr(*b++, a++);
4959 }
4960 }
4961
4962 void quicken_jni_functions() {
4963 // Replace Get<Primitive>Field with fast versions
4964 if (UseFastJNIAccessors && !JvmtiExport::can_post_field_access()
4965 && !VerifyJNIFields && !TraceJNICalls && !CountJNICalls && !CheckJNICalls
4966 #if defined(_WINDOWS) && defined(IA32) && defined(COMPILER2)
4967 // windows x86 currently needs SEH wrapper and the gain of the fast
4968 // versions currently isn't certain for server vm on uniprocessor.
4969 && os::is_MP()
4970 #endif
4971 ) {
4972 address func;
4973 func = JNI_FastGetField::generate_fast_get_boolean_field();
4974 if (func != (address)-1) {
4975 jni_NativeInterface.GetBooleanField = (GetBooleanField_t)func;
4976 }
4977 func = JNI_FastGetField::generate_fast_get_byte_field();
4978 if (func != (address)-1) {
4979 jni_NativeInterface.GetByteField = (GetByteField_t)func;
4980 }
4981 func = JNI_FastGetField::generate_fast_get_char_field();
4982 if (func != (address)-1) {
4983 jni_NativeInterface.GetCharField = (GetCharField_t)func;
4984 }
4985 func = JNI_FastGetField::generate_fast_get_short_field();
4986 if (func != (address)-1) {
4987 jni_NativeInterface.GetShortField = (GetShortField_t)func;
4988 }
4989 func = JNI_FastGetField::generate_fast_get_int_field();
4990 if (func != (address)-1) {
4991 jni_NativeInterface.GetIntField = (GetIntField_t)func;
4992 }
4993 func = JNI_FastGetField::generate_fast_get_long_field();
4994 if (func != (address)-1) {
4995 jni_NativeInterface.GetLongField = (GetLongField_t)func;
4996 }
4997 func = JNI_FastGetField::generate_fast_get_float_field();
4998 if (func != (address)-1) {
4999 jni_NativeInterface.GetFloatField = (GetFloatField_t)func;
5000 }
5001 func = JNI_FastGetField::generate_fast_get_double_field();
5002 if (func != (address)-1) {
5003 jni_NativeInterface.GetDoubleField = (GetDoubleField_t)func;
5004 }
5005 }
5006 }
5007
5008 // Returns the function structure
5009 struct JNINativeInterface_* jni_functions() {
5010 #if INCLUDE_JNI_CHECK
5011 if (CheckJNICalls) return jni_functions_check();
5012 #endif // INCLUDE_JNI_CHECK
5013 return &jni_NativeInterface;
5014 }
5015
5016 // Returns the function structure
5017 struct JNINativeInterface_* jni_functions_nocheck() {
5018 return &jni_NativeInterface;
5019 }
5020
5021
5022 // Invocation API
5023
5024
5025 // Forward declaration
5026 extern const struct JNIInvokeInterface_ jni_InvokeInterface;
5027
5028 // Global invocation API vars
5029 volatile jint vm_created = 0;
5030 // Indicate whether it is safe to recreate VM
5031 volatile jint safe_to_recreate_vm = 1;
5032 struct JavaVM_ main_vm = {&jni_InvokeInterface};
5033
5034
5035 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */
5036 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
5037
5038 #ifndef USDT2
5039 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*);
5040 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint);
5041 #else /* USDT2 */
5042 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
5043 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
5044 #endif /* USDT2 */
5045
5046 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
5047 #ifndef USDT2
5048 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_);
5049 #else /* USDT2 */
5050 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(
5051 args_);
5052 #endif /* USDT2 */
5053 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
5054 jint ret = JNI_ERR;
5055 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
5056
5057 if (Threads::is_supported_jni_version(args->version)) {
5058 ret = JNI_OK;
5059 }
5060 // 1.1 style no longer supported in hotspot.
5061 // According the JNI spec, we should update args->version on return.
5062 // We also use the structure to communicate with launcher about default
5063 // stack size.
5064 if (args->version == JNI_VERSION_1_1) {
5065 args->version = JNI_VERSION_1_2;
5066 // javaStackSize is int in arguments structure
5067 assert(jlong(ThreadStackSize) * K < INT_MAX, "integer overflow");
5068 args->javaStackSize = (jint)(ThreadStackSize * K);
5069 }
5070 return ret;
5071 }
5072
5073 #ifndef PRODUCT
5074
5075 #include "gc_implementation/shared/gcTimer.hpp"
5076 #include "gc_interface/collectedHeap.hpp"
5077 #if INCLUDE_ALL_GCS
5078 #include "gc_implementation/g1/heapRegionRemSet.hpp"
5079 #endif
5080 #include "memory/guardedMemory.hpp"
5081 #include "utilities/quickSort.hpp"
5082 #include "utilities/ostream.hpp"
5083 #if INCLUDE_VM_STRUCTS
5084 #include "runtime/vmStructs.hpp"
5085 #endif
5086
5087 #define run_unit_test(unit_test_function_call) \
5088 tty->print_cr("Running test: " #unit_test_function_call); \
5089 unit_test_function_call
5090
5091 // Forward declaration
5092 void TestOS_test();
5093 void TestReservedSpace_test();
5094 void TestReserveMemorySpecial_test();
5095 void TestVirtualSpace_test();
5096 void TestMetaspaceAux_test();
5097 void TestMetachunk_test();
5098 void TestVirtualSpaceNode_test();
5099 void TestNewSize_test();
5100 void TestKlass_test();
5101 void Test_linked_list();
5102 void TestChunkedList_test();
5103 #if INCLUDE_ALL_GCS
5104 void TestOldFreeSpaceCalculation_test();
5105 void TestG1BiasedArray_test();
5106 void TestBufferingOopClosure_test();
5107 void TestCodeCacheRemSet_test();
5108 void FreeRegionList_test();
5109 #endif
5110
5111 void execute_internal_vm_tests() {
5112 if (ExecuteInternalVMTests) {
5113 tty->print_cr("Running internal VM tests");
5114 run_unit_test(TestOS_test());
5115 run_unit_test(TestReservedSpace_test());
5116 run_unit_test(TestReserveMemorySpecial_test());
5117 run_unit_test(TestVirtualSpace_test());
5118 run_unit_test(TestMetaspaceAux_test());
5119 run_unit_test(TestMetachunk_test());
5120 run_unit_test(TestVirtualSpaceNode_test());
5121 run_unit_test(GlobalDefinitions::test_globals());
5122 run_unit_test(GCTimerAllTest::all());
5123 run_unit_test(arrayOopDesc::test_max_array_length());
5124 run_unit_test(CollectedHeap::test_is_in());
5125 run_unit_test(QuickSort::test_quick_sort());
5126 run_unit_test(GuardedMemory::test_guarded_memory());
5127 run_unit_test(AltHashing::test_alt_hash());
5128 run_unit_test(test_loggc_filename());
5129 run_unit_test(TestNewSize_test());
5130 run_unit_test(TestKlass_test());
5131 run_unit_test(Test_linked_list());
5132 run_unit_test(TestChunkedList_test());
5133 #if INCLUDE_VM_STRUCTS
5134 run_unit_test(VMStructs::test());
5135 #endif
5136 #if INCLUDE_ALL_GCS
5137 run_unit_test(TestOldFreeSpaceCalculation_test());
5138 run_unit_test(TestG1BiasedArray_test());
5139 run_unit_test(HeapRegionRemSet::test_prt());
5140 run_unit_test(TestBufferingOopClosure_test());
5141 run_unit_test(TestCodeCacheRemSet_test());
5142 if (UseG1GC) {
5143 run_unit_test(FreeRegionList_test());
5144 }
5145 #endif
5146 tty->print_cr("All internal VM tests passed");
5147 }
5148 }
5149
5150 #undef run_unit_test
5151
5152 #endif
5153
5154 #ifndef USDT2
5155 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5156 DT_RETURN_MARK_DECL(CreateJavaVM, jint);
5157 #else /* USDT2 */
5158 DT_RETURN_MARK_DECL(CreateJavaVM, jint
5159 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
5160 #endif /* USDT2 */
5161
5162 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
5163 #ifndef USDT2
5164 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5165 #else /* USDT2 */
5166 HOTSPOT_JNI_CREATEJAVAVM_ENTRY(
5167 (void **) vm, penv, args);
5168 #endif /* USDT2 */
5169
5170 jint result = JNI_ERR;
5171 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
5172
5173 // We're about to use Atomic::xchg for synchronization. Some Zero
5174 // platforms use the GCC builtin __sync_lock_test_and_set for this,
5175 // but __sync_lock_test_and_set is not guaranteed to do what we want
5176 // on all architectures. So we check it works before relying on it.
5177 #if defined(ZERO) && defined(ASSERT)
5178 {
5179 jint a = 0xcafebabe;
5180 jint b = Atomic::xchg(0xdeadbeef, &a);
5181 void *c = &a;
5182 void *d = Atomic::xchg_ptr(&b, &c);
5183 assert(a == (jint) 0xdeadbeef && b == (jint) 0xcafebabe, "Atomic::xchg() works");
5184 assert(c == &b && d == &a, "Atomic::xchg_ptr() works");
5185 }
5186 #endif // ZERO && ASSERT
5187
5188 // At the moment it's only possible to have one Java VM,
5189 // since some of the runtime state is in global variables.
5190
5191 // We cannot use our mutex locks here, since they only work on
5192 // Threads. We do an atomic compare and exchange to ensure only
5193 // one thread can call this method at a time
5194
5195 // We use Atomic::xchg rather than Atomic::add/dec since on some platforms
5196 // the add/dec implementations are dependent on whether we are running
5197 // on a multiprocessor, and at this stage of initialization the os::is_MP
5198 // function used to determine this will always return false. Atomic::xchg
5199 // does not have this problem.
5200 if (Atomic::xchg(1, &vm_created) == 1) {
5201 return JNI_EEXIST; // already created, or create attempt in progress
5202 }
5203 if (Atomic::xchg(0, &safe_to_recreate_vm) == 0) {
5204 return JNI_ERR; // someone tried and failed and retry not allowed.
5205 }
5206
5207 assert(vm_created == 1, "vm_created is true during the creation");
5208
5209 /**
5210 * Certain errors during initialization are recoverable and do not
5211 * prevent this method from being called again at a later time
5212 * (perhaps with different arguments). However, at a certain
5213 * point during initialization if an error occurs we cannot allow
5214 * this function to be called again (or it will crash). In those
5215 * situations, the 'canTryAgain' flag is set to false, which atomically
5216 * sets safe_to_recreate_vm to 1, such that any new call to
5217 * JNI_CreateJavaVM will immediately fail using the above logic.
5218 */
5219 bool can_try_again = true;
5220
5221 result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again);
5222 if (result == JNI_OK) {
5223 JavaThread *thread = JavaThread::current();
5224 /* thread is thread_in_vm here */
5225 *vm = (JavaVM *)(&main_vm);
5226 *(JNIEnv**)penv = thread->jni_environment();
5227
5228 // Tracks the time application was running before GC
5229 RuntimeService::record_application_start();
5230
5231 if (EnableEventTracing) {
5232 TraceEvents::write_thread_start();
5233 }
5234
5235 // Notify JVMTI
5236 if (JvmtiExport::should_post_thread_life()) {
5237 JvmtiExport::post_thread_start(thread);
5238 }
5239
5240 EventThreadStart event;
5241 if (event.should_commit()) {
5242 event.set_javalangthread(java_lang_Thread::thread_id(thread->threadObj()));
5243 event.commit();
5244 }
5245
5246 #ifndef PRODUCT
5247 #ifndef CALL_TEST_FUNC_WITH_WRAPPER_IF_NEEDED
5248 #define CALL_TEST_FUNC_WITH_WRAPPER_IF_NEEDED(f) f()
5249 #endif
5250
5251 // Check if we should compile all classes on bootclasspath
5252 if (CompileTheWorld) ClassLoader::compile_the_world();
5253 if (ReplayCompiles) ciReplay::replay(thread);
5254
5255 // Some platforms (like Win*) need a wrapper around these test
5256 // functions in order to properly handle error conditions.
5257 CALL_TEST_FUNC_WITH_WRAPPER_IF_NEEDED(test_error_handler);
5258 CALL_TEST_FUNC_WITH_WRAPPER_IF_NEEDED(execute_internal_vm_tests);
5259 #endif
5260
5261 // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
5262 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
5263 } else {
5264 if (can_try_again) {
5265 // reset safe_to_recreate_vm to 1 so that retrial would be possible
5266 safe_to_recreate_vm = 1;
5267 }
5268
5269 // Creation failed. We must reset vm_created
5270 *vm = 0;
5271 *(JNIEnv**)penv = 0;
5272 // reset vm_created last to avoid race condition. Use OrderAccess to
5273 // control both compiler and architectural-based reordering.
5274 OrderAccess::release_store(&vm_created, 0);
5275 }
5276
5277 return result;
5278 }
5279
5280 #ifndef USDT2
5281 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \
5282 JavaVM**, jsize, jsize*);
5283 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint);
5284 #endif /* !USDT2 */
5285
5286 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
5287 // See bug 4367188, the wrapper can sometimes cause VM crashes
5288 // JNIWrapper("GetCreatedJavaVMs");
5289 #ifndef USDT2
5290 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
5291 vm_buf, bufLen, numVMs);
5292 #else /* USDT2 */
5293 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY(
5294 (void **) vm_buf, bufLen, (uintptr_t *) numVMs);
5295 #endif /* USDT2 */
5296 if (vm_created) {
5297 if (numVMs != NULL) *numVMs = 1;
5298 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
5299 } else {
5300 if (numVMs != NULL) *numVMs = 0;
5301 }
5302 #ifndef USDT2
5303 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK);
5304 #else /* USDT2 */
5305 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(
5306 JNI_OK);
5307 #endif /* USDT2 */
5308 return JNI_OK;
5309 }
5310
5311 extern "C" {
5312
5313 #ifndef USDT2
5314 DT_RETURN_MARK_DECL(DestroyJavaVM, jint);
5315 #else /* USDT2 */
5316 DT_RETURN_MARK_DECL(DestroyJavaVM, jint
5317 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
5318 #endif /* USDT2 */
5319
5320 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
5321 #ifndef USDT2
5322 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
5323 #else /* USDT2 */
5324 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(
5325 vm);
5326 #endif /* USDT2 */
5327 jint res = JNI_ERR;
5328 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
5329
5330 if (!vm_created) {
5331 res = JNI_ERR;
5332 return res;
5333 }
5334
5335 JNIWrapper("DestroyJavaVM");
5336 JNIEnv *env;
5337 JavaVMAttachArgs destroyargs;
5338 destroyargs.version = CurrentVersion;
5339 destroyargs.name = (char *)"DestroyJavaVM";
5340 destroyargs.group = NULL;
5341 res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs);
5342 if (res != JNI_OK) {
5343 return res;
5344 }
5345
5346 // Since this is not a JVM_ENTRY we have to set the thread state manually before entering.
5347 JavaThread* thread = JavaThread::current();
5348 ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
5349 if (Threads::destroy_vm()) {
5350 // Should not change thread state, VM is gone
5351 vm_created = false;
5352 res = JNI_OK;
5353 return res;
5354 } else {
5355 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
5356 res = JNI_ERR;
5357 return res;
5358 }
5359 }
5360
5361
5362 static jint attach_current_thread(JavaVM *vm, void **penv, void *_args, bool daemon) {
5363 JavaVMAttachArgs *args = (JavaVMAttachArgs *) _args;
5364
5365 // Check below commented out from JDK1.2fcs as well
5366 /*
5367 if (args && (args->version != JNI_VERSION_1_1 || args->version != JNI_VERSION_1_2)) {
5368 return JNI_EVERSION;
5369 }
5370 */
5371
5372 Thread* t = ThreadLocalStorage::get_thread_slow();
5373 if (t != NULL) {
5374 // If the thread has been attached this operation is a no-op
5375 *(JNIEnv**)penv = ((JavaThread*) t)->jni_environment();
5376 return JNI_OK;
5377 }
5378
5379 // Create a thread and mark it as attaching so it will be skipped by the
5380 // ThreadsListEnumerator - see CR 6404306
5381 JavaThread* thread = new JavaThread(true);
5382
5383 // Set correct safepoint info. The thread is going to call into Java when
5384 // initializing the Java level thread object. Hence, the correct state must
5385 // be set in order for the Safepoint code to deal with it correctly.
5386 thread->set_thread_state(_thread_in_vm);
5387 // Must do this before initialize_thread_local_storage
5388 thread->record_stack_base_and_size();
5389
5390 thread->initialize_thread_local_storage();
5391
5392 if (!os::create_attached_thread(thread)) {
5393 delete thread;
5394 return JNI_ERR;
5395 }
5396 // Enable stack overflow checks
5397 thread->create_stack_guard_pages();
5398
5399 thread->initialize_tlab();
5400
5401 thread->cache_global_variables();
5402
5403 // Crucial that we do not have a safepoint check for this thread, since it has
5404 // not been added to the Thread list yet.
5405 { Threads_lock->lock_without_safepoint_check();
5406 // This must be inside this lock in order to get FullGCALot to work properly, i.e., to
5407 // avoid this thread trying to do a GC before it is added to the thread-list
5408 thread->set_active_handles(JNIHandleBlock::allocate_block());
5409 Threads::add(thread, daemon);
5410 Threads_lock->unlock();
5411 }
5412 // Create thread group and name info from attach arguments
5413 oop group = NULL;
5414 char* thread_name = NULL;
5415 if (args != NULL && Threads::is_supported_jni_version(args->version)) {
5416 group = JNIHandles::resolve(args->group);
5417 thread_name = args->name; // may be NULL
5418 }
5419 if (group == NULL) group = Universe::main_thread_group();
5420
5421 // Create Java level thread object and attach it to this thread
5422 bool attach_failed = false;
5423 {
5424 EXCEPTION_MARK;
5425 HandleMark hm(THREAD);
5426 Handle thread_group(THREAD, group);
5427 thread->allocate_threadObj(thread_group, thread_name, daemon, THREAD);
5428 if (HAS_PENDING_EXCEPTION) {
5429 CLEAR_PENDING_EXCEPTION;
5430 // cleanup outside the handle mark.
5431 attach_failed = true;
5432 }
5433 }
5434
5435 if (attach_failed) {
5436 // Added missing cleanup
5437 thread->cleanup_failed_attach_current_thread();
5438 return JNI_ERR;
5439 }
5440
5441 // mark the thread as no longer attaching
5442 // this uses a fence to push the change through so we don't have
5443 // to regrab the threads_lock
5444 thread->set_done_attaching_via_jni();
5445
5446 // Set java thread status.
5447 java_lang_Thread::set_thread_status(thread->threadObj(),
5448 java_lang_Thread::RUNNABLE);
5449
5450 if (EnableEventTracing) {
5451 TraceEvents::write_thread_start();
5452 }
5453
5454 // Notify the debugger
5455 if (JvmtiExport::should_post_thread_life()) {
5456 JvmtiExport::post_thread_start(thread);
5457 }
5458
5459 EventThreadStart event;
5460 if (event.should_commit()) {
5461 event.set_javalangthread(java_lang_Thread::thread_id(thread->threadObj()));
5462 event.commit();
5463 }
5464
5465 *(JNIEnv**)penv = thread->jni_environment();
5466
5467 // Now leaving the VM, so change thread_state. This is normally automatically taken care
5468 // of in the JVM_ENTRY. But in this situation we have to do it manually. Notice, that by
5469 // using ThreadStateTransition::transition, we do a callback to the safepoint code if
5470 // needed.
5471
5472 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
5473
5474 // Perform any platform dependent FPU setup
5475 os::setup_fpu();
5476
5477 return JNI_OK;
5478 }
5479
5480
5481 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
5482 #ifndef USDT2
5483 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args);
5484 #else /* USDT2 */
5485 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(
5486 vm, penv, _args);
5487 #endif /* USDT2 */
5488 if (!vm_created) {
5489 #ifndef USDT2
5490 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
5491 #else /* USDT2 */
5492 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(
5493 (uint32_t) JNI_ERR);
5494 #endif /* USDT2 */
5495 return JNI_ERR;
5496 }
5497
5498 JNIWrapper("AttachCurrentThread");
5499 jint ret = attach_current_thread(vm, penv, _args, false);
5500 #ifndef USDT2
5501 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret);
5502 #else /* USDT2 */
5503 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(
5504 ret);
5505 #endif /* USDT2 */
5506 return ret;
5507 }
5508
5509
5510 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
5511 #ifndef USDT2
5512 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm);
5513 #else /* USDT2 */
5514 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(
5515 vm);
5516 #endif /* USDT2 */
5517 VM_Exit::block_if_vm_exited();
5518
5519 JNIWrapper("DetachCurrentThread");
5520
5521 // If the thread has been deattacted the operations is a no-op
5522 if (ThreadLocalStorage::thread() == NULL) {
5523 #ifndef USDT2
5524 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5525 #else /* USDT2 */
5526 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
5527 JNI_OK);
5528 #endif /* USDT2 */
5529 return JNI_OK;
5530 }
5531
5532 JavaThread* thread = JavaThread::current();
5533 if (thread->has_last_Java_frame()) {
5534 #ifndef USDT2
5535 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR);
5536 #else /* USDT2 */
5537 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
5538 (uint32_t) JNI_ERR);
5539 #endif /* USDT2 */
5540 // Can't detach a thread that's running java, that can't work.
5541 return JNI_ERR;
5542 }
5543
5544 // Safepoint support. Have to do call-back to safepoint code, if in the
5545 // middel of a safepoint operation
5546 ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
5547
5548 if (EnableEventTracing) {
5549 TraceEvents::write_thread_exit();
5550 }
5551
5552 // XXX: Note that JavaThread::exit() call below removes the guards on the
5553 // stack pages set up via enable_stack_{red,yellow}_zone() calls
5554 // above in jni_AttachCurrentThread. Unfortunately, while the setting
5555 // of the guards is visible in jni_AttachCurrentThread above,
5556 // the removal of the guards is buried below in JavaThread::exit()
5557 // here. The abstraction should be more symmetrically either exposed
5558 // or hidden (e.g. it could probably be hidden in the same
5559 // (platform-dependent) methods where we do alternate stack
5560 // maintenance work?)
5561 thread->exit(false, JavaThread::jni_detach);
5562 delete thread;
5563
5564 #ifndef USDT2
5565 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5566 #else /* USDT2 */
5567 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
5568 JNI_OK);
5569 #endif /* USDT2 */
5570 return JNI_OK;
5571 }
5572
5573 #ifndef USDT2
5574 DT_RETURN_MARK_DECL(GetEnv, jint);
5575 #else /* USDT2 */
5576 DT_RETURN_MARK_DECL(GetEnv, jint
5577 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
5578 #endif /* USDT2 */
5579
5580 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
5581 #ifndef USDT2
5582 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version);
5583 #else /* USDT2 */
5584 HOTSPOT_JNI_GETENV_ENTRY(
5585 vm, penv, version);
5586 #endif /* USDT2 */
5587 jint ret = JNI_ERR;
5588 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
5589
5590 if (!vm_created) {
5591 *penv = NULL;
5592 ret = JNI_EDETACHED;
5593 return ret;
5594 }
5595
5596 if (JniExportedInterface::GetExportedInterface(vm, penv, version, &ret)) {
5597 return ret;
5598 }
5599
5600 #ifndef JVMPI_VERSION_1
5601 // need these in order to be polite about older agents
5602 #define JVMPI_VERSION_1 ((jint)0x10000001)
5603 #define JVMPI_VERSION_1_1 ((jint)0x10000002)
5604 #define JVMPI_VERSION_1_2 ((jint)0x10000003)
5605 #endif // !JVMPI_VERSION_1
5606
5607 Thread* thread = ThreadLocalStorage::thread();
5608 if (thread != NULL && thread->is_Java_thread()) {
5609 if (Threads::is_supported_jni_version_including_1_1(version)) {
5610 *(JNIEnv**)penv = ((JavaThread*) thread)->jni_environment();
5611 ret = JNI_OK;
5612 return ret;
5613
5614 } else if (version == JVMPI_VERSION_1 ||
5615 version == JVMPI_VERSION_1_1 ||
5616 version == JVMPI_VERSION_1_2) {
5617 tty->print_cr("ERROR: JVMPI, an experimental interface, is no longer supported.");
5618 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
5619 ret = JNI_EVERSION;
5620 return ret;
5621 } else if (JvmtiExport::is_jvmdi_version(version)) {
5622 tty->print_cr("FATAL ERROR: JVMDI is no longer supported.");
5623 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
5624 ret = JNI_EVERSION;
5625 return ret;
5626 } else {
5627 *penv = NULL;
5628 ret = JNI_EVERSION;
5629 return ret;
5630 }
5631 } else {
5632 *penv = NULL;
5633 ret = JNI_EDETACHED;
5634 return ret;
5635 }
5636 }
5637
5638
5639 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
5640 #ifndef USDT2
5641 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args);
5642 #else /* USDT2 */
5643 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(
5644 vm, penv, _args);
5645 #endif /* USDT2 */
5646 if (!vm_created) {
5647 #ifndef USDT2
5648 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
5649 #else /* USDT2 */
5650 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(
5651 (uint32_t) JNI_ERR);
5652 #endif /* USDT2 */
5653 return JNI_ERR;
5654 }
5655
5656 JNIWrapper("AttachCurrentThreadAsDaemon");
5657 jint ret = attach_current_thread(vm, penv, _args, true);
5658 #ifndef USDT2
5659 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret);
5660 #else /* USDT2 */
5661 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(
5662 ret);
5663 #endif /* USDT2 */
5664 return ret;
5665 }
5666
5667
5668 } // End extern "C"
5669
5670 const struct JNIInvokeInterface_ jni_InvokeInterface = {
5671 NULL,
5672 NULL,
5673 NULL,
5674
5675 jni_DestroyJavaVM,
5676 jni_AttachCurrentThread,
5677 jni_DetachCurrentThread,
5678 jni_GetEnv,
5679 jni_AttachCurrentThreadAsDaemon
5680 };