1 /*
2 * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2012 Red Hat, Inc.
4 * Copyright (c) 2021, Azul Systems, Inc. All rights reserved.
5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 *
7 * This code is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 only, as
9 * published by the Free Software Foundation.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 *
25 */
26
27 #include "precompiled.hpp"
28 #include "ci/ciReplay.hpp"
29 #include "classfile/altHashing.hpp"
30 #include "classfile/classFileStream.hpp"
31 #include "classfile/classLoader.hpp"
32 #include "classfile/classLoadInfo.hpp"
33 #include "classfile/javaClasses.hpp"
34 #include "classfile/javaClasses.inline.hpp"
35 #include "classfile/javaThreadStatus.hpp"
36 #include "classfile/moduleEntry.hpp"
37 #include "classfile/modules.hpp"
38 #include "classfile/symbolTable.hpp"
39 #include "classfile/systemDictionary.hpp"
40 #include "classfile/vmClasses.hpp"
41 #include "classfile/vmSymbols.hpp"
42 #include "compiler/compiler_globals.hpp"
43 #include "gc/shared/collectedHeap.hpp"
44 #include "gc/shared/gcLocker.inline.hpp"
45 #include "gc/shared/stringdedup/stringDedup.hpp"
46 #include "interpreter/linkResolver.hpp"
47 #include "jfr/jfrEvents.hpp"
48 #include "jfr/support/jfrThreadId.hpp"
49 #include "jni.h"
50 #include "jvm.h"
51 #include "logging/log.hpp"
52 #include "memory/allocation.hpp"
53 #include "memory/allocation.inline.hpp"
54 #include "memory/oopFactory.hpp"
55 #include "memory/resourceArea.hpp"
56 #include "memory/universe.hpp"
57 #include "oops/access.inline.hpp"
58 #include "oops/arrayOop.hpp"
59 #include "oops/instanceKlass.inline.hpp"
60 #include "oops/instanceOop.hpp"
61 #include "oops/klass.inline.hpp"
62 #include "oops/markWord.hpp"
63 #include "oops/method.hpp"
64 #include "oops/objArrayKlass.hpp"
65 #include "oops/objArrayOop.inline.hpp"
66 #include "oops/oop.inline.hpp"
67 #include "oops/symbol.hpp"
68 #include "oops/typeArrayKlass.hpp"
69 #include "oops/typeArrayOop.inline.hpp"
70 #include "prims/jniCheck.hpp"
71 #include "prims/jniExport.hpp"
72 #include "prims/jniFastGetField.hpp"
73 #include "prims/jvm_misc.hpp"
74 #include "prims/jvmtiExport.hpp"
75 #include "prims/jvmtiThreadState.hpp"
76 #include "runtime/arguments.hpp"
77 #include "runtime/atomic.hpp"
78 #include "runtime/fieldDescriptor.inline.hpp"
79 #include "runtime/handles.inline.hpp"
80 #include "runtime/interfaceSupport.inline.hpp"
81 #include "runtime/java.hpp"
82 #include "runtime/javaCalls.hpp"
83 #include "runtime/javaThread.inline.hpp"
84 #include "runtime/jfieldIDWorkaround.hpp"
85 #include "runtime/jniHandles.inline.hpp"
86 #include "runtime/reflection.hpp"
87 #include "runtime/safepointVerifiers.hpp"
88 #include "runtime/sharedRuntime.hpp"
89 #include "runtime/signature.hpp"
90 #include "runtime/synchronizer.hpp"
91 #include "runtime/thread.inline.hpp"
92 #include "runtime/vmOperations.hpp"
93 #include "services/memTracker.hpp"
94 #include "services/runtimeService.hpp"
95 #include "utilities/defaultStream.hpp"
96 #include "utilities/dtrace.hpp"
97 #include "utilities/events.hpp"
98 #include "utilities/macros.hpp"
99 #include "utilities/vmError.hpp"
100 #if INCLUDE_JVMCI
101 #include "jvmci/jvmciCompiler.hpp"
102 #endif
103
104 static jint CurrentVersion = JNI_VERSION_20;
105
106 #if defined(_WIN32) && !defined(USE_VECTORED_EXCEPTION_HANDLING)
107 extern LONG WINAPI topLevelExceptionFilter(_EXCEPTION_POINTERS* );
108 #endif
109
110 // The DT_RETURN_MARK macros create a scoped object to fire the dtrace
111 // '-return' probe regardless of the return path is taken out of the function.
112 // Methods that have multiple return paths use this to avoid having to
113 // instrument each return path. Methods that use CHECK or THROW must use this
114 // since those macros can cause an immediate uninstrumented return.
115 //
116 // In order to get the return value, a reference to the variable containing
117 // the return value must be passed to the constructor of the object, and
118 // the return value must be set before return (since the mark object has
119 // a reference to it).
120 //
121 // Example:
122 // DT_RETURN_MARK_DECL(SomeFunc, int);
123 // JNI_ENTRY(int, SomeFunc, ...)
124 // int return_value = 0;
125 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
126 // foo(CHECK_0)
127 // return_value = 5;
128 // return return_value;
129 // JNI_END
130 #define DT_RETURN_MARK_DECL(name, type, probe) \
131 DTRACE_ONLY( \
132 class DTraceReturnProbeMark_##name { \
133 public: \
134 const type& _ret_ref; \
135 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \
136 ~DTraceReturnProbeMark_##name() { \
137 probe; \
138 } \
139 } \
140 )
141 // Void functions are simpler since there's no return value
142 #define DT_VOID_RETURN_MARK_DECL(name, probe) \
143 DTRACE_ONLY( \
144 class DTraceReturnProbeMark_##name { \
145 public: \
146 ~DTraceReturnProbeMark_##name() { \
147 probe; \
148 } \
149 } \
150 )
151
152 // Place these macros in the function to mark the return. Non-void
153 // functions need the type and address of the return value.
154 #define DT_RETURN_MARK(name, type, ref) \
155 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
156 #define DT_VOID_RETURN_MARK(name) \
157 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark )
158
159
160 // Use these to select distinct code for floating-point vs. non-floating point
161 // situations. Used from within common macros where we need slightly
162 // different behavior for Float/Double
163 #define FP_SELECT_Boolean(intcode, fpcode) intcode
164 #define FP_SELECT_Byte(intcode, fpcode) intcode
165 #define FP_SELECT_Char(intcode, fpcode) intcode
166 #define FP_SELECT_Short(intcode, fpcode) intcode
167 #define FP_SELECT_Object(intcode, fpcode) intcode
168 #define FP_SELECT_Int(intcode, fpcode) intcode
169 #define FP_SELECT_Long(intcode, fpcode) intcode
170 #define FP_SELECT_Float(intcode, fpcode) fpcode
171 #define FP_SELECT_Double(intcode, fpcode) fpcode
172 #define FP_SELECT(TypeName, intcode, fpcode) \
173 FP_SELECT_##TypeName(intcode, fpcode)
174
175 // Choose DT_RETURN_MARK macros based on the type: float/double -> void
176 // (dtrace doesn't do FP yet)
177 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \
178 FP_SELECT(TypeName, \
179 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )
180 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
181 FP_SELECT(TypeName, \
182 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
183
184
185 // out-of-line helpers for class jfieldIDWorkaround:
186
187 bool jfieldIDWorkaround::is_valid_jfieldID(Klass* k, jfieldID id) {
188 if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) {
189 uintptr_t as_uint = (uintptr_t) id;
190 intptr_t offset = raw_instance_offset(id);
191 if (is_checked_jfieldID(id)) {
192 if (!klass_hash_ok(k, id)) {
193 return false;
194 }
195 }
196 return InstanceKlass::cast(k)->contains_field_offset(offset);
197 } else {
198 JNIid* result = (JNIid*) id;
199 #ifdef ASSERT
200 return result != nullptr && result->is_static_field_id();
201 #else
202 return result != nullptr;
203 #endif
204 }
205 }
206
207
208 intptr_t jfieldIDWorkaround::encode_klass_hash(Klass* k, intptr_t offset) {
209 if (offset <= small_offset_mask) {
210 Klass* field_klass = k;
211 Klass* super_klass = field_klass->super();
212 // With compressed oops the most super class with nonstatic fields would
213 // be the owner of fields embedded in the header.
214 while (InstanceKlass::cast(super_klass)->has_nonstatic_fields() &&
215 InstanceKlass::cast(super_klass)->contains_field_offset(offset)) {
216 field_klass = super_klass; // super contains the field also
217 super_klass = field_klass->super();
218 }
219 debug_only(NoSafepointVerifier nosafepoint;)
220 uintptr_t klass_hash = field_klass->identity_hash();
221 return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place;
222 } else {
223 #if 0
224 #ifndef PRODUCT
225 {
226 ResourceMark rm;
227 warning("VerifyJNIFields: long offset %d in %s", offset, k->external_name());
228 }
229 #endif
230 #endif
231 return 0;
232 }
233 }
234
235 bool jfieldIDWorkaround::klass_hash_ok(Klass* k, jfieldID id) {
236 uintptr_t as_uint = (uintptr_t) id;
237 intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask;
238 do {
239 debug_only(NoSafepointVerifier nosafepoint;)
240 // Could use a non-blocking query for identity_hash here...
241 if ((k->identity_hash() & klass_mask) == klass_hash)
242 return true;
243 k = k->super();
244 } while (k != nullptr);
245 return false;
246 }
247
248 void jfieldIDWorkaround::verify_instance_jfieldID(Klass* k, jfieldID id) {
249 guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" );
250 uintptr_t as_uint = (uintptr_t) id;
251 intptr_t offset = raw_instance_offset(id);
252 if (VerifyJNIFields) {
253 if (is_checked_jfieldID(id)) {
254 guarantee(klass_hash_ok(k, id),
255 "Bug in native code: jfieldID class must match object");
256 } else {
257 #if 0
258 #ifndef PRODUCT
259 if (Verbose) {
260 ResourceMark rm;
261 warning("VerifyJNIFields: unverified offset %d for %s", offset, k->external_name());
262 }
263 #endif
264 #endif
265 }
266 }
267 guarantee(InstanceKlass::cast(k)->contains_field_offset(offset),
268 "Bug in native code: jfieldID offset must address interior of object");
269 }
270
271 // Implementation of JNI entries
272
273 DT_RETURN_MARK_DECL(DefineClass, jclass
274 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
275
276 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
277 const jbyte *buf, jsize bufLen))
278 HOTSPOT_JNI_DEFINECLASS_ENTRY(
279 env, (char*) name, loaderRef, (char*) buf, bufLen);
280
281 jclass cls = nullptr;
282 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
283
284 // Class resolution will get the class name from the .class stream if the name is null.
285 TempNewSymbol class_name = name == nullptr ? nullptr :
286 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(),
287 CHECK_NULL);
288
289 ResourceMark rm(THREAD);
290 ClassFileStream st((u1*)buf, bufLen, nullptr, ClassFileStream::verify);
291 Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));
292 Handle protection_domain;
293 ClassLoadInfo cl_info(protection_domain);
294 Klass* k = SystemDictionary::resolve_from_stream(&st, class_name,
295 class_loader,
296 cl_info,
297 CHECK_NULL);
298
299 if (log_is_enabled(Debug, class, resolve)) {
300 trace_class_resolution(k);
301 }
302
303 cls = (jclass)JNIHandles::make_local(THREAD, k->java_mirror());
304 return cls;
305 JNI_END
306
307
308
309 DT_RETURN_MARK_DECL(FindClass, jclass
310 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
311
312 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
313 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
314
315 jclass result = nullptr;
316 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
317
318 // This should be ClassNotFoundException imo.
319 TempNewSymbol class_name =
320 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(),
321 CHECK_NULL);
322
323 //%note jni_3
324 Handle protection_domain;
325 // Find calling class
326 Klass* k = thread->security_get_caller_class(0);
327 // default to the system loader when no context
328 Handle loader(THREAD, SystemDictionary::java_system_loader());
329 if (k != nullptr) {
330 // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
331 // in the correct class context.
332 if (k->class_loader() == nullptr &&
333 k->name() == vmSymbols::jdk_internal_loader_NativeLibraries()) {
334 JavaValue result(T_OBJECT);
335 JavaCalls::call_static(&result, k,
336 vmSymbols::getFromClass_name(),
337 vmSymbols::void_class_signature(),
338 CHECK_NULL);
339 // When invoked from JNI_OnLoad, NativeLibraries::getFromClass returns
340 // a non-null Class object. When invoked from JNI_OnUnload,
341 // it will return null to indicate no context.
342 oop mirror = result.get_oop();
343 if (mirror != nullptr) {
344 Klass* fromClass = java_lang_Class::as_Klass(mirror);
345 loader = Handle(THREAD, fromClass->class_loader());
346 protection_domain = Handle(THREAD, fromClass->protection_domain());
347 }
348 } else {
349 loader = Handle(THREAD, k->class_loader());
350 }
351 }
352
353 result = find_class_from_class_loader(env, class_name, true, loader,
354 protection_domain, true, thread);
355
356 if (log_is_enabled(Debug, class, resolve) && result != nullptr) {
357 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
358 }
359
360 return result;
361 JNI_END
362
363 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
364 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
365
366 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
367 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
368
369 jmethodID ret = nullptr;
370 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
371
372 // method is a handle to a java.lang.reflect.Method object
373 oop reflected = JNIHandles::resolve_non_null(method);
374 oop mirror = nullptr;
375 int slot = 0;
376
377 if (reflected->klass() == vmClasses::reflect_Constructor_klass()) {
378 mirror = java_lang_reflect_Constructor::clazz(reflected);
379 slot = java_lang_reflect_Constructor::slot(reflected);
380 } else {
381 assert(reflected->klass() == vmClasses::reflect_Method_klass(), "wrong type");
382 mirror = java_lang_reflect_Method::clazz(reflected);
383 slot = java_lang_reflect_Method::slot(reflected);
384 }
385 Klass* k1 = java_lang_Class::as_Klass(mirror);
386
387 // Make sure class is initialized before handing id's out to methods
388 k1->initialize(CHECK_NULL);
389 Method* m = InstanceKlass::cast(k1)->method_with_idnum(slot);
390 ret = m==nullptr? nullptr : m->jmethod_id(); // return null if reflected method deleted
391 return ret;
392 JNI_END
393
394 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
395 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
396
397 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
398 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
399
400 jfieldID ret = nullptr;
401 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
402
403 // field is a handle to a java.lang.reflect.Field object
404 oop reflected = JNIHandles::resolve_non_null(field);
405 oop mirror = java_lang_reflect_Field::clazz(reflected);
406 Klass* k1 = java_lang_Class::as_Klass(mirror);
407 int slot = java_lang_reflect_Field::slot(reflected);
408 int modifiers = java_lang_reflect_Field::modifiers(reflected);
409
410 // Make sure class is initialized before handing id's out to fields
411 k1->initialize(CHECK_NULL);
412
413 // First check if this is a static field
414 if (modifiers & JVM_ACC_STATIC) {
415 intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
416 JNIid* id = InstanceKlass::cast(k1)->jni_id_for(offset);
417 assert(id != nullptr, "corrupt Field object");
418 debug_only(id->set_is_static_field_id();)
419 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
420 ret = jfieldIDWorkaround::to_static_jfieldID(id);
421 return ret;
422 }
423
424 // The slot is the index of the field description in the field-array
425 // The jfieldID is the offset of the field within the object
426 // It may also have hash bits for k, if VerifyJNIFields is turned on.
427 intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
428 assert(InstanceKlass::cast(k1)->contains_field_offset(offset), "stay within object");
429 ret = jfieldIDWorkaround::to_instance_jfieldID(k1, offset);
430 return ret;
431 JNI_END
432
433
434 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
435 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
436
437 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
438 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
439
440 jobject ret = nullptr;
441 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
442
443 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
444 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
445 oop reflection_method;
446 if (m->is_initializer()) {
447 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
448 } else {
449 reflection_method = Reflection::new_method(m, false, CHECK_NULL);
450 }
451 ret = JNIHandles::make_local(THREAD, reflection_method);
452 return ret;
453 JNI_END
454
455 DT_RETURN_MARK_DECL(GetSuperclass, jclass
456 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
457
458 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
459 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
460
461 jclass obj = nullptr;
462 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
463
464 oop mirror = JNIHandles::resolve_non_null(sub);
465 // primitive classes return null
466 if (java_lang_Class::is_primitive(mirror)) return nullptr;
467
468 // Rules of Class.getSuperClass as implemented by KLass::java_super:
469 // arrays return Object
470 // interfaces return null
471 // proper classes return Klass::super()
472 Klass* k = java_lang_Class::as_Klass(mirror);
473 if (k->is_interface()) return nullptr;
474
475 // return mirror for superclass
476 Klass* super = k->java_super();
477 // super2 is the value computed by the compiler's getSuperClass intrinsic:
478 debug_only(Klass* super2 = ( k->is_array_klass()
479 ? vmClasses::Object_klass()
480 : k->super() ) );
481 assert(super == super2,
482 "java_super computation depends on interface, array, other super");
483 obj = (super == nullptr) ? nullptr : (jclass) JNIHandles::make_local(THREAD, super->java_mirror());
484 return obj;
485 JNI_END
486
487 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
488 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
489
490 oop sub_mirror = JNIHandles::resolve_non_null(sub);
491 oop super_mirror = JNIHandles::resolve_non_null(super);
492 if (java_lang_Class::is_primitive(sub_mirror) ||
493 java_lang_Class::is_primitive(super_mirror)) {
494 jboolean ret = (sub_mirror == super_mirror);
495
496 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
497 return ret;
498 }
499 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
500 Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
501 assert(sub_klass != nullptr && super_klass != nullptr, "invalid arguments to jni_IsAssignableFrom");
502 jboolean ret = sub_klass->is_subtype_of(super_klass) ?
503 JNI_TRUE : JNI_FALSE;
504
505 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
506 return ret;
507 JNI_END
508
509
510 DT_RETURN_MARK_DECL(Throw, jint
511 , HOTSPOT_JNI_THROW_RETURN(_ret_ref));
512
513 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
514 HOTSPOT_JNI_THROW_ENTRY(env, obj);
515
516 jint ret = JNI_OK;
517 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
518
519 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
520 ShouldNotReachHere();
521 return 0; // Mute compiler.
522 JNI_END
523
524
525 DT_RETURN_MARK_DECL(ThrowNew, jint
526 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
527
528 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
529 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
530
531 jint ret = JNI_OK;
532 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
533
534 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
535 Symbol* name = k->name();
536 Handle class_loader (THREAD, k->class_loader());
537 Handle protection_domain (THREAD, k->protection_domain());
538 THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK);
539 ShouldNotReachHere();
540 return 0; // Mute compiler.
541 JNI_END
542
543
544 // JNI functions only transform a pending async exception to a synchronous
545 // exception in ExceptionOccurred and ExceptionCheck calls, since
546 // delivering an async exception in other places won't change the native
547 // code's control flow and would be harmful when native code further calls
548 // JNI functions with a pending exception. Async exception is also checked
549 // during the call, so ExceptionOccurred/ExceptionCheck won't return
550 // false but deliver the async exception at the very end during
551 // state transition.
552
553 static void jni_check_async_exceptions(JavaThread *thread) {
554 assert(thread == Thread::current(), "must be itself");
555 if (thread->has_async_exception_condition()) {
556 SafepointMechanism::process_if_requested_with_exit_check(thread, true /* check asyncs */);
557 }
558 }
559
560 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
561 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
562
563 jni_check_async_exceptions(thread);
564 oop exception = thread->pending_exception();
565 jthrowable ret = (jthrowable) JNIHandles::make_local(THREAD, exception);
566
567 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
568 return ret;
569 JNI_END
570
571
572 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
573 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
574
575 if (thread->has_pending_exception()) {
576 Handle ex(thread, thread->pending_exception());
577 thread->clear_pending_exception();
578 jio_fprintf(defaultStream::error_stream(), "Exception ");
579 if (thread != nullptr && thread->threadObj() != nullptr) {
580 ResourceMark rm(THREAD);
581 jio_fprintf(defaultStream::error_stream(),
582 "in thread \"%s\" ", thread->name());
583 }
584 if (ex->is_a(vmClasses::Throwable_klass())) {
585 JavaValue result(T_VOID);
586 JavaCalls::call_virtual(&result,
587 ex,
588 vmClasses::Throwable_klass(),
589 vmSymbols::printStackTrace_name(),
590 vmSymbols::void_method_signature(),
591 THREAD);
592 // If an exception is thrown in the call it gets thrown away. Not much
593 // we can do with it. The native code that calls this, does not check
594 // for the exception - hence, it might still be in the thread when DestroyVM gets
595 // called, potentially causing a few asserts to trigger - since no pending exception
596 // is expected.
597 CLEAR_PENDING_EXCEPTION;
598 } else {
599 ResourceMark rm(THREAD);
600 jio_fprintf(defaultStream::error_stream(),
601 ". Uncaught exception of type %s.",
602 ex->klass()->external_name());
603 }
604 }
605
606 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
607 JNI_END
608
609
610 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionClear(JNIEnv *env))
611 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
612
613 // The jni code might be using this API to clear java thrown exception.
614 // So just mark jvmti thread exception state as exception caught.
615 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
616 if (state != nullptr && state->is_exception_detected()) {
617 state->set_exception_caught();
618 }
619 thread->clear_pending_exception();
620
621 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
622 JNI_END
623
624
625 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
626 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
627
628 tty->print_cr("FATAL ERROR in native method: %s", msg);
629 thread->print_jni_stack();
630 os::abort(); // Dump core and abort
631 JNI_END
632
633
634 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
635 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
636
637 //%note jni_11
638 if (capacity < 0 ||
639 ((MaxJNILocalCapacity > 0) && (capacity > MaxJNILocalCapacity))) {
640 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
641 return JNI_ERR;
642 }
643
644 thread->push_jni_handle_block();
645 jint ret = JNI_OK;
646 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
647 return ret;
648 JNI_END
649
650
651 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
652 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
653
654 //%note jni_11
655 Handle result_handle(thread, JNIHandles::resolve(result));
656 JNIHandleBlock* old_handles = thread->active_handles();
657 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
658 if (new_handles != nullptr) {
659 // As a sanity check we only release the handle blocks if the pop_frame_link is not null.
660 // This way code will still work if PopLocalFrame is called without a corresponding
661 // PushLocalFrame call. Note that we set the pop_frame_link to null explicitly, otherwise
662 // the release_block call will release the blocks.
663 thread->set_active_handles(new_handles);
664 old_handles->set_pop_frame_link(nullptr); // clear link we won't release new_handles below
665 JNIHandleBlock::release_block(old_handles, thread); // may block
666 result = JNIHandles::make_local(thread, result_handle());
667 }
668 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
669 return result;
670 JNI_END
671
672
673 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
674 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
675
676 Handle ref_handle(thread, JNIHandles::resolve(ref));
677 jobject ret = JNIHandles::make_global(ref_handle, AllocFailStrategy::RETURN_NULL);
678
679 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
680 return ret;
681 JNI_END
682
683 // Must be JNI_ENTRY (with HandleMark)
684 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
685 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
686
687 JNIHandles::destroy_global(ref);
688
689 HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
690 JNI_END
691
692 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
693 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
694
695 JNIHandles::destroy_local(obj);
696
697 HOTSPOT_JNI_DELETELOCALREF_RETURN();
698 JNI_END
699
700 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
701 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
702
703 jboolean ret = JNIHandles::is_same_object(r1, r2) ? JNI_TRUE : JNI_FALSE;
704
705 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
706 return ret;
707 JNI_END
708
709
710 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
711 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
712
713 jobject ret = JNIHandles::make_local(THREAD, JNIHandles::resolve(ref),
714 AllocFailStrategy::RETURN_NULL);
715
716 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
717 return ret;
718 JNI_END
719
720 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
721 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
722
723 jint ret;
724 if (capacity >= 0 &&
725 ((MaxJNILocalCapacity <= 0) || (capacity <= MaxJNILocalCapacity))) {
726 ret = JNI_OK;
727 } else {
728 ret = JNI_ERR;
729 }
730
731 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
732 return ret;
733 JNI_END
734
735 // Return the Handle Type
736 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
737 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
738
739 jobjectRefType ret = JNIInvalidRefType;
740 if (obj != nullptr) {
741 ret = JNIHandles::handle_type(thread, obj);
742 }
743
744 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
745 return ret;
746 JNI_END
747
748
749 class JNI_ArgumentPusher : public SignatureIterator {
750 protected:
751 JavaCallArguments* _arguments;
752
753 void push_int(jint x) { _arguments->push_int(x); }
754 void push_long(jlong x) { _arguments->push_long(x); }
755 void push_float(jfloat x) { _arguments->push_float(x); }
756 void push_double(jdouble x) { _arguments->push_double(x); }
757 void push_object(jobject x) { _arguments->push_jobject(x); }
758
759 void push_boolean(jboolean b) {
760 // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
761 // 0 to JNI_FALSE. Boolean return values from native are normalized the same in
762 // TemplateInterpreterGenerator::generate_result_handler_for and
763 // SharedRuntime::generate_native_wrapper.
764 push_int(b == 0 ? JNI_FALSE : JNI_TRUE);
765 }
766
767 JNI_ArgumentPusher(Method* method)
768 : SignatureIterator(method->signature(),
769 Fingerprinter(methodHandle(Thread::current(), method)).fingerprint())
770 {
771 _arguments = nullptr;
772 }
773
774 public:
775 virtual void push_arguments_on(JavaCallArguments* arguments) = 0;
776 };
777
778
779 class JNI_ArgumentPusherVaArg : public JNI_ArgumentPusher {
780 va_list _ap;
781
782 void set_ap(va_list rap) {
783 va_copy(_ap, rap);
784 }
785
786 friend class SignatureIterator; // so do_parameters_on can call do_type
787 void do_type(BasicType type) {
788 switch (type) {
789 // these are coerced to int when using va_arg
790 case T_BYTE:
791 case T_CHAR:
792 case T_SHORT:
793 case T_INT: push_int(va_arg(_ap, jint)); break;
794 case T_BOOLEAN: push_boolean((jboolean) va_arg(_ap, jint)); break;
795
796 // each of these paths is exercised by the various jck Call[Static,Nonvirtual,][Void,Int,..]Method[A,V,] tests
797
798 case T_LONG: push_long(va_arg(_ap, jlong)); break;
799 // float is coerced to double w/ va_arg
800 case T_FLOAT: push_float((jfloat) va_arg(_ap, jdouble)); break;
801 case T_DOUBLE: push_double(va_arg(_ap, jdouble)); break;
802
803 case T_ARRAY:
804 case T_OBJECT: push_object(va_arg(_ap, jobject)); break;
805 default: ShouldNotReachHere();
806 }
807 }
808
809 public:
810 JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap)
811 : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)) {
812 set_ap(rap);
813 }
814
815 ~JNI_ArgumentPusherVaArg() {
816 va_end(_ap);
817 }
818
819 virtual void push_arguments_on(JavaCallArguments* arguments) {
820 _arguments = arguments;
821 do_parameters_on(this);
822 }
823 };
824
825
826 class JNI_ArgumentPusherArray : public JNI_ArgumentPusher {
827 protected:
828 const jvalue *_ap;
829
830 inline void set_ap(const jvalue *rap) { _ap = rap; }
831
832 friend class SignatureIterator; // so do_parameters_on can call do_type
833 void do_type(BasicType type) {
834 switch (type) {
835 case T_CHAR: push_int((_ap++)->c); break;
836 case T_SHORT: push_int((_ap++)->s); break;
837 case T_BYTE: push_int((_ap++)->b); break;
838 case T_INT: push_int((_ap++)->i); break;
839 case T_BOOLEAN: push_boolean((_ap++)->z); break;
840 case T_LONG: push_long((_ap++)->j); break;
841 case T_FLOAT: push_float((_ap++)->f); break;
842 case T_DOUBLE: push_double((_ap++)->d); break;
843 case T_ARRAY:
844 case T_OBJECT: push_object((_ap++)->l); break;
845 default: ShouldNotReachHere();
846 }
847 }
848
849 public:
850 JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap)
851 : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)) {
852 set_ap(rap);
853 }
854
855 virtual void push_arguments_on(JavaCallArguments* arguments) {
856 _arguments = arguments;
857 do_parameters_on(this);
858 }
859 };
860
861
862 enum JNICallType {
863 JNI_STATIC,
864 JNI_VIRTUAL,
865 JNI_NONVIRTUAL
866 };
867
868
869
870 static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
871 methodHandle method(THREAD, Method::resolve_jmethod_id(method_id));
872
873 // Create object to hold arguments for the JavaCall, and associate it with
874 // the jni parser
875 ResourceMark rm(THREAD);
876 int number_of_parameters = method->size_of_parameters();
877 JavaCallArguments java_args(number_of_parameters);
878
879 assert(method->is_static(), "method should be static");
880
881 // Fill out JavaCallArguments object
882 args->push_arguments_on(&java_args);
883 // Initialize result type
884 result->set_type(args->return_type());
885
886 // Invoke the method. Result is returned as oop.
887 JavaCalls::call(result, method, &java_args, CHECK);
888
889 // Convert result
890 if (is_reference_type(result->get_type())) {
891 result->set_jobject(JNIHandles::make_local(THREAD, result->get_oop()));
892 }
893 }
894
895
896 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
897 oop recv = JNIHandles::resolve(receiver);
898 if (recv == nullptr) {
899 THROW(vmSymbols::java_lang_NullPointerException());
900 }
901 Handle h_recv(THREAD, recv);
902
903 int number_of_parameters;
904 Method* selected_method;
905 {
906 Method* m = Method::resolve_jmethod_id(method_id);
907 number_of_parameters = m->size_of_parameters();
908 InstanceKlass* holder = m->method_holder();
909 if (call_type != JNI_VIRTUAL) {
910 selected_method = m;
911 } else if (!m->has_itable_index()) {
912 // non-interface call -- for that little speed boost, don't handlize
913 debug_only(NoSafepointVerifier nosafepoint;)
914 // jni_GetMethodID makes sure class is linked and initialized
915 // so m should have a valid vtable index.
916 assert(m->valid_vtable_index(), "no valid vtable index");
917 int vtbl_index = m->vtable_index();
918 if (vtbl_index != Method::nonvirtual_vtable_index) {
919 selected_method = h_recv->klass()->method_at_vtable(vtbl_index);
920 } else {
921 // final method
922 selected_method = m;
923 }
924 } else {
925 // interface call
926 int itbl_index = m->itable_index();
927 Klass* k = h_recv->klass();
928 selected_method = InstanceKlass::cast(k)->method_at_itable(holder, itbl_index, CHECK);
929 }
930 }
931
932 methodHandle method(THREAD, selected_method);
933
934 // Create object to hold arguments for the JavaCall, and associate it with
935 // the jni parser
936 ResourceMark rm(THREAD);
937 JavaCallArguments java_args(number_of_parameters);
938
939 // handle arguments
940 assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
941 java_args.push_oop(h_recv); // Push jobject handle
942
943 // Fill out JavaCallArguments object
944 args->push_arguments_on(&java_args);
945 // Initialize result type
946 result->set_type(args->return_type());
947
948 // Invoke the method. Result is returned as oop.
949 JavaCalls::call(result, method, &java_args, CHECK);
950
951 // Convert result
952 if (is_reference_type(result->get_type())) {
953 result->set_jobject(JNIHandles::make_local(THREAD, result->get_oop()));
954 }
955 }
956
957 DT_RETURN_MARK_DECL(AllocObject, jobject
958 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
959
960 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
961 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
962
963 jobject ret = nullptr;
964 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
965
966 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
967 ret = JNIHandles::make_local(THREAD, i);
968 return ret;
969 JNI_END
970
971 DT_RETURN_MARK_DECL(NewObjectA, jobject
972 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
973
974 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
975 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
976
977 jobject obj = nullptr;
978 DT_RETURN_MARK(NewObjectA, jobject, (const jobject&)obj);
979
980 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
981 obj = JNIHandles::make_local(THREAD, i);
982 JavaValue jvalue(T_VOID);
983 JNI_ArgumentPusherArray ap(methodID, args);
984 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
985 return obj;
986 JNI_END
987
988
989 DT_RETURN_MARK_DECL(NewObjectV, jobject
990 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
991
992 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
993 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
994
995 jobject obj = nullptr;
996 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
997
998 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
999 obj = JNIHandles::make_local(THREAD, i);
1000 JavaValue jvalue(T_VOID);
1001 JNI_ArgumentPusherVaArg ap(methodID, args);
1002 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1003 return obj;
1004 JNI_END
1005
1006
1007 DT_RETURN_MARK_DECL(NewObject, jobject
1008 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1009
1010 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1011 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
1012
1013 jobject obj = nullptr;
1014 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1015
1016 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(clazz), CHECK_NULL);
1017 obj = JNIHandles::make_local(THREAD, i);
1018 va_list args;
1019 va_start(args, methodID);
1020 JavaValue jvalue(T_VOID);
1021 JNI_ArgumentPusherVaArg ap(methodID, args);
1022 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
1023 va_end(args);
1024 return obj;
1025 JNI_END
1026
1027
1028 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1029 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
1030
1031 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1032 jclass ret =
1033 (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
1034
1035 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1036 return ret;
1037 JNI_END
1038
1039 JNI_ENTRY_NO_PRESERVE(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1040 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
1041
1042 jboolean ret = JNI_TRUE;
1043 if (obj != nullptr) {
1044 ret = JNI_FALSE;
1045 Klass* k = java_lang_Class::as_Klass(
1046 JNIHandles::resolve_non_null(clazz));
1047 if (k != nullptr) {
1048 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
1049 }
1050 }
1051
1052 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
1053 return ret;
1054 JNI_END
1055
1056
1057 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
1058 const char *sig, bool is_static, TRAPS) {
1059 // %%%% This code should probably just call into a method in the LinkResolver
1060 //
1061 // The class should have been loaded (we have an instance of the class
1062 // passed in) so the method and signature should already be in the symbol
1063 // table. If they're not there, the method doesn't exist.
1064 const char *name_to_probe = (name_str == nullptr)
1065 ? vmSymbols::object_initializer_name()->as_C_string()
1066 : name_str;
1067 TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
1068 TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
1069
1070 if (name == nullptr || signature == nullptr) {
1071 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1072 }
1073
1074 oop mirror = JNIHandles::resolve_non_null(clazz);
1075 Klass* klass = java_lang_Class::as_Klass(mirror);
1076
1077 // Throw a NoSuchMethodError exception if we have an instance of a
1078 // primitive java.lang.Class
1079 if (java_lang_Class::is_primitive(mirror)) {
1080 ResourceMark rm(THREAD);
1081 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), err_msg("%s%s.%s%s", is_static ? "static " : "", klass->signature_name(), name_str, sig));
1082 }
1083
1084 // Make sure class is linked and initialized before handing id's out to
1085 // Method*s.
1086 klass->initialize(CHECK_NULL);
1087
1088 Method* m;
1089 if (name == vmSymbols::object_initializer_name() ||
1090 name == vmSymbols::class_initializer_name()) {
1091 // Never search superclasses for constructors
1092 if (klass->is_instance_klass()) {
1093 m = InstanceKlass::cast(klass)->find_method(name, signature);
1094 } else {
1095 m = nullptr;
1096 }
1097 } else {
1098 m = klass->lookup_method(name, signature);
1099 if (m == nullptr && klass->is_instance_klass()) {
1100 m = InstanceKlass::cast(klass)->lookup_method_in_ordered_interfaces(name, signature);
1101 }
1102 }
1103 if (m == nullptr || (m->is_static() != is_static)) {
1104 ResourceMark rm(THREAD);
1105 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), err_msg("%s%s.%s%s", is_static ? "static " : "", klass->signature_name(), name_str, sig));
1106 }
1107 return m->jmethod_id();
1108 }
1109
1110
1111 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
1112 const char *name, const char *sig))
1113 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1114 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1115 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1116 return ret;
1117 JNI_END
1118
1119
1120 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
1121 const char *name, const char *sig))
1122 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
1123 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
1124 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
1125 return ret;
1126 JNI_END
1127
1128
1129
1130 //
1131 // Calling Methods
1132 //
1133
1134
1135 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \
1136 , EntryProbe, ReturnProbe) \
1137 \
1138 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
1139 , ReturnProbe); \
1140 \
1141 JNI_ENTRY(ResultType, \
1142 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
1143 \
1144 EntryProbe; \
1145 ResultType ret = 0;\
1146 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
1147 (const ResultType&)ret);\
1148 \
1149 va_list args; \
1150 va_start(args, methodID); \
1151 JavaValue jvalue(Tag); \
1152 JNI_ArgumentPusherVaArg ap(methodID, args); \
1153 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1154 va_end(args); \
1155 ret = jvalue.get_##ResultType(); \
1156 return ret;\
1157 JNI_END
1158
1159 // the runtime type of subword integral basic types is integer
1160 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN
1161 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1162 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
1163 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE
1164 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1165 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
1166 DEFINE_CALLMETHOD(jchar, Char, T_CHAR
1167 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1168 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
1169 DEFINE_CALLMETHOD(jshort, Short, T_SHORT
1170 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1171 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
1172
1173 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT
1174 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1175 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
1176 DEFINE_CALLMETHOD(jint, Int, T_INT,
1177 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1178 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
1179 DEFINE_CALLMETHOD(jlong, Long, T_LONG
1180 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1181 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
1182 // Float and double probes don't return value because dtrace doesn't currently support it
1183 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT
1184 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1185 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
1186 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE
1187 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
1188 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
1189
1190 #define DEFINE_CALLMETHODV(ResultType, Result, Tag \
1191 , EntryProbe, ReturnProbe) \
1192 \
1193 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType \
1194 , ReturnProbe); \
1195 \
1196 JNI_ENTRY(ResultType, \
1197 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
1198 \
1199 EntryProbe;\
1200 ResultType ret = 0;\
1201 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
1202 (const ResultType&)ret);\
1203 \
1204 JavaValue jvalue(Tag); \
1205 JNI_ArgumentPusherVaArg ap(methodID, args); \
1206 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1207 ret = jvalue.get_##ResultType(); \
1208 return ret;\
1209 JNI_END
1210
1211 // the runtime type of subword integral basic types is integer
1212 DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
1213 , HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1214 HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref))
1215 DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE
1216 , HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1217 HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref))
1218 DEFINE_CALLMETHODV(jchar, Char, T_CHAR
1219 , HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1220 HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref))
1221 DEFINE_CALLMETHODV(jshort, Short, T_SHORT
1222 , HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1223 HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref))
1224
1225 DEFINE_CALLMETHODV(jobject, Object, T_OBJECT
1226 , HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1227 HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref))
1228 DEFINE_CALLMETHODV(jint, Int, T_INT,
1229 HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1230 HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref))
1231 DEFINE_CALLMETHODV(jlong, Long, T_LONG
1232 , HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1233 HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref))
1234 // Float and double probes don't return value because dtrace doesn't currently support it
1235 DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT
1236 , HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1237 HOTSPOT_JNI_CALLFLOATMETHODV_RETURN())
1238 DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE
1239 , HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
1240 HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN())
1241
1242 #define DEFINE_CALLMETHODA(ResultType, Result, Tag \
1243 , EntryProbe, ReturnProbe) \
1244 \
1245 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \
1246 , ReturnProbe); \
1247 \
1248 JNI_ENTRY(ResultType, \
1249 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
1250 EntryProbe; \
1251 ResultType ret = 0;\
1252 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
1253 (const ResultType&)ret);\
1254 \
1255 JavaValue jvalue(Tag); \
1256 JNI_ArgumentPusherArray ap(methodID, args); \
1257 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
1258 ret = jvalue.get_##ResultType(); \
1259 return ret;\
1260 JNI_END
1261
1262 // the runtime type of subword integral basic types is integer
1263 DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
1264 , HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1265 HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref))
1266 DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE
1267 , HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1268 HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref))
1269 DEFINE_CALLMETHODA(jchar, Char, T_CHAR
1270 , HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1271 HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref))
1272 DEFINE_CALLMETHODA(jshort, Short, T_SHORT
1273 , HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1274 HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref))
1275
1276 DEFINE_CALLMETHODA(jobject, Object, T_OBJECT
1277 , HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1278 HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref))
1279 DEFINE_CALLMETHODA(jint, Int, T_INT,
1280 HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1281 HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref))
1282 DEFINE_CALLMETHODA(jlong, Long, T_LONG
1283 , HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1284 HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref))
1285 // Float and double probes don't return value because dtrace doesn't currently support it
1286 DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT
1287 , HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1288 HOTSPOT_JNI_CALLFLOATMETHODA_RETURN())
1289 DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE
1290 , HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
1291 HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN())
1292
1293 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
1294 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
1295 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
1296
1297
1298 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
1299 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
1300 DT_VOID_RETURN_MARK(CallVoidMethod);
1301
1302 va_list args;
1303 va_start(args, methodID);
1304 JavaValue jvalue(T_VOID);
1305 JNI_ArgumentPusherVaArg ap(methodID, args);
1306 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1307 va_end(args);
1308 JNI_END
1309
1310
1311 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
1312 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
1313 DT_VOID_RETURN_MARK(CallVoidMethodV);
1314
1315 JavaValue jvalue(T_VOID);
1316 JNI_ArgumentPusherVaArg ap(methodID, args);
1317 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1318 JNI_END
1319
1320
1321 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
1322 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
1323 DT_VOID_RETURN_MARK(CallVoidMethodA);
1324
1325 JavaValue jvalue(T_VOID);
1326 JNI_ArgumentPusherArray ap(methodID, args);
1327 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
1328 JNI_END
1329
1330
1331
1332 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
1333 , EntryProbe, ReturnProbe) \
1334 \
1335 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
1336 , ReturnProbe);\
1337 \
1338 JNI_ENTRY(ResultType, \
1339 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
1340 \
1341 EntryProbe;\
1342 ResultType ret;\
1343 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
1344 (const ResultType&)ret);\
1345 \
1346 va_list args; \
1347 va_start(args, methodID); \
1348 JavaValue jvalue(Tag); \
1349 JNI_ArgumentPusherVaArg ap(methodID, args); \
1350 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1351 va_end(args); \
1352 ret = jvalue.get_##ResultType(); \
1353 return ret;\
1354 JNI_END
1355
1356 // the runtime type of subword integral basic types is integer
1357 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN
1358 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1359 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(_ret_ref))
1360 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE
1361 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1362 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(_ret_ref))
1363 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR
1364 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1365 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(_ret_ref))
1366 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT
1367 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1368 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(_ret_ref))
1369
1370 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT
1371 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1372 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(_ret_ref))
1373 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT
1374 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1375 HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(_ret_ref))
1376 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG
1377 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1378 // Float and double probes don't return value because dtrace doesn't currently support it
1379 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(_ret_ref))
1380 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT
1381 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1382 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN())
1383 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE
1384 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
1385 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN())
1386
1387 #define DEFINE_CALLNONVIRTUALMETHODV(ResultType, Result, Tag \
1388 , EntryProbe, ReturnProbe) \
1389 \
1390 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType \
1391 , ReturnProbe);\
1392 \
1393 JNI_ENTRY(ResultType, \
1394 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
1395 \
1396 EntryProbe;\
1397 ResultType ret;\
1398 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
1399 (const ResultType&)ret);\
1400 \
1401 JavaValue jvalue(Tag); \
1402 JNI_ArgumentPusherVaArg ap(methodID, args); \
1403 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1404 ret = jvalue.get_##ResultType(); \
1405 return ret;\
1406 JNI_END
1407
1408 // the runtime type of subword integral basic types is integer
1409 DEFINE_CALLNONVIRTUALMETHODV(jboolean, Boolean, T_BOOLEAN
1410 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1411 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(_ret_ref))
1412 DEFINE_CALLNONVIRTUALMETHODV(jbyte, Byte, T_BYTE
1413 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1414 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(_ret_ref))
1415 DEFINE_CALLNONVIRTUALMETHODV(jchar, Char, T_CHAR
1416 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1417 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(_ret_ref))
1418 DEFINE_CALLNONVIRTUALMETHODV(jshort, Short, T_SHORT
1419 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1420 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(_ret_ref))
1421
1422 DEFINE_CALLNONVIRTUALMETHODV(jobject, Object, T_OBJECT
1423 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1424 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(_ret_ref))
1425 DEFINE_CALLNONVIRTUALMETHODV(jint, Int, T_INT
1426 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1427 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(_ret_ref))
1428 DEFINE_CALLNONVIRTUALMETHODV(jlong, Long, T_LONG
1429 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1430 // Float and double probes don't return value because dtrace doesn't currently support it
1431 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(_ret_ref))
1432 DEFINE_CALLNONVIRTUALMETHODV(jfloat, Float, T_FLOAT
1433 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1434 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN())
1435 DEFINE_CALLNONVIRTUALMETHODV(jdouble, Double, T_DOUBLE
1436 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
1437 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN())
1438
1439 #define DEFINE_CALLNONVIRTUALMETHODA(ResultType, Result, Tag \
1440 , EntryProbe, ReturnProbe) \
1441 \
1442 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType \
1443 , ReturnProbe);\
1444 \
1445 JNI_ENTRY(ResultType, \
1446 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
1447 \
1448 EntryProbe;\
1449 ResultType ret;\
1450 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
1451 (const ResultType&)ret);\
1452 \
1453 JavaValue jvalue(Tag); \
1454 JNI_ArgumentPusherArray ap(methodID, args); \
1455 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
1456 ret = jvalue.get_##ResultType(); \
1457 return ret;\
1458 JNI_END
1459
1460 // the runtime type of subword integral basic types is integer
1461 DEFINE_CALLNONVIRTUALMETHODA(jboolean, Boolean, T_BOOLEAN
1462 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1463 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(_ret_ref))
1464 DEFINE_CALLNONVIRTUALMETHODA(jbyte, Byte, T_BYTE
1465 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1466 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(_ret_ref))
1467 DEFINE_CALLNONVIRTUALMETHODA(jchar, Char, T_CHAR
1468 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1469 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(_ret_ref))
1470 DEFINE_CALLNONVIRTUALMETHODA(jshort, Short, T_SHORT
1471 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1472 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(_ret_ref))
1473
1474 DEFINE_CALLNONVIRTUALMETHODA(jobject, Object, T_OBJECT
1475 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1476 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(_ret_ref))
1477 DEFINE_CALLNONVIRTUALMETHODA(jint, Int, T_INT
1478 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1479 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(_ret_ref))
1480 DEFINE_CALLNONVIRTUALMETHODA(jlong, Long, T_LONG
1481 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1482 // Float and double probes don't return value because dtrace doesn't currently support it
1483 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(_ret_ref))
1484 DEFINE_CALLNONVIRTUALMETHODA(jfloat, Float, T_FLOAT
1485 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1486 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN())
1487 DEFINE_CALLNONVIRTUALMETHODA(jdouble, Double, T_DOUBLE
1488 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
1489 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN())
1490
1491 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod
1492 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
1493 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
1494 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
1495 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
1496 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
1497
1498 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
1499 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
1500 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
1501
1502 va_list args;
1503 va_start(args, methodID);
1504 JavaValue jvalue(T_VOID);
1505 JNI_ArgumentPusherVaArg ap(methodID, args);
1506 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
1507 va_end(args);
1508 JNI_END
1509
1510
1511 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
1512 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
1513 env, obj, cls, (uintptr_t) methodID);
1514 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
1515
1516 JavaValue jvalue(T_VOID);
1517 JNI_ArgumentPusherVaArg ap(methodID, args);
1518 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
1519 JNI_END
1520
1521
1522 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
1523 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
1524 env, obj, cls, (uintptr_t) methodID);
1525 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
1526 JavaValue jvalue(T_VOID);
1527 JNI_ArgumentPusherArray ap(methodID, args);
1528 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
1529 JNI_END
1530
1531
1532
1533 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
1534 , EntryProbe, ResultProbe) \
1535 \
1536 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
1537 , ResultProbe); \
1538 \
1539 JNI_ENTRY(ResultType, \
1540 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
1541 \
1542 EntryProbe; \
1543 ResultType ret = 0;\
1544 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
1545 (const ResultType&)ret);\
1546 \
1547 va_list args; \
1548 va_start(args, methodID); \
1549 JavaValue jvalue(Tag); \
1550 JNI_ArgumentPusherVaArg ap(methodID, args); \
1551 jni_invoke_static(env, &jvalue, nullptr, JNI_STATIC, methodID, &ap, CHECK_0); \
1552 va_end(args); \
1553 ret = jvalue.get_##ResultType(); \
1554 return ret;\
1555 JNI_END
1556
1557 // the runtime type of subword integral basic types is integer
1558 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN
1559 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1560 HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(_ret_ref));
1561 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE
1562 , HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1563 HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(_ret_ref));
1564 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR
1565 , HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1566 HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(_ret_ref));
1567 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT
1568 , HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1569 HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(_ret_ref));
1570
1571 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT
1572 , HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1573 HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(_ret_ref));
1574 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT
1575 , HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1576 HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(_ret_ref));
1577 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG
1578 , HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1579 HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(_ret_ref));
1580 // Float and double probes don't return value because dtrace doesn't currently support it
1581 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT
1582 , HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1583 HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN());
1584 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE
1585 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
1586 HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN());
1587
1588 #define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \
1589 , EntryProbe, ResultProbe) \
1590 \
1591 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \
1592 , ResultProbe); \
1593 \
1594 JNI_ENTRY(ResultType, \
1595 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
1596 \
1597 EntryProbe; \
1598 ResultType ret = 0;\
1599 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
1600 (const ResultType&)ret);\
1601 \
1602 JavaValue jvalue(Tag); \
1603 JNI_ArgumentPusherVaArg ap(methodID, args); \
1604 /* Make sure class is initialized before trying to invoke its method */ \
1605 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); \
1606 k->initialize(CHECK_0); \
1607 jni_invoke_static(env, &jvalue, nullptr, JNI_STATIC, methodID, &ap, CHECK_0); \
1608 va_end(args); \
1609 ret = jvalue.get_##ResultType(); \
1610 return ret;\
1611 JNI_END
1612
1613 // the runtime type of subword integral basic types is integer
1614 DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN
1615 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1616 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref));
1617 DEFINE_CALLSTATICMETHODV(jbyte, Byte, T_BYTE
1618 , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1619 HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref));
1620 DEFINE_CALLSTATICMETHODV(jchar, Char, T_CHAR
1621 , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1622 HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref));
1623 DEFINE_CALLSTATICMETHODV(jshort, Short, T_SHORT
1624 , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1625 HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref));
1626
1627 DEFINE_CALLSTATICMETHODV(jobject, Object, T_OBJECT
1628 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1629 HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(_ret_ref));
1630 DEFINE_CALLSTATICMETHODV(jint, Int, T_INT
1631 , HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1632 HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(_ret_ref));
1633 DEFINE_CALLSTATICMETHODV(jlong, Long, T_LONG
1634 , HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1635 HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(_ret_ref));
1636 // Float and double probes don't return value because dtrace doesn't currently support it
1637 DEFINE_CALLSTATICMETHODV(jfloat, Float, T_FLOAT
1638 , HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1639 HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN());
1640 DEFINE_CALLSTATICMETHODV(jdouble, Double, T_DOUBLE
1641 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1642 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN());
1643
1644 #define DEFINE_CALLSTATICMETHODA(ResultType, Result, Tag \
1645 , EntryProbe, ResultProbe) \
1646 \
1647 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType \
1648 , ResultProbe); \
1649 \
1650 JNI_ENTRY(ResultType, \
1651 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
1652 \
1653 EntryProbe; \
1654 ResultType ret = 0;\
1655 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
1656 (const ResultType&)ret);\
1657 \
1658 JavaValue jvalue(Tag); \
1659 JNI_ArgumentPusherArray ap(methodID, args); \
1660 jni_invoke_static(env, &jvalue, nullptr, JNI_STATIC, methodID, &ap, CHECK_0); \
1661 ret = jvalue.get_##ResultType(); \
1662 return ret;\
1663 JNI_END
1664
1665 // the runtime type of subword integral basic types is integer
1666 DEFINE_CALLSTATICMETHODA(jboolean, Boolean, T_BOOLEAN
1667 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1668 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(_ret_ref));
1669 DEFINE_CALLSTATICMETHODA(jbyte, Byte, T_BYTE
1670 , HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1671 HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(_ret_ref));
1672 DEFINE_CALLSTATICMETHODA(jchar, Char, T_CHAR
1673 , HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1674 HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(_ret_ref));
1675 DEFINE_CALLSTATICMETHODA(jshort, Short, T_SHORT
1676 , HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1677 HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(_ret_ref));
1678
1679 DEFINE_CALLSTATICMETHODA(jobject, Object, T_OBJECT
1680 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1681 HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(_ret_ref));
1682 DEFINE_CALLSTATICMETHODA(jint, Int, T_INT
1683 , HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1684 HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(_ret_ref));
1685 DEFINE_CALLSTATICMETHODA(jlong, Long, T_LONG
1686 , HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1687 HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(_ret_ref));
1688 // Float and double probes don't return value because dtrace doesn't currently support it
1689 DEFINE_CALLSTATICMETHODA(jfloat, Float, T_FLOAT
1690 , HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1691 HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN());
1692 DEFINE_CALLSTATICMETHODA(jdouble, Double, T_DOUBLE
1693 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
1694 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN());
1695
1696 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod
1697 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
1698 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
1699 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
1700 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
1701 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
1702
1703 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
1704 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
1705 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
1706
1707 va_list args;
1708 va_start(args, methodID);
1709 JavaValue jvalue(T_VOID);
1710 JNI_ArgumentPusherVaArg ap(methodID, args);
1711 jni_invoke_static(env, &jvalue, nullptr, JNI_STATIC, methodID, &ap, CHECK);
1712 va_end(args);
1713 JNI_END
1714
1715
1716 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
1717 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
1718 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
1719
1720 JavaValue jvalue(T_VOID);
1721 JNI_ArgumentPusherVaArg ap(methodID, args);
1722 jni_invoke_static(env, &jvalue, nullptr, JNI_STATIC, methodID, &ap, CHECK);
1723 JNI_END
1724
1725
1726 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
1727 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
1728 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
1729
1730 JavaValue jvalue(T_VOID);
1731 JNI_ArgumentPusherArray ap(methodID, args);
1732 jni_invoke_static(env, &jvalue, nullptr, JNI_STATIC, methodID, &ap, CHECK);
1733 JNI_END
1734
1735
1736 //
1737 // Accessing Fields
1738 //
1739
1740
1741 DT_RETURN_MARK_DECL(GetFieldID, jfieldID
1742 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
1743
1744 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
1745 const char *name, const char *sig))
1746 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
1747 jfieldID ret = 0;
1748 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
1749
1750 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1751
1752 // The class should have been loaded (we have an instance of the class
1753 // passed in) so the field and signature should already be in the symbol
1754 // table. If they're not there, the field doesn't exist.
1755 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
1756 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
1757 if (fieldname == nullptr || signame == nullptr) {
1758 ResourceMark rm;
1759 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), err_msg("%s.%s %s", k->external_name(), name, sig));
1760 }
1761
1762 // Make sure class is initialized before handing id's out to fields
1763 k->initialize(CHECK_NULL);
1764
1765 fieldDescriptor fd;
1766 if (!k->is_instance_klass() ||
1767 !InstanceKlass::cast(k)->find_field(fieldname, signame, false, &fd)) {
1768 ResourceMark rm;
1769 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), err_msg("%s.%s %s", k->external_name(), name, sig));
1770 }
1771
1772 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
1773 // It may also have hash bits for k, if VerifyJNIFields is turned on.
1774 ret = jfieldIDWorkaround::to_instance_jfieldID(k, fd.offset());
1775 return ret;
1776 JNI_END
1777
1778
1779 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
1780 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
1781 oop o = JNIHandles::resolve_non_null(obj);
1782 Klass* k = o->klass();
1783 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
1784 // Keep JVMTI addition small and only check enabled flag here.
1785 // jni_GetField_probe() assumes that is okay to create handles.
1786 if (JvmtiExport::should_post_field_access()) {
1787 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
1788 }
1789 oop loaded_obj = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(o, offset);
1790 jobject ret = JNIHandles::make_local(THREAD, loaded_obj);
1791 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
1792 return ret;
1793 JNI_END
1794
1795
1796
1797 #define DEFINE_GETFIELD(Return,Fieldname,Result \
1798 , EntryProbe, ReturnProbe) \
1799 \
1800 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
1801 , ReturnProbe); \
1802 \
1803 JNI_ENTRY_NO_PRESERVE(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
1804 \
1805 EntryProbe; \
1806 Return ret = 0;\
1807 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
1808 \
1809 oop o = JNIHandles::resolve_non_null(obj); \
1810 Klass* k = o->klass(); \
1811 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
1812 /* Keep JVMTI addition small and only check enabled flag here. */ \
1813 if (JvmtiExport::should_post_field_access()) { \
1814 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false); \
1815 } \
1816 ret = o->Fieldname##_field(offset); \
1817 return ret; \
1818 JNI_END
1819
1820 DEFINE_GETFIELD(jboolean, bool, Boolean
1821 , HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1822 HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(_ret_ref))
1823 DEFINE_GETFIELD(jbyte, byte, Byte
1824 , HOTSPOT_JNI_GETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1825 HOTSPOT_JNI_GETBYTEFIELD_RETURN(_ret_ref))
1826 DEFINE_GETFIELD(jchar, char, Char
1827 , HOTSPOT_JNI_GETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1828 HOTSPOT_JNI_GETCHARFIELD_RETURN(_ret_ref))
1829 DEFINE_GETFIELD(jshort, short, Short
1830 , HOTSPOT_JNI_GETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1831 HOTSPOT_JNI_GETSHORTFIELD_RETURN(_ret_ref))
1832 DEFINE_GETFIELD(jint, int, Int
1833 , HOTSPOT_JNI_GETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1834 HOTSPOT_JNI_GETINTFIELD_RETURN(_ret_ref))
1835 DEFINE_GETFIELD(jlong, long, Long
1836 , HOTSPOT_JNI_GETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1837 HOTSPOT_JNI_GETLONGFIELD_RETURN(_ret_ref))
1838 // Float and double probes don't return value because dtrace doesn't currently support it
1839 DEFINE_GETFIELD(jfloat, float, Float
1840 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1841 HOTSPOT_JNI_GETFLOATFIELD_RETURN())
1842 DEFINE_GETFIELD(jdouble, double, Double
1843 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1844 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
1845
1846 address jni_GetBooleanField_addr() {
1847 return (address)jni_GetBooleanField;
1848 }
1849 address jni_GetByteField_addr() {
1850 return (address)jni_GetByteField;
1851 }
1852 address jni_GetCharField_addr() {
1853 return (address)jni_GetCharField;
1854 }
1855 address jni_GetShortField_addr() {
1856 return (address)jni_GetShortField;
1857 }
1858 address jni_GetIntField_addr() {
1859 return (address)jni_GetIntField;
1860 }
1861 address jni_GetLongField_addr() {
1862 return (address)jni_GetLongField;
1863 }
1864 address jni_GetFloatField_addr() {
1865 return (address)jni_GetFloatField;
1866 }
1867 address jni_GetDoubleField_addr() {
1868 return (address)jni_GetDoubleField;
1869 }
1870
1871 JNI_ENTRY_NO_PRESERVE(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
1872 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
1873 oop o = JNIHandles::resolve_non_null(obj);
1874 Klass* k = o->klass();
1875 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
1876 // Keep JVMTI addition small and only check enabled flag here.
1877 if (JvmtiExport::should_post_field_modification()) {
1878 jvalue field_value;
1879 field_value.l = value;
1880 o = JvmtiExport::jni_SetField_probe(thread, obj, o, k, fieldID, false, JVM_SIGNATURE_CLASS, (jvalue *)&field_value);
1881 }
1882 HeapAccess<ON_UNKNOWN_OOP_REF>::oop_store_at(o, offset, JNIHandles::resolve(value));
1883 HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
1884 JNI_END
1885
1886
1887 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
1888 , EntryProbe, ReturnProbe) \
1889 \
1890 JNI_ENTRY_NO_PRESERVE(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
1891 \
1892 EntryProbe; \
1893 \
1894 oop o = JNIHandles::resolve_non_null(obj); \
1895 Klass* k = o->klass(); \
1896 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
1897 /* Keep JVMTI addition small and only check enabled flag here. */ \
1898 if (JvmtiExport::should_post_field_modification()) { \
1899 jvalue field_value; \
1900 field_value.unionType = value; \
1901 o = JvmtiExport::jni_SetField_probe(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
1902 } \
1903 if (SigType == JVM_SIGNATURE_BOOLEAN) { value = ((jboolean)value) & 1; } \
1904 o->Fieldname##_field_put(offset, value); \
1905 ReturnProbe; \
1906 JNI_END
1907
1908 DEFINE_SETFIELD(jboolean, bool, Boolean, JVM_SIGNATURE_BOOLEAN, z
1909 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
1910 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
1911 DEFINE_SETFIELD(jbyte, byte, Byte, JVM_SIGNATURE_BYTE, b
1912 , HOTSPOT_JNI_SETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
1913 HOTSPOT_JNI_SETBYTEFIELD_RETURN())
1914 DEFINE_SETFIELD(jchar, char, Char, JVM_SIGNATURE_CHAR, c
1915 , HOTSPOT_JNI_SETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
1916 HOTSPOT_JNI_SETCHARFIELD_RETURN())
1917 DEFINE_SETFIELD(jshort, short, Short, JVM_SIGNATURE_SHORT, s
1918 , HOTSPOT_JNI_SETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
1919 HOTSPOT_JNI_SETSHORTFIELD_RETURN())
1920 DEFINE_SETFIELD(jint, int, Int, JVM_SIGNATURE_INT, i
1921 , HOTSPOT_JNI_SETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
1922 HOTSPOT_JNI_SETINTFIELD_RETURN())
1923 DEFINE_SETFIELD(jlong, long, Long, JVM_SIGNATURE_LONG, j
1924 , HOTSPOT_JNI_SETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
1925 HOTSPOT_JNI_SETLONGFIELD_RETURN())
1926 // Float and double probes don't return value because dtrace doesn't currently support it
1927 DEFINE_SETFIELD(jfloat, float, Float, JVM_SIGNATURE_FLOAT, f
1928 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1929 HOTSPOT_JNI_SETFLOATFIELD_RETURN())
1930 DEFINE_SETFIELD(jdouble, double, Double, JVM_SIGNATURE_DOUBLE, d
1931 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
1932 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
1933
1934 DT_RETURN_MARK_DECL(ToReflectedField, jobject
1935 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
1936
1937 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
1938 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
1939 jobject ret = nullptr;
1940 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
1941
1942 fieldDescriptor fd;
1943 bool found = false;
1944 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1945
1946 assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
1947
1948 if (isStatic) {
1949 // Static field. The fieldID a JNIid specifying the field holder and the offset within the Klass*.
1950 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
1951 assert(id->is_static_field_id(), "invalid static field id");
1952 found = id->find_local_field(&fd);
1953 } else {
1954 // Non-static field. The fieldID is really the offset of the field within the instanceOop.
1955 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
1956 found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
1957 }
1958 assert(found, "bad fieldID passed into jni_ToReflectedField");
1959 oop reflected = Reflection::new_field(&fd, CHECK_NULL);
1960 ret = JNIHandles::make_local(THREAD, reflected);
1961 return ret;
1962 JNI_END
1963
1964
1965 //
1966 // Accessing Static Fields
1967 //
1968 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
1969 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
1970
1971 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
1972 const char *name, const char *sig))
1973 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
1974 jfieldID ret = nullptr;
1975 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
1976
1977 // The class should have been loaded (we have an instance of the class
1978 // passed in) so the field and signature should already be in the symbol
1979 // table. If they're not there, the field doesn't exist.
1980 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
1981 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
1982 if (fieldname == nullptr || signame == nullptr) {
1983 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
1984 }
1985 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1986 // Make sure class is initialized before handing id's out to static fields
1987 k->initialize(CHECK_NULL);
1988
1989 fieldDescriptor fd;
1990 if (!k->is_instance_klass() ||
1991 !InstanceKlass::cast(k)->find_field(fieldname, signame, true, &fd)) {
1992 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
1993 }
1994
1995 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
1996 JNIid* id = fd.field_holder()->jni_id_for(fd.offset());
1997 debug_only(id->set_is_static_field_id();)
1998
1999 debug_only(id->verify(fd.field_holder()));
2000
2001 ret = jfieldIDWorkaround::to_static_jfieldID(id);
2002 return ret;
2003 JNI_END
2004
2005
2006 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2007 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
2008 #if INCLUDE_JNI_CHECK
2009 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2010 #endif // INCLUDE_JNI_CHECK
2011 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2012 assert(id->is_static_field_id(), "invalid static field id");
2013 // Keep JVMTI addition small and only check enabled flag here.
2014 // jni_GetField_probe() assumes that is okay to create handles.
2015 if (JvmtiExport::should_post_field_access()) {
2016 JvmtiExport::jni_GetField_probe(thread, nullptr, nullptr, id->holder(), fieldID, true);
2017 }
2018 jobject ret = JNIHandles::make_local(THREAD, id->holder()->java_mirror()->obj_field(id->offset()));
2019 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
2020 return ret;
2021 JNI_END
2022
2023
2024 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
2025 , EntryProbe, ReturnProbe) \
2026 \
2027 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
2028 , ReturnProbe); \
2029 \
2030 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
2031 EntryProbe; \
2032 Return ret = 0;\
2033 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
2034 (const Return&)ret);\
2035 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
2036 assert(id->is_static_field_id(), "invalid static field id"); \
2037 /* Keep JVMTI addition small and only check enabled flag here. */ \
2038 /* jni_GetField_probe() assumes that is okay to create handles. */ \
2039 if (JvmtiExport::should_post_field_access()) { \
2040 JvmtiExport::jni_GetField_probe(thread, nullptr, nullptr, id->holder(), fieldID, true); \
2041 } \
2042 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
2043 return ret;\
2044 JNI_END
2045
2046 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean
2047 , HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(_ret_ref))
2048 DEFINE_GETSTATICFIELD(jbyte, byte, Byte
2049 , HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(_ret_ref) )
2050 DEFINE_GETSTATICFIELD(jchar, char, Char
2051 , HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(_ret_ref) )
2052 DEFINE_GETSTATICFIELD(jshort, short, Short
2053 , HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(_ret_ref) )
2054 DEFINE_GETSTATICFIELD(jint, int, Int
2055 , HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(_ret_ref) )
2056 DEFINE_GETSTATICFIELD(jlong, long, Long
2057 , HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(_ret_ref) )
2058 // Float and double probes don't return value because dtrace doesn't currently support it
2059 DEFINE_GETSTATICFIELD(jfloat, float, Float
2060 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() )
2061 DEFINE_GETSTATICFIELD(jdouble, double, Double
2062 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() )
2063
2064 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
2065 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
2066 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2067 assert(id->is_static_field_id(), "invalid static field id");
2068 // Keep JVMTI addition small and only check enabled flag here.
2069 // jni_SetField_probe() assumes that is okay to create handles.
2070 if (JvmtiExport::should_post_field_modification()) {
2071 jvalue field_value;
2072 field_value.l = value;
2073 JvmtiExport::jni_SetField_probe(thread, nullptr, nullptr, id->holder(), fieldID, true, JVM_SIGNATURE_CLASS, (jvalue *)&field_value);
2074 }
2075 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
2076 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
2077 JNI_END
2078
2079
2080
2081 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
2082 , EntryProbe, ReturnProbe) \
2083 \
2084 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
2085 EntryProbe; \
2086 \
2087 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
2088 assert(id->is_static_field_id(), "invalid static field id"); \
2089 /* Keep JVMTI addition small and only check enabled flag here. */ \
2090 /* jni_SetField_probe() assumes that is okay to create handles. */ \
2091 if (JvmtiExport::should_post_field_modification()) { \
2092 jvalue field_value; \
2093 field_value.unionType = value; \
2094 JvmtiExport::jni_SetField_probe(thread, nullptr, nullptr, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
2095 } \
2096 if (SigType == JVM_SIGNATURE_BOOLEAN) { value = ((jboolean)value) & 1; } \
2097 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
2098 ReturnProbe;\
2099 JNI_END
2100
2101 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, JVM_SIGNATURE_BOOLEAN, z
2102 , HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value),
2103 HOTSPOT_JNI_SETSTATICBOOLEANFIELD_RETURN())
2104 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, JVM_SIGNATURE_BYTE, b
2105 , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
2106 HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN())
2107 DEFINE_SETSTATICFIELD(jchar, char, Char, JVM_SIGNATURE_CHAR, c
2108 , HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
2109 HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN())
2110 DEFINE_SETSTATICFIELD(jshort, short, Short, JVM_SIGNATURE_SHORT, s
2111 , HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
2112 HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN())
2113 DEFINE_SETSTATICFIELD(jint, int, Int, JVM_SIGNATURE_INT, i
2114 , HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
2115 HOTSPOT_JNI_SETSTATICINTFIELD_RETURN())
2116 DEFINE_SETSTATICFIELD(jlong, long, Long, JVM_SIGNATURE_LONG, j
2117 , HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
2118 HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN())
2119 // Float and double probes don't return value because dtrace doesn't currently support it
2120 DEFINE_SETSTATICFIELD(jfloat, float, Float, JVM_SIGNATURE_FLOAT, f
2121 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
2122 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
2123 DEFINE_SETSTATICFIELD(jdouble, double, Double, JVM_SIGNATURE_DOUBLE, d
2124 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
2125 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
2126
2127 //
2128 // String Operations
2129 //
2130
2131 // Unicode Interface
2132
2133 DT_RETURN_MARK_DECL(NewString, jstring
2134 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
2135
2136 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
2137 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
2138 jstring ret = nullptr;
2139 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
2140 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
2141 ret = (jstring) JNIHandles::make_local(THREAD, string);
2142 return ret;
2143 JNI_END
2144
2145
2146 JNI_ENTRY_NO_PRESERVE(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
2147 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
2148 jsize ret = 0;
2149 oop s = JNIHandles::resolve_non_null(string);
2150 ret = java_lang_String::length(s);
2151 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
2152 return ret;
2153 JNI_END
2154
2155
2156 JNI_ENTRY_NO_PRESERVE(const jchar*, jni_GetStringChars(
2157 JNIEnv *env, jstring string, jboolean *isCopy))
2158 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
2159 jchar* buf = nullptr;
2160 oop s = JNIHandles::resolve_non_null(string);
2161 typeArrayOop s_value = java_lang_String::value(s);
2162 if (s_value != nullptr) {
2163 int s_len = java_lang_String::length(s, s_value);
2164 bool is_latin1 = java_lang_String::is_latin1(s);
2165 buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal); // add one for zero termination
2166 /* JNI Specification states return null on OOM */
2167 if (buf != nullptr) {
2168 if (s_len > 0) {
2169 if (!is_latin1) {
2170 ArrayAccess<>::arraycopy_to_native(s_value, (size_t) typeArrayOopDesc::element_offset<jchar>(0),
2171 buf, s_len);
2172 } else {
2173 for (int i = 0; i < s_len; i++) {
2174 buf[i] = ((jchar) s_value->byte_at(i)) & 0xff;
2175 }
2176 }
2177 }
2178 buf[s_len] = 0;
2179 //%note jni_5
2180 if (isCopy != nullptr) {
2181 *isCopy = JNI_TRUE;
2182 }
2183 }
2184 }
2185 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
2186 return buf;
2187 JNI_END
2188
2189
2190 JNI_ENTRY_NO_PRESERVE(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
2191 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
2192 //%note jni_6
2193 if (chars != nullptr) {
2194 // Since String objects are supposed to be immutable, don't copy any
2195 // new data back. A bad user will have to go after the char array.
2196 FreeHeap((void*) chars);
2197 }
2198 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
2199 JNI_END
2200
2201
2202 // UTF Interface
2203
2204 DT_RETURN_MARK_DECL(NewStringUTF, jstring
2205 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
2206
2207 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
2208 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
2209 jstring ret;
2210 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
2211
2212 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
2213 ret = (jstring) JNIHandles::make_local(THREAD, result);
2214 return ret;
2215 JNI_END
2216
2217
2218 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
2219 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
2220 oop java_string = JNIHandles::resolve_non_null(string);
2221 jsize ret = java_lang_String::utf8_length(java_string);
2222 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
2223 return ret;
2224 JNI_END
2225
2226
2227 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
2228 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
2229 char* result = nullptr;
2230 oop java_string = JNIHandles::resolve_non_null(string);
2231 typeArrayOop s_value = java_lang_String::value(java_string);
2232 if (s_value != nullptr) {
2233 size_t length = java_lang_String::utf8_length(java_string, s_value);
2234 /* JNI Specification states return null on OOM */
2235 result = AllocateHeap(length + 1, mtInternal, AllocFailStrategy::RETURN_NULL);
2236 if (result != nullptr) {
2237 java_lang_String::as_utf8_string(java_string, s_value, result, (int) length + 1);
2238 if (isCopy != nullptr) {
2239 *isCopy = JNI_TRUE;
2240 }
2241 }
2242 }
2243 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
2244 return result;
2245 JNI_END
2246
2247
2248 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
2249 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
2250 if (chars != nullptr) {
2251 FreeHeap((char*) chars);
2252 }
2253 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN();
2254 JNI_END
2255
2256
2257 JNI_ENTRY_NO_PRESERVE(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
2258 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
2259 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
2260 assert(a->is_array(), "must be array");
2261 jsize ret = a->length();
2262 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
2263 return ret;
2264 JNI_END
2265
2266
2267 //
2268 // Object Array Operations
2269 //
2270
2271 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
2272 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
2273
2274 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
2275 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
2276 jobjectArray ret = nullptr;
2277 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
2278 Klass* ek = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass));
2279 Klass* ak = ek->array_klass(CHECK_NULL);
2280 ObjArrayKlass::cast(ak)->initialize(CHECK_NULL);
2281 objArrayOop result = ObjArrayKlass::cast(ak)->allocate(length, CHECK_NULL);
2282 oop initial_value = JNIHandles::resolve(initialElement);
2283 if (initial_value != nullptr) { // array already initialized with null
2284 for (int index = 0; index < length; index++) {
2285 result->obj_at_put(index, initial_value);
2286 }
2287 }
2288 ret = (jobjectArray) JNIHandles::make_local(THREAD, result);
2289 return ret;
2290 JNI_END
2291
2292 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
2293 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
2294
2295 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
2296 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
2297 jobject ret = nullptr;
2298 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
2299 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2300 if (a->is_within_bounds(index)) {
2301 ret = JNIHandles::make_local(THREAD, a->obj_at(index));
2302 return ret;
2303 } else {
2304 ResourceMark rm(THREAD);
2305 stringStream ss;
2306 ss.print("Index %d out of bounds for length %d", index, a->length());
2307 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2308 }
2309 JNI_END
2310
2311 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
2312 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
2313
2314 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
2315 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
2316 DT_VOID_RETURN_MARK(SetObjectArrayElement);
2317
2318 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2319 oop v = JNIHandles::resolve(value);
2320 if (a->is_within_bounds(index)) {
2321 if (v == nullptr || v->is_a(ObjArrayKlass::cast(a->klass())->element_klass())) {
2322 a->obj_at_put(index, v);
2323 } else {
2324 ResourceMark rm(THREAD);
2325 stringStream ss;
2326 Klass *bottom_kl = ObjArrayKlass::cast(a->klass())->bottom_klass();
2327 ss.print("type mismatch: can not store %s to %s[%d]",
2328 v->klass()->external_name(),
2329 bottom_kl->is_typeArray_klass() ? type2name_tab[ArrayKlass::cast(bottom_kl)->element_type()] : bottom_kl->external_name(),
2330 index);
2331 for (int dims = ArrayKlass::cast(a->klass())->dimension(); dims > 1; --dims) {
2332 ss.print("[]");
2333 }
2334 THROW_MSG(vmSymbols::java_lang_ArrayStoreException(), ss.as_string());
2335 }
2336 } else {
2337 ResourceMark rm(THREAD);
2338 stringStream ss;
2339 ss.print("Index %d out of bounds for length %d", index, a->length());
2340 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2341 }
2342 JNI_END
2343
2344
2345
2346 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
2347 ,EntryProbe,ReturnProbe) \
2348 \
2349 DT_RETURN_MARK_DECL(New##Result##Array, Return \
2350 , ReturnProbe); \
2351 \
2352 JNI_ENTRY(Return, \
2353 jni_New##Result##Array(JNIEnv *env, jsize len)) \
2354 EntryProbe; \
2355 Return ret = nullptr;\
2356 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
2357 \
2358 oop obj= oopFactory::Allocator(len, CHECK_NULL); \
2359 ret = (Return) JNIHandles::make_local(THREAD, obj); \
2360 return ret;\
2361 JNI_END
2362
2363 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean,
2364 HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len),
2365 HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref))
2366 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte,
2367 HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len),
2368 HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref))
2369 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short,
2370 HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len),
2371 HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref))
2372 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char,
2373 HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len),
2374 HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref))
2375 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int,
2376 HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len),
2377 HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref))
2378 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long,
2379 HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
2380 HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref))
2381 DEFINE_NEWSCALARARRAY(jfloatArray, new_floatArray, Float,
2382 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
2383 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
2384 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double,
2385 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
2386 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
2387
2388 // Return an address which will fault if the caller writes to it.
2389
2390 static char* get_bad_address() {
2391 static char* bad_address = nullptr;
2392 if (bad_address == nullptr) {
2393 size_t size = os::vm_allocation_granularity();
2394 bad_address = os::reserve_memory(size);
2395 if (bad_address != nullptr) {
2396 os::protect_memory(bad_address, size, os::MEM_PROT_READ,
2397 /*is_committed*/false);
2398 MemTracker::record_virtual_memory_type((void*)bad_address, mtInternal);
2399 }
2400 }
2401 return bad_address;
2402 }
2403
2404
2405
2406 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
2407 , EntryProbe, ReturnProbe) \
2408 \
2409 JNI_ENTRY_NO_PRESERVE(ElementType*, \
2410 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
2411 EntryProbe; \
2412 /* allocate an chunk of memory in c land */ \
2413 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
2414 ElementType* result; \
2415 int len = a->length(); \
2416 if (len == 0) { \
2417 if (isCopy != nullptr) { \
2418 *isCopy = JNI_FALSE; \
2419 } \
2420 /* Empty array: legal but useless, can't return null. \
2421 * Return a pointer to something useless. \
2422 * Avoid asserts in typeArrayOop. */ \
2423 result = (ElementType*)get_bad_address(); \
2424 } else { \
2425 /* JNI Specification states return null on OOM */ \
2426 result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
2427 if (result != nullptr) { \
2428 /* copy the array to the c chunk */ \
2429 ArrayAccess<>::arraycopy_to_native(a, typeArrayOopDesc::element_offset<ElementType>(0), \
2430 result, len); \
2431 if (isCopy) { \
2432 *isCopy = JNI_TRUE; \
2433 } \
2434 } \
2435 } \
2436 ReturnProbe; \
2437 return result; \
2438 JNI_END
2439
2440 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
2441 , HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2442 HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN((uintptr_t*)result))
2443 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte
2444 , HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2445 HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN((char*)result))
2446 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short
2447 , HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
2448 HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN((uint16_t*)result))
2449 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char
2450 , HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
2451 HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(result))
2452 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int
2453 , HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2454 HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN((uint32_t*)result))
2455 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long
2456 , HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2457 HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(((uintptr_t*)result)))
2458 // Float and double probes don't return value because dtrace doesn't currently support it
2459 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float
2460 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2461 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
2462 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
2463 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
2464 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
2465
2466
2467 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
2468 , EntryProbe, ReturnProbe);\
2469 \
2470 JNI_ENTRY_NO_PRESERVE(void, \
2471 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
2472 ElementType *buf, jint mode)) \
2473 EntryProbe; \
2474 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
2475 int len = a->length(); \
2476 if (len != 0) { /* Empty array: nothing to free or copy. */ \
2477 if ((mode == 0) || (mode == JNI_COMMIT)) { \
2478 ArrayAccess<>::arraycopy_from_native(buf, a, typeArrayOopDesc::element_offset<ElementType>(0), len); \
2479 } \
2480 if ((mode == 0) || (mode == JNI_ABORT)) { \
2481 FreeHeap(buf); \
2482 } \
2483 } \
2484 ReturnProbe; \
2485 JNI_END
2486
2487 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
2488 , HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
2489 HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN())
2490 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte
2491 , HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(env, array, (char *) buf, mode),
2492 HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN())
2493 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short
2494 , HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
2495 HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN())
2496 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char
2497 , HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
2498 HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN())
2499 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int
2500 , HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(env, array, (uint32_t *) buf, mode),
2501 HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN())
2502 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long
2503 , HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
2504 HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN())
2505 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float
2506 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
2507 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
2508 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
2509 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
2510 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
2511
2512 static void check_bounds(jsize start, jsize copy_len, jsize array_len, TRAPS) {
2513 ResourceMark rm(THREAD);
2514 if (copy_len < 0) {
2515 stringStream ss;
2516 ss.print("Length %d is negative", copy_len);
2517 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2518 } else if (start < 0 || (start > array_len - copy_len)) {
2519 stringStream ss;
2520 ss.print("Array region %d.." INT64_FORMAT " out of bounds for length %d",
2521 start, (int64_t)start+(int64_t)copy_len, array_len);
2522 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string());
2523 }
2524 }
2525
2526 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
2527 , EntryProbe, ReturnProbe); \
2528 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
2529 , ReturnProbe); \
2530 \
2531 JNI_ENTRY(void, \
2532 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
2533 jsize len, ElementType *buf)) \
2534 EntryProbe; \
2535 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
2536 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
2537 check_bounds(start, len, src->length(), CHECK); \
2538 if (len > 0) { \
2539 ArrayAccess<>::arraycopy_to_native(src, typeArrayOopDesc::element_offset<ElementType>(start), buf, len); \
2540 } \
2541 JNI_END
2542
2543 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool
2544 , HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
2545 HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN());
2546 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte
2547 , HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
2548 HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN());
2549 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short
2550 , HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
2551 HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN());
2552 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char
2553 , HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t*) buf),
2554 HOTSPOT_JNI_GETCHARARRAYREGION_RETURN());
2555 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int
2556 , HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t*) buf),
2557 HOTSPOT_JNI_GETINTARRAYREGION_RETURN());
2558 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long
2559 , HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
2560 HOTSPOT_JNI_GETLONGARRAYREGION_RETURN());
2561 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float
2562 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
2563 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
2564 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
2565 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
2566 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
2567
2568
2569 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
2570 , EntryProbe, ReturnProbe); \
2571 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
2572 ,ReturnProbe); \
2573 \
2574 JNI_ENTRY(void, \
2575 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
2576 jsize len, const ElementType *buf)) \
2577 EntryProbe; \
2578 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
2579 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
2580 check_bounds(start, len, dst->length(), CHECK); \
2581 if (len > 0) { \
2582 ArrayAccess<>::arraycopy_from_native(buf, dst, typeArrayOopDesc::element_offset<ElementType>(start), len); \
2583 } \
2584 JNI_END
2585
2586 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool
2587 , HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *)buf),
2588 HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN())
2589 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte
2590 , HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
2591 HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN())
2592 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short
2593 , HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
2594 HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN())
2595 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char
2596 , HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
2597 HOTSPOT_JNI_SETCHARARRAYREGION_RETURN())
2598 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int
2599 , HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t *) buf),
2600 HOTSPOT_JNI_SETINTARRAYREGION_RETURN())
2601 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long
2602 , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
2603 HOTSPOT_JNI_SETLONGARRAYREGION_RETURN())
2604 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float
2605 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
2606 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
2607 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
2608 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
2609 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
2610
2611
2612 DT_RETURN_MARK_DECL(RegisterNatives, jint
2613 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
2614
2615 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
2616 const JNINativeMethod *methods,
2617 jint nMethods))
2618 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
2619 jint ret = 0;
2620 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
2621
2622 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
2623
2624 // There are no restrictions on native code registering native methods,
2625 // which allows agents to redefine the bindings to native methods, however
2626 // we issue a warning if any code running outside of the boot/platform
2627 // loader is rebinding any native methods in classes loaded by the
2628 // boot/platform loader that are in named modules. That will catch changes
2629 // to platform classes while excluding classes added to the bootclasspath.
2630 bool do_warning = false;
2631
2632 // Only instanceKlasses can have native methods
2633 if (k->is_instance_klass()) {
2634 oop cl = k->class_loader();
2635 InstanceKlass* ik = InstanceKlass::cast(k);
2636 // Check for a platform class
2637 if ((cl == nullptr || SystemDictionary::is_platform_class_loader(cl)) &&
2638 ik->module()->is_named()) {
2639 Klass* caller = thread->security_get_caller_class(1);
2640 // If no caller class, or caller class has a different loader, then
2641 // issue a warning below.
2642 do_warning = (caller == nullptr) || caller->class_loader() != cl;
2643 }
2644 }
2645
2646
2647 for (int index = 0; index < nMethods; index++) {
2648 const char* meth_name = methods[index].name;
2649 const char* meth_sig = methods[index].signature;
2650 int meth_name_len = (int)strlen(meth_name);
2651
2652 // The class should have been loaded (we have an instance of the class
2653 // passed in) so the method and signature should already be in the symbol
2654 // table. If they're not there, the method doesn't exist.
2655 TempNewSymbol name = SymbolTable::probe(meth_name, meth_name_len);
2656 TempNewSymbol signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
2657
2658 if (name == nullptr || signature == nullptr) {
2659 ResourceMark rm(THREAD);
2660 stringStream st;
2661 st.print("Method %s.%s%s not found", k->external_name(), meth_name, meth_sig);
2662 // Must return negative value on failure
2663 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
2664 }
2665
2666 if (do_warning) {
2667 ResourceMark rm(THREAD);
2668 log_warning(jni, resolve)("Re-registering of platform native method: %s.%s%s "
2669 "from code in a different classloader", k->external_name(), meth_name, meth_sig);
2670 }
2671
2672 bool res = Method::register_native(k, name, signature,
2673 (address) methods[index].fnPtr, THREAD);
2674 if (!res) {
2675 ret = -1;
2676 break;
2677 }
2678 }
2679 return ret;
2680 JNI_END
2681
2682
2683 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
2684 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
2685 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
2686 //%note jni_2
2687 if (k->is_instance_klass()) {
2688 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
2689 Method* m = InstanceKlass::cast(k)->methods()->at(index);
2690 if (m->is_native()) {
2691 m->clear_native_function();
2692 m->set_signature_handler(nullptr);
2693 }
2694 }
2695 }
2696 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
2697 return 0;
2698 JNI_END
2699
2700 //
2701 // Monitor functions
2702 //
2703
2704 DT_RETURN_MARK_DECL(MonitorEnter, jint
2705 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
2706
2707 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
2708 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
2709 jint ret = JNI_ERR;
2710 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
2711
2712 // If the object is null, we can't do anything with it
2713 if (jobj == nullptr) {
2714 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
2715 }
2716
2717 Handle obj(thread, JNIHandles::resolve_non_null(jobj));
2718 ObjectSynchronizer::jni_enter(obj, thread);
2719 return JNI_OK;
2720 JNI_END
2721
2722 DT_RETURN_MARK_DECL(MonitorExit, jint
2723 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
2724
2725 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
2726 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
2727 jint ret = JNI_ERR;
2728 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
2729
2730 // Don't do anything with a null object
2731 if (jobj == nullptr) {
2732 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
2733 }
2734
2735 Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
2736 ObjectSynchronizer::jni_exit(obj(), CHECK_(JNI_ERR));
2737 return JNI_OK;
2738 JNI_END
2739
2740 //
2741 // Extensions
2742 //
2743
2744 DT_VOID_RETURN_MARK_DECL(GetStringRegion
2745 , HOTSPOT_JNI_GETSTRINGREGION_RETURN());
2746
2747 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
2748 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
2749 DT_VOID_RETURN_MARK(GetStringRegion);
2750 oop s = JNIHandles::resolve_non_null(string);
2751 typeArrayOop s_value = java_lang_String::value(s);
2752 int s_len = java_lang_String::length(s, s_value);
2753 if (start < 0 || len < 0 || start > s_len - len) {
2754 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
2755 } else {
2756 if (len > 0) {
2757 bool is_latin1 = java_lang_String::is_latin1(s);
2758 if (!is_latin1) {
2759 ArrayAccess<>::arraycopy_to_native(s_value, typeArrayOopDesc::element_offset<jchar>(start),
2760 buf, len);
2761 } else {
2762 for (int i = 0; i < len; i++) {
2763 buf[i] = ((jchar) s_value->byte_at(i + start)) & 0xff;
2764 }
2765 }
2766 }
2767 }
2768 JNI_END
2769
2770 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
2771 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
2772
2773 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
2774 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
2775 DT_VOID_RETURN_MARK(GetStringUTFRegion);
2776 oop s = JNIHandles::resolve_non_null(string);
2777 typeArrayOop s_value = java_lang_String::value(s);
2778 int s_len = java_lang_String::length(s, s_value);
2779 if (start < 0 || len < 0 || start > s_len - len) {
2780 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
2781 } else {
2782 //%note jni_7
2783 if (len > 0) {
2784 // Assume the buffer is large enough as the JNI spec. does not require user error checking
2785 java_lang_String::as_utf8_string(s, s_value, start, len, buf, INT_MAX);
2786 // as_utf8_string null-terminates the result string
2787 } else {
2788 // JDK null-terminates the buffer even in len is zero
2789 if (buf != nullptr) {
2790 buf[0] = 0;
2791 }
2792 }
2793 }
2794 JNI_END
2795
2796 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
2797 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
2798 Handle a(thread, JNIHandles::resolve_non_null(array));
2799 assert(a->is_typeArray(), "just checking");
2800
2801 // Pin object
2802 Universe::heap()->pin_object(thread, a());
2803
2804 BasicType type = TypeArrayKlass::cast(a->klass())->element_type();
2805 void* ret = arrayOop(a())->base(type);
2806 if (isCopy != nullptr) {
2807 *isCopy = JNI_FALSE;
2808 }
2809 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
2810 return ret;
2811 JNI_END
2812
2813
2814 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
2815 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
2816 // Unpin object
2817 Universe::heap()->unpin_object(thread, JNIHandles::resolve_non_null(array));
2818 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN();
2819 JNI_END
2820
2821
2822 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
2823 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
2824 oop s = JNIHandles::resolve_non_null(string);
2825 jchar* ret;
2826 if (!java_lang_String::is_latin1(s)) {
2827 typeArrayHandle s_value(thread, java_lang_String::value(s));
2828
2829 // Pin value array
2830 Universe::heap()->pin_object(thread, s_value());
2831
2832 ret = (jchar*) s_value->base(T_CHAR);
2833 if (isCopy != nullptr) *isCopy = JNI_FALSE;
2834 } else {
2835 // Inflate latin1 encoded string to UTF16
2836 typeArrayOop s_value = java_lang_String::value(s);
2837 int s_len = java_lang_String::length(s, s_value);
2838 ret = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal); // add one for zero termination
2839 /* JNI Specification states return null on OOM */
2840 if (ret != nullptr) {
2841 for (int i = 0; i < s_len; i++) {
2842 ret[i] = ((jchar) s_value->byte_at(i)) & 0xff;
2843 }
2844 ret[s_len] = 0;
2845 }
2846 if (isCopy != nullptr) *isCopy = JNI_TRUE;
2847 }
2848 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
2849 return ret;
2850 JNI_END
2851
2852
2853 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
2854 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
2855 oop s = JNIHandles::resolve_non_null(str);
2856 bool is_latin1 = java_lang_String::is_latin1(s);
2857
2858 if (is_latin1) {
2859 // For latin1 string, free jchar array allocated by earlier call to GetStringCritical.
2860 // This assumes that ReleaseStringCritical bookends GetStringCritical.
2861 FREE_C_HEAP_ARRAY(jchar, chars);
2862 } else {
2863 // StringDedup can have replaced the value array, so don't fetch the array from 's'.
2864 // Instead, we calculate the address based on the jchar array exposed with GetStringCritical.
2865 oop value = cast_to_oop((address)chars - arrayOopDesc::base_offset_in_bytes(T_CHAR));
2866
2867 // Unpin value array
2868 Universe::heap()->unpin_object(thread, value);
2869 }
2870 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
2871 JNI_END
2872
2873
2874 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
2875 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
2876 Handle ref_handle(thread, JNIHandles::resolve(ref));
2877 jweak ret = JNIHandles::make_weak_global(ref_handle, AllocFailStrategy::RETURN_NULL);
2878 if (ret == nullptr) {
2879 THROW_OOP_(Universe::out_of_memory_error_c_heap(), nullptr);
2880 }
2881 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
2882 return ret;
2883 JNI_END
2884
2885 // Must be JNI_ENTRY (with HandleMark)
2886 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
2887 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
2888 JNIHandles::destroy_weak_global(ref);
2889 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
2890 JNI_END
2891
2892
2893 JNI_ENTRY_NO_PRESERVE(jboolean, jni_ExceptionCheck(JNIEnv *env))
2894 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
2895 jni_check_async_exceptions(thread);
2896 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
2897 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
2898 return ret;
2899 JNI_END
2900
2901
2902 // Initialization state for three routines below relating to
2903 // java.nio.DirectBuffers
2904 static int directBufferSupportInitializeStarted = 0;
2905 static volatile int directBufferSupportInitializeEnded = 0;
2906 static volatile int directBufferSupportInitializeFailed = 0;
2907 static jclass bufferClass = nullptr;
2908 static jclass directBufferClass = nullptr;
2909 static jclass directByteBufferClass = nullptr;
2910 static jmethodID directByteBufferConstructor = nullptr;
2911 static jfieldID directBufferAddressField = nullptr;
2912 static jfieldID bufferCapacityField = nullptr;
2913
2914 static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) {
2915 Handle loader; // null (bootstrap) loader
2916 Handle protection_domain; // null protection domain
2917
2918 TempNewSymbol sym = SymbolTable::new_symbol(name);
2919 jclass result = find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL);
2920
2921 if (log_is_enabled(Debug, class, resolve) && result != nullptr) {
2922 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
2923 }
2924 return result;
2925 }
2926
2927 // These lookups are done with the null (bootstrap) ClassLoader to
2928 // circumvent any security checks that would be done by jni_FindClass.
2929 JNI_ENTRY(bool, lookupDirectBufferClasses(JNIEnv* env))
2930 {
2931 if ((bufferClass = lookupOne(env, "java/nio/Buffer", thread)) == nullptr) { return false; }
2932 if ((directBufferClass = lookupOne(env, "sun/nio/ch/DirectBuffer", thread)) == nullptr) { return false; }
2933 if ((directByteBufferClass = lookupOne(env, "java/nio/DirectByteBuffer", thread)) == nullptr) { return false; }
2934 return true;
2935 }
2936 JNI_END
2937
2938
2939 static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
2940 if (directBufferSupportInitializeFailed) {
2941 return false;
2942 }
2943
2944 if (Atomic::cmpxchg(&directBufferSupportInitializeStarted, 0, 1) == 0) {
2945 if (!lookupDirectBufferClasses(env)) {
2946 directBufferSupportInitializeFailed = 1;
2947 return false;
2948 }
2949
2950 // Make global references for these
2951 bufferClass = (jclass) env->NewGlobalRef(bufferClass);
2952 directBufferClass = (jclass) env->NewGlobalRef(directBufferClass);
2953 directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
2954
2955 // Global refs will be null if out-of-memory (no exception is pending)
2956 if (bufferClass == nullptr || directBufferClass == nullptr || directByteBufferClass == nullptr) {
2957 directBufferSupportInitializeFailed = 1;
2958 return false;
2959 }
2960
2961 // Get needed field and method IDs
2962 directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JJ)V");
2963 if (env->ExceptionCheck()) {
2964 env->ExceptionClear();
2965 directBufferSupportInitializeFailed = 1;
2966 return false;
2967 }
2968 directBufferAddressField = env->GetFieldID(bufferClass, "address", "J");
2969 if (env->ExceptionCheck()) {
2970 env->ExceptionClear();
2971 directBufferSupportInitializeFailed = 1;
2972 return false;
2973 }
2974 bufferCapacityField = env->GetFieldID(bufferClass, "capacity", "I");
2975 if (env->ExceptionCheck()) {
2976 env->ExceptionClear();
2977 directBufferSupportInitializeFailed = 1;
2978 return false;
2979 }
2980
2981 if ((directByteBufferConstructor == nullptr) ||
2982 (directBufferAddressField == nullptr) ||
2983 (bufferCapacityField == nullptr)) {
2984 directBufferSupportInitializeFailed = 1;
2985 return false;
2986 }
2987
2988 directBufferSupportInitializeEnded = 1;
2989 } else {
2990 while (!directBufferSupportInitializeEnded && !directBufferSupportInitializeFailed) {
2991 os::naked_yield();
2992 }
2993 }
2994
2995 return !directBufferSupportInitializeFailed;
2996 }
2997
2998 extern "C" jobject JNICALL jni_NewDirectByteBuffer(JNIEnv *env, void* address, jlong capacity)
2999 {
3000 // thread_from_jni_environment() will block if VM is gone.
3001 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
3002
3003 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
3004
3005 if (!directBufferSupportInitializeEnded) {
3006 if (!initializeDirectBufferSupport(env, thread)) {
3007 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(nullptr);
3008 return nullptr;
3009 }
3010 }
3011
3012 // Being paranoid about accidental sign extension on address
3013 jlong addr = (jlong) ((uintptr_t) address);
3014 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, capacity);
3015 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
3016 return ret;
3017 }
3018
3019 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
3020 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
3021
3022 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
3023 {
3024 // thread_from_jni_environment() will block if VM is gone.
3025 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
3026
3027 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
3028 void* ret = nullptr;
3029 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
3030
3031 if (!directBufferSupportInitializeEnded) {
3032 if (!initializeDirectBufferSupport(env, thread)) {
3033 return 0;
3034 }
3035 }
3036
3037 if ((buf != nullptr) && (!env->IsInstanceOf(buf, directBufferClass))) {
3038 return 0;
3039 }
3040
3041 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
3042 return ret;
3043 }
3044
3045 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
3046 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
3047
3048 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
3049 {
3050 // thread_from_jni_environment() will block if VM is gone.
3051 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
3052
3053 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
3054 jlong ret = -1;
3055 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
3056
3057 if (!directBufferSupportInitializeEnded) {
3058 if (!initializeDirectBufferSupport(env, thread)) {
3059 ret = 0;
3060 return ret;
3061 }
3062 }
3063
3064 if (buf == nullptr) {
3065 return -1;
3066 }
3067
3068 if (!env->IsInstanceOf(buf, directBufferClass)) {
3069 return -1;
3070 }
3071
3072 // NOTE that capacity is currently an int in the implementation
3073 ret = env->GetIntField(buf, bufferCapacityField);
3074 return ret;
3075 }
3076
3077
3078 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
3079 HOTSPOT_JNI_GETVERSION_ENTRY(env);
3080 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
3081 return CurrentVersion;
3082 JNI_END
3083
3084 extern struct JavaVM_ main_vm;
3085
3086 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
3087 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
3088 *vm = (JavaVM *)(&main_vm);
3089 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
3090 return JNI_OK;
3091 JNI_END
3092
3093
3094 JNI_ENTRY(jobject, jni_GetModule(JNIEnv* env, jclass clazz))
3095 return Modules::get_module(clazz, THREAD);
3096 JNI_END
3097
3098 JNI_ENTRY(jboolean, jni_IsVirtualThread(JNIEnv* env, jobject obj))
3099 oop thread_obj = JNIHandles::resolve_external_guard(obj);
3100 if (thread_obj != nullptr && thread_obj->is_a(vmClasses::BaseVirtualThread_klass())) {
3101 return JNI_TRUE;
3102 } else {
3103 return JNI_FALSE;
3104 }
3105 JNI_END
3106
3107
3108 // Structure containing all jni functions
3109 struct JNINativeInterface_ jni_NativeInterface = {
3110 nullptr,
3111 nullptr,
3112 nullptr,
3113
3114 nullptr,
3115
3116 jni_GetVersion,
3117
3118 jni_DefineClass,
3119 jni_FindClass,
3120
3121 jni_FromReflectedMethod,
3122 jni_FromReflectedField,
3123
3124 jni_ToReflectedMethod,
3125
3126 jni_GetSuperclass,
3127 jni_IsAssignableFrom,
3128
3129 jni_ToReflectedField,
3130
3131 jni_Throw,
3132 jni_ThrowNew,
3133 jni_ExceptionOccurred,
3134 jni_ExceptionDescribe,
3135 jni_ExceptionClear,
3136 jni_FatalError,
3137
3138 jni_PushLocalFrame,
3139 jni_PopLocalFrame,
3140
3141 jni_NewGlobalRef,
3142 jni_DeleteGlobalRef,
3143 jni_DeleteLocalRef,
3144 jni_IsSameObject,
3145
3146 jni_NewLocalRef,
3147 jni_EnsureLocalCapacity,
3148
3149 jni_AllocObject,
3150 jni_NewObject,
3151 jni_NewObjectV,
3152 jni_NewObjectA,
3153
3154 jni_GetObjectClass,
3155 jni_IsInstanceOf,
3156
3157 jni_GetMethodID,
3158
3159 jni_CallObjectMethod,
3160 jni_CallObjectMethodV,
3161 jni_CallObjectMethodA,
3162 jni_CallBooleanMethod,
3163 jni_CallBooleanMethodV,
3164 jni_CallBooleanMethodA,
3165 jni_CallByteMethod,
3166 jni_CallByteMethodV,
3167 jni_CallByteMethodA,
3168 jni_CallCharMethod,
3169 jni_CallCharMethodV,
3170 jni_CallCharMethodA,
3171 jni_CallShortMethod,
3172 jni_CallShortMethodV,
3173 jni_CallShortMethodA,
3174 jni_CallIntMethod,
3175 jni_CallIntMethodV,
3176 jni_CallIntMethodA,
3177 jni_CallLongMethod,
3178 jni_CallLongMethodV,
3179 jni_CallLongMethodA,
3180 jni_CallFloatMethod,
3181 jni_CallFloatMethodV,
3182 jni_CallFloatMethodA,
3183 jni_CallDoubleMethod,
3184 jni_CallDoubleMethodV,
3185 jni_CallDoubleMethodA,
3186 jni_CallVoidMethod,
3187 jni_CallVoidMethodV,
3188 jni_CallVoidMethodA,
3189
3190 jni_CallNonvirtualObjectMethod,
3191 jni_CallNonvirtualObjectMethodV,
3192 jni_CallNonvirtualObjectMethodA,
3193 jni_CallNonvirtualBooleanMethod,
3194 jni_CallNonvirtualBooleanMethodV,
3195 jni_CallNonvirtualBooleanMethodA,
3196 jni_CallNonvirtualByteMethod,
3197 jni_CallNonvirtualByteMethodV,
3198 jni_CallNonvirtualByteMethodA,
3199 jni_CallNonvirtualCharMethod,
3200 jni_CallNonvirtualCharMethodV,
3201 jni_CallNonvirtualCharMethodA,
3202 jni_CallNonvirtualShortMethod,
3203 jni_CallNonvirtualShortMethodV,
3204 jni_CallNonvirtualShortMethodA,
3205 jni_CallNonvirtualIntMethod,
3206 jni_CallNonvirtualIntMethodV,
3207 jni_CallNonvirtualIntMethodA,
3208 jni_CallNonvirtualLongMethod,
3209 jni_CallNonvirtualLongMethodV,
3210 jni_CallNonvirtualLongMethodA,
3211 jni_CallNonvirtualFloatMethod,
3212 jni_CallNonvirtualFloatMethodV,
3213 jni_CallNonvirtualFloatMethodA,
3214 jni_CallNonvirtualDoubleMethod,
3215 jni_CallNonvirtualDoubleMethodV,
3216 jni_CallNonvirtualDoubleMethodA,
3217 jni_CallNonvirtualVoidMethod,
3218 jni_CallNonvirtualVoidMethodV,
3219 jni_CallNonvirtualVoidMethodA,
3220
3221 jni_GetFieldID,
3222
3223 jni_GetObjectField,
3224 jni_GetBooleanField,
3225 jni_GetByteField,
3226 jni_GetCharField,
3227 jni_GetShortField,
3228 jni_GetIntField,
3229 jni_GetLongField,
3230 jni_GetFloatField,
3231 jni_GetDoubleField,
3232
3233 jni_SetObjectField,
3234 jni_SetBooleanField,
3235 jni_SetByteField,
3236 jni_SetCharField,
3237 jni_SetShortField,
3238 jni_SetIntField,
3239 jni_SetLongField,
3240 jni_SetFloatField,
3241 jni_SetDoubleField,
3242
3243 jni_GetStaticMethodID,
3244
3245 jni_CallStaticObjectMethod,
3246 jni_CallStaticObjectMethodV,
3247 jni_CallStaticObjectMethodA,
3248 jni_CallStaticBooleanMethod,
3249 jni_CallStaticBooleanMethodV,
3250 jni_CallStaticBooleanMethodA,
3251 jni_CallStaticByteMethod,
3252 jni_CallStaticByteMethodV,
3253 jni_CallStaticByteMethodA,
3254 jni_CallStaticCharMethod,
3255 jni_CallStaticCharMethodV,
3256 jni_CallStaticCharMethodA,
3257 jni_CallStaticShortMethod,
3258 jni_CallStaticShortMethodV,
3259 jni_CallStaticShortMethodA,
3260 jni_CallStaticIntMethod,
3261 jni_CallStaticIntMethodV,
3262 jni_CallStaticIntMethodA,
3263 jni_CallStaticLongMethod,
3264 jni_CallStaticLongMethodV,
3265 jni_CallStaticLongMethodA,
3266 jni_CallStaticFloatMethod,
3267 jni_CallStaticFloatMethodV,
3268 jni_CallStaticFloatMethodA,
3269 jni_CallStaticDoubleMethod,
3270 jni_CallStaticDoubleMethodV,
3271 jni_CallStaticDoubleMethodA,
3272 jni_CallStaticVoidMethod,
3273 jni_CallStaticVoidMethodV,
3274 jni_CallStaticVoidMethodA,
3275
3276 jni_GetStaticFieldID,
3277
3278 jni_GetStaticObjectField,
3279 jni_GetStaticBooleanField,
3280 jni_GetStaticByteField,
3281 jni_GetStaticCharField,
3282 jni_GetStaticShortField,
3283 jni_GetStaticIntField,
3284 jni_GetStaticLongField,
3285 jni_GetStaticFloatField,
3286 jni_GetStaticDoubleField,
3287
3288 jni_SetStaticObjectField,
3289 jni_SetStaticBooleanField,
3290 jni_SetStaticByteField,
3291 jni_SetStaticCharField,
3292 jni_SetStaticShortField,
3293 jni_SetStaticIntField,
3294 jni_SetStaticLongField,
3295 jni_SetStaticFloatField,
3296 jni_SetStaticDoubleField,
3297
3298 jni_NewString,
3299 jni_GetStringLength,
3300 jni_GetStringChars,
3301 jni_ReleaseStringChars,
3302
3303 jni_NewStringUTF,
3304 jni_GetStringUTFLength,
3305 jni_GetStringUTFChars,
3306 jni_ReleaseStringUTFChars,
3307
3308 jni_GetArrayLength,
3309
3310 jni_NewObjectArray,
3311 jni_GetObjectArrayElement,
3312 jni_SetObjectArrayElement,
3313
3314 jni_NewBooleanArray,
3315 jni_NewByteArray,
3316 jni_NewCharArray,
3317 jni_NewShortArray,
3318 jni_NewIntArray,
3319 jni_NewLongArray,
3320 jni_NewFloatArray,
3321 jni_NewDoubleArray,
3322
3323 jni_GetBooleanArrayElements,
3324 jni_GetByteArrayElements,
3325 jni_GetCharArrayElements,
3326 jni_GetShortArrayElements,
3327 jni_GetIntArrayElements,
3328 jni_GetLongArrayElements,
3329 jni_GetFloatArrayElements,
3330 jni_GetDoubleArrayElements,
3331
3332 jni_ReleaseBooleanArrayElements,
3333 jni_ReleaseByteArrayElements,
3334 jni_ReleaseCharArrayElements,
3335 jni_ReleaseShortArrayElements,
3336 jni_ReleaseIntArrayElements,
3337 jni_ReleaseLongArrayElements,
3338 jni_ReleaseFloatArrayElements,
3339 jni_ReleaseDoubleArrayElements,
3340
3341 jni_GetBooleanArrayRegion,
3342 jni_GetByteArrayRegion,
3343 jni_GetCharArrayRegion,
3344 jni_GetShortArrayRegion,
3345 jni_GetIntArrayRegion,
3346 jni_GetLongArrayRegion,
3347 jni_GetFloatArrayRegion,
3348 jni_GetDoubleArrayRegion,
3349
3350 jni_SetBooleanArrayRegion,
3351 jni_SetByteArrayRegion,
3352 jni_SetCharArrayRegion,
3353 jni_SetShortArrayRegion,
3354 jni_SetIntArrayRegion,
3355 jni_SetLongArrayRegion,
3356 jni_SetFloatArrayRegion,
3357 jni_SetDoubleArrayRegion,
3358
3359 jni_RegisterNatives,
3360 jni_UnregisterNatives,
3361
3362 jni_MonitorEnter,
3363 jni_MonitorExit,
3364
3365 jni_GetJavaVM,
3366
3367 jni_GetStringRegion,
3368 jni_GetStringUTFRegion,
3369
3370 jni_GetPrimitiveArrayCritical,
3371 jni_ReleasePrimitiveArrayCritical,
3372
3373 jni_GetStringCritical,
3374 jni_ReleaseStringCritical,
3375
3376 jni_NewWeakGlobalRef,
3377 jni_DeleteWeakGlobalRef,
3378
3379 jni_ExceptionCheck,
3380
3381 jni_NewDirectByteBuffer,
3382 jni_GetDirectBufferAddress,
3383 jni_GetDirectBufferCapacity,
3384
3385 // New 1_6 features
3386
3387 jni_GetObjectRefType,
3388
3389 // Module features
3390
3391 jni_GetModule,
3392
3393 // Virtual threads
3394
3395 jni_IsVirtualThread
3396 };
3397
3398
3399 // For jvmti use to modify jni function table.
3400 // Java threads in native contiues to run until it is transitioned
3401 // to VM at safepoint. Before the transition or before it is blocked
3402 // for safepoint it may access jni function table. VM could crash if
3403 // any java thread access the jni function table in the middle of memcpy.
3404 // To avoid this each function pointers are copied automically.
3405 void copy_jni_function_table(const struct JNINativeInterface_ *new_jni_NativeInterface) {
3406 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
3407 intptr_t *a = (intptr_t *) jni_functions();
3408 intptr_t *b = (intptr_t *) new_jni_NativeInterface;
3409 for (uint i=0; i < sizeof(struct JNINativeInterface_)/sizeof(void *); i++) {
3410 Atomic::store(a++, *b++);
3411 }
3412 }
3413
3414 void quicken_jni_functions() {
3415 // Replace Get<Primitive>Field with fast versions
3416 if (UseFastJNIAccessors && !VerifyJNIFields && !CheckJNICalls) {
3417 address func;
3418 func = JNI_FastGetField::generate_fast_get_boolean_field();
3419 if (func != (address)-1) {
3420 jni_NativeInterface.GetBooleanField = (GetBooleanField_t)func;
3421 }
3422 func = JNI_FastGetField::generate_fast_get_byte_field();
3423 if (func != (address)-1) {
3424 jni_NativeInterface.GetByteField = (GetByteField_t)func;
3425 }
3426 func = JNI_FastGetField::generate_fast_get_char_field();
3427 if (func != (address)-1) {
3428 jni_NativeInterface.GetCharField = (GetCharField_t)func;
3429 }
3430 func = JNI_FastGetField::generate_fast_get_short_field();
3431 if (func != (address)-1) {
3432 jni_NativeInterface.GetShortField = (GetShortField_t)func;
3433 }
3434 func = JNI_FastGetField::generate_fast_get_int_field();
3435 if (func != (address)-1) {
3436 jni_NativeInterface.GetIntField = (GetIntField_t)func;
3437 }
3438 func = JNI_FastGetField::generate_fast_get_long_field();
3439 if (func != (address)-1) {
3440 jni_NativeInterface.GetLongField = (GetLongField_t)func;
3441 }
3442 func = JNI_FastGetField::generate_fast_get_float_field();
3443 if (func != (address)-1) {
3444 jni_NativeInterface.GetFloatField = (GetFloatField_t)func;
3445 }
3446 func = JNI_FastGetField::generate_fast_get_double_field();
3447 if (func != (address)-1) {
3448 jni_NativeInterface.GetDoubleField = (GetDoubleField_t)func;
3449 }
3450 }
3451 }
3452
3453 // Returns the function structure
3454 struct JNINativeInterface_* jni_functions() {
3455 #if INCLUDE_JNI_CHECK
3456 if (CheckJNICalls) return jni_functions_check();
3457 #endif // INCLUDE_JNI_CHECK
3458 return &jni_NativeInterface;
3459 }
3460
3461 // Returns the function structure
3462 struct JNINativeInterface_* jni_functions_nocheck() {
3463 return &jni_NativeInterface;
3464 }
3465
3466 static void post_thread_start_event(const JavaThread* jt) {
3467 assert(jt != nullptr, "invariant");
3468 EventThreadStart event;
3469 if (event.should_commit()) {
3470 event.set_thread(JFR_JVM_THREAD_ID(jt));
3471 event.set_parentThread((traceid)0);
3472 #if INCLUDE_JFR
3473 if (EventThreadStart::is_stacktrace_enabled()) {
3474 jt->jfr_thread_local()->set_cached_stack_trace_id((traceid)0);
3475 event.commit();
3476 jt->jfr_thread_local()->clear_cached_stack_trace();
3477 } else
3478 #endif
3479 {
3480 event.commit();
3481 }
3482 }
3483 }
3484
3485 // Invocation API
3486
3487
3488 // Forward declaration
3489 extern const struct JNIInvokeInterface_ jni_InvokeInterface;
3490
3491 // Global invocation API vars
3492 volatile int vm_created = 0;
3493 // Indicate whether it is safe to recreate VM. Recreation is only
3494 // possible after a failed initial creation attempt in some cases.
3495 volatile int safe_to_recreate_vm = 1;
3496 struct JavaVM_ main_vm = {&jni_InvokeInterface};
3497
3498
3499 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */
3500 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
3501
3502 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
3503 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
3504
3505 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
3506 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
3507 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
3508 jint ret = JNI_ERR;
3509 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
3510
3511 if (Threads::is_supported_jni_version(args->version)) {
3512 ret = JNI_OK;
3513 }
3514 // 1.1 style no longer supported in hotspot.
3515 // According the JNI spec, we should update args->version on return.
3516 // We also use the structure to communicate with launcher about default
3517 // stack size.
3518 if (args->version == JNI_VERSION_1_1) {
3519 args->version = JNI_VERSION_1_2;
3520 // javaStackSize is int in arguments structure
3521 assert(jlong(ThreadStackSize) * K < INT_MAX, "integer overflow");
3522 args->javaStackSize = (jint)(ThreadStackSize * K);
3523 }
3524 return ret;
3525 }
3526
3527 DT_RETURN_MARK_DECL(CreateJavaVM, jint
3528 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
3529
3530 static jint JNI_CreateJavaVM_inner(JavaVM **vm, void **penv, void *args) {
3531 HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
3532
3533 jint result = JNI_ERR;
3534 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
3535
3536 // We're about to use Atomic::xchg for synchronization. Some Zero
3537 // platforms use the GCC builtin __sync_lock_test_and_set for this,
3538 // but __sync_lock_test_and_set is not guaranteed to do what we want
3539 // on all architectures. So we check it works before relying on it.
3540 #if defined(ZERO) && defined(ASSERT)
3541 {
3542 jint a = 0xcafebabe;
3543 jint b = Atomic::xchg(&a, (jint) 0xdeadbeef);
3544 void *c = &a;
3545 void *d = Atomic::xchg(&c, &b);
3546 assert(a == (jint) 0xdeadbeef && b == (jint) 0xcafebabe, "Atomic::xchg() works");
3547 assert(c == &b && d == &a, "Atomic::xchg() works");
3548 }
3549 #endif // ZERO && ASSERT
3550
3551 // At the moment it's only possible to have one Java VM,
3552 // since some of the runtime state is in global variables.
3553
3554 // We cannot use our mutex locks here, since they only work on
3555 // Threads. We do an atomic compare and exchange to ensure only
3556 // one thread can call this method at a time
3557
3558 // We use Atomic::xchg rather than Atomic::add/dec since on some platforms
3559 // the add/dec implementations are dependent on whether we are running
3560 // on a multiprocessor Atomic::xchg does not have this problem.
3561 if (Atomic::xchg(&vm_created, 1) == 1) {
3562 return JNI_EEXIST; // already created, or create attempt in progress
3563 }
3564
3565 // If a previous creation attempt failed but can be retried safely,
3566 // then safe_to_recreate_vm will have been reset to 1 after being
3567 // cleared here. If a previous creation attempt succeeded and we then
3568 // destroyed that VM, we will be prevented from trying to recreate
3569 // the VM in the same process, as the value will still be 0.
3570 if (Atomic::xchg(&safe_to_recreate_vm, 0) == 0) {
3571 return JNI_ERR;
3572 }
3573
3574 assert(vm_created == 1, "vm_created is true during the creation");
3575
3576 /**
3577 * Certain errors during initialization are recoverable and do not
3578 * prevent this method from being called again at a later time
3579 * (perhaps with different arguments). However, at a certain
3580 * point during initialization if an error occurs we cannot allow
3581 * this function to be called again (or it will crash). In those
3582 * situations, the 'canTryAgain' flag is set to false, which atomically
3583 * sets safe_to_recreate_vm to 1, such that any new call to
3584 * JNI_CreateJavaVM will immediately fail using the above logic.
3585 */
3586 bool can_try_again = true;
3587
3588 result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again);
3589 if (result == JNI_OK) {
3590 JavaThread *thread = JavaThread::current();
3591 assert(!thread->has_pending_exception(), "should have returned not OK");
3592 /* thread is thread_in_vm here */
3593 *vm = (JavaVM *)(&main_vm);
3594 *(JNIEnv**)penv = thread->jni_environment();
3595
3596 #if INCLUDE_JVMCI
3597 if (EnableJVMCI) {
3598 if (UseJVMCICompiler) {
3599 // JVMCI is initialized on a CompilerThread
3600 if (BootstrapJVMCI) {
3601 JavaThread* THREAD = thread; // For exception macros.
3602 JVMCICompiler* compiler = JVMCICompiler::instance(true, CATCH);
3603 compiler->bootstrap(THREAD);
3604 if (HAS_PENDING_EXCEPTION) {
3605 HandleMark hm(THREAD);
3606 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
3607 }
3608 }
3609 }
3610 }
3611 #endif
3612
3613 // Notify JVMTI
3614 if (JvmtiExport::should_post_thread_life()) {
3615 JvmtiExport::post_thread_start(thread);
3616 }
3617
3618 post_thread_start_event(thread);
3619
3620 if (ReplayCompiles) ciReplay::replay(thread);
3621
3622 #ifdef ASSERT
3623 // Some platforms (like Win*) need a wrapper around these test
3624 // functions in order to properly handle error conditions.
3625 if (ErrorHandlerTest != 0) {
3626 VMError::controlled_crash(ErrorHandlerTest);
3627 }
3628 #endif
3629
3630 // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
3631 ThreadStateTransition::transition_from_vm(thread, _thread_in_native);
3632 MACOS_AARCH64_ONLY(thread->enable_wx(WXExec));
3633 } else {
3634 // If create_vm exits because of a pending exception, exit with that
3635 // exception. In the future when we figure out how to reclaim memory,
3636 // we may be able to exit with JNI_ERR and allow the calling application
3637 // to continue.
3638 if (Universe::is_fully_initialized()) {
3639 // otherwise no pending exception possible - VM will already have aborted
3640 JavaThread* THREAD = JavaThread::current(); // For exception macros.
3641 if (HAS_PENDING_EXCEPTION) {
3642 HandleMark hm(THREAD);
3643 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
3644 }
3645 }
3646
3647 if (can_try_again) {
3648 // reset safe_to_recreate_vm to 1 so that retrial would be possible
3649 safe_to_recreate_vm = 1;
3650 }
3651
3652 // Creation failed. We must reset vm_created
3653 *vm = 0;
3654 *(JNIEnv**)penv = 0;
3655 // reset vm_created last to avoid race condition. Use OrderAccess to
3656 // control both compiler and architectural-based reordering.
3657 Atomic::release_store(&vm_created, 0);
3658 }
3659
3660 // Flush stdout and stderr before exit.
3661 fflush(stdout);
3662 fflush(stderr);
3663
3664 return result;
3665
3666 }
3667
3668 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
3669 jint result = JNI_ERR;
3670 // On Windows, let CreateJavaVM run with SEH protection
3671 #if defined(_WIN32) && !defined(USE_VECTORED_EXCEPTION_HANDLING)
3672 __try {
3673 #endif
3674 result = JNI_CreateJavaVM_inner(vm, penv, args);
3675 #if defined(_WIN32) && !defined(USE_VECTORED_EXCEPTION_HANDLING)
3676 } __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
3677 // Nothing to do.
3678 }
3679 #endif
3680 return result;
3681 }
3682
3683 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
3684 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
3685
3686 if (vm_created == 1) {
3687 if (numVMs != nullptr) *numVMs = 1;
3688 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
3689 } else {
3690 if (numVMs != nullptr) *numVMs = 0;
3691 }
3692 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
3693 return JNI_OK;
3694 }
3695
3696 extern "C" {
3697
3698 DT_RETURN_MARK_DECL(DestroyJavaVM, jint
3699 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
3700
3701 static jint JNICALL jni_DestroyJavaVM_inner(JavaVM *vm) {
3702 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
3703 jint res = JNI_ERR;
3704 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
3705
3706 if (vm_created == 0) {
3707 res = JNI_ERR;
3708 return res;
3709 }
3710
3711 JNIEnv *env;
3712 JavaVMAttachArgs destroyargs;
3713 destroyargs.version = CurrentVersion;
3714 destroyargs.name = (char *)"DestroyJavaVM";
3715 destroyargs.group = nullptr;
3716 res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs);
3717 if (res != JNI_OK) {
3718 return res;
3719 }
3720
3721 JavaThread* thread = JavaThread::current();
3722
3723 // Make sure we are actually in a newly attached thread, with no
3724 // existing Java frame.
3725 if (thread->has_last_Java_frame()) {
3726 return JNI_ERR;
3727 }
3728
3729 // Since this is not a JVM_ENTRY we have to set the thread state manually before entering.
3730
3731 // We are going to VM, change W^X state to the expected one.
3732 MACOS_AARCH64_ONLY(WXMode oldmode = thread->enable_wx(WXWrite));
3733
3734 ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
3735 Threads::destroy_vm();
3736 // Don't bother restoring thread state, VM is gone.
3737 vm_created = 0;
3738 return JNI_OK;
3739 }
3740
3741 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
3742 jint result = JNI_ERR;
3743 // On Windows, we need SEH protection
3744 #if defined(_WIN32) && !defined(USE_VECTORED_EXCEPTION_HANDLING)
3745 __try {
3746 #endif
3747 result = jni_DestroyJavaVM_inner(vm);
3748 #if defined(_WIN32) && !defined(USE_VECTORED_EXCEPTION_HANDLING)
3749 } __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
3750 // Nothing to do.
3751 }
3752 #endif
3753 return result;
3754 }
3755
3756 static jint attach_current_thread(JavaVM *vm, void **penv, void *_args, bool daemon) {
3757 JavaVMAttachArgs *args = (JavaVMAttachArgs *) _args;
3758
3759 // Check below commented out from JDK1.2fcs as well
3760 /*
3761 if (args && (args->version != JNI_VERSION_1_1 || args->version != JNI_VERSION_1_2)) {
3762 return JNI_EVERSION;
3763 }
3764 */
3765
3766 Thread* t = Thread::current_or_null();
3767 if (t != nullptr) {
3768 // If executing from an atexit hook we may be in the VMThread.
3769 if (t->is_Java_thread()) {
3770 // If the thread has been attached this operation is a no-op
3771 *(JNIEnv**)penv = JavaThread::cast(t)->jni_environment();
3772 return JNI_OK;
3773 } else {
3774 return JNI_ERR;
3775 }
3776 }
3777
3778 // Create a thread and mark it as attaching so it will be skipped by the
3779 // ThreadsListEnumerator - see CR 6404306
3780 JavaThread* thread = new JavaThread(true);
3781
3782 // Set correct safepoint info. The thread is going to call into Java when
3783 // initializing the Java level thread object. Hence, the correct state must
3784 // be set in order for the Safepoint code to deal with it correctly.
3785 thread->set_thread_state(_thread_in_vm);
3786 thread->record_stack_base_and_size();
3787 thread->register_thread_stack_with_NMT();
3788 thread->initialize_thread_current();
3789 MACOS_AARCH64_ONLY(thread->init_wx());
3790
3791 if (!os::create_attached_thread(thread)) {
3792 thread->smr_delete();
3793 return JNI_ERR;
3794 }
3795 // Enable stack overflow checks
3796 thread->stack_overflow_state()->create_stack_guard_pages();
3797
3798 thread->initialize_tlab();
3799
3800 thread->cache_global_variables();
3801
3802 // This thread will not do a safepoint check, since it has
3803 // not been added to the Thread list yet.
3804 { MutexLocker ml(Threads_lock);
3805 // This must be inside this lock in order to get FullGCALot to work properly, i.e., to
3806 // avoid this thread trying to do a GC before it is added to the thread-list
3807 thread->set_active_handles(JNIHandleBlock::allocate_block());
3808 Threads::add(thread, daemon);
3809 }
3810 // Create thread group and name info from attach arguments
3811 oop group = nullptr;
3812 char* thread_name = nullptr;
3813 if (args != nullptr && Threads::is_supported_jni_version(args->version)) {
3814 group = JNIHandles::resolve(args->group);
3815 thread_name = args->name; // may be null
3816 }
3817 if (group == nullptr) group = Universe::main_thread_group();
3818
3819 // Create Java level thread object and attach it to this thread
3820 bool attach_failed = false;
3821 {
3822 EXCEPTION_MARK;
3823 HandleMark hm(THREAD);
3824 Handle thread_group(THREAD, group);
3825 thread->allocate_threadObj(thread_group, thread_name, daemon, THREAD);
3826 if (HAS_PENDING_EXCEPTION) {
3827 CLEAR_PENDING_EXCEPTION;
3828 // cleanup outside the handle mark.
3829 attach_failed = true;
3830 }
3831 }
3832
3833 if (attach_failed) {
3834 // Added missing cleanup
3835 thread->cleanup_failed_attach_current_thread(daemon);
3836 return JNI_ERR;
3837 }
3838
3839 // mark the thread as no longer attaching
3840 // this uses a fence to push the change through so we don't have
3841 // to regrab the threads_lock
3842 thread->set_done_attaching_via_jni();
3843
3844 // Set java thread status.
3845 java_lang_Thread::set_thread_status(thread->threadObj(),
3846 JavaThreadStatus::RUNNABLE);
3847
3848 // Notify the debugger
3849 if (JvmtiExport::should_post_thread_life()) {
3850 JvmtiExport::post_thread_start(thread);
3851 }
3852
3853 post_thread_start_event(thread);
3854
3855 *(JNIEnv**)penv = thread->jni_environment();
3856
3857 // Now leaving the VM, so change thread_state. This is normally automatically taken care
3858 // of in the JVM_ENTRY. But in this situation we have to do it manually.
3859 ThreadStateTransition::transition_from_vm(thread, _thread_in_native);
3860 MACOS_AARCH64_ONLY(thread->enable_wx(WXExec));
3861
3862 // Perform any platform dependent FPU setup
3863 os::setup_fpu();
3864
3865 return JNI_OK;
3866 }
3867
3868
3869 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
3870 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
3871 if (vm_created == 0) {
3872 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
3873 return JNI_ERR;
3874 }
3875
3876 jint ret = attach_current_thread(vm, penv, _args, false);
3877 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
3878 return ret;
3879 }
3880
3881
3882 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
3883 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
3884 if (vm_created == 0) {
3885 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_ERR);
3886 return JNI_ERR;
3887 }
3888
3889 Thread* current = Thread::current_or_null();
3890
3891 // If the thread has already been detached the operation is a no-op
3892 if (current == nullptr) {
3893 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
3894 return JNI_OK;
3895 }
3896
3897 // If executing from an atexit hook we may be in the VMThread.
3898 if (!current->is_Java_thread()) {
3899 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
3900 return JNI_ERR;
3901 }
3902
3903 VM_Exit::block_if_vm_exited();
3904
3905 JavaThread* thread = JavaThread::cast(current);
3906 if (thread->has_last_Java_frame()) {
3907 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
3908 // Can't detach a thread that's running java, that can't work.
3909 return JNI_ERR;
3910 }
3911
3912 // We are going to VM, change W^X state to the expected one.
3913 MACOS_AARCH64_ONLY(thread->enable_wx(WXWrite));
3914
3915 // Safepoint support. Have to do call-back to safepoint code, if in the
3916 // middle of a safepoint operation
3917 ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
3918
3919 // XXX: Note that JavaThread::exit() call below removes the guards on the
3920 // stack pages set up via enable_stack_{red,yellow}_zone() calls
3921 // above in jni_AttachCurrentThread. Unfortunately, while the setting
3922 // of the guards is visible in jni_AttachCurrentThread above,
3923 // the removal of the guards is buried below in JavaThread::exit()
3924 // here. The abstraction should be more symmetrically either exposed
3925 // or hidden (e.g. it could probably be hidden in the same
3926 // (platform-dependent) methods where we do alternate stack
3927 // maintenance work?)
3928 thread->exit(false, JavaThread::jni_detach);
3929 thread->smr_delete();
3930
3931 // Go to the execute mode, the initial state of the thread on creation.
3932 // Use os interface as the thread is not a JavaThread anymore.
3933 MACOS_AARCH64_ONLY(os::current_thread_enable_wx(WXExec));
3934
3935 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
3936 return JNI_OK;
3937 }
3938
3939 DT_RETURN_MARK_DECL(GetEnv, jint
3940 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
3941
3942 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
3943 HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
3944 jint ret = JNI_ERR;
3945 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
3946
3947 if (vm_created == 0) {
3948 *penv = nullptr;
3949 ret = JNI_EDETACHED;
3950 return ret;
3951 }
3952
3953 if (JniExportedInterface::GetExportedInterface(vm, penv, version, &ret)) {
3954 return ret;
3955 }
3956
3957 #ifndef JVMPI_VERSION_1
3958 // need these in order to be polite about older agents
3959 #define JVMPI_VERSION_1 ((jint)0x10000001)
3960 #define JVMPI_VERSION_1_1 ((jint)0x10000002)
3961 #define JVMPI_VERSION_1_2 ((jint)0x10000003)
3962 #endif // !JVMPI_VERSION_1
3963
3964 Thread* thread = Thread::current_or_null();
3965 if (thread != nullptr && thread->is_Java_thread()) {
3966 if (Threads::is_supported_jni_version_including_1_1(version)) {
3967 *(JNIEnv**)penv = JavaThread::cast(thread)->jni_environment();
3968 ret = JNI_OK;
3969 return ret;
3970
3971 } else if (version == JVMPI_VERSION_1 ||
3972 version == JVMPI_VERSION_1_1 ||
3973 version == JVMPI_VERSION_1_2) {
3974 tty->print_cr("ERROR: JVMPI, an experimental interface, is no longer supported.");
3975 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
3976 ret = JNI_EVERSION;
3977 return ret;
3978 } else if (JvmtiExport::is_jvmdi_version(version)) {
3979 tty->print_cr("FATAL ERROR: JVMDI is no longer supported.");
3980 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
3981 ret = JNI_EVERSION;
3982 return ret;
3983 } else {
3984 *penv = nullptr;
3985 ret = JNI_EVERSION;
3986 return ret;
3987 }
3988 } else {
3989 *penv = nullptr;
3990 ret = JNI_EDETACHED;
3991 return ret;
3992 }
3993 }
3994
3995
3996 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
3997 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
3998 if (vm_created == 0) {
3999 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
4000 return JNI_ERR;
4001 }
4002
4003 jint ret = attach_current_thread(vm, penv, _args, true);
4004 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
4005 return ret;
4006 }
4007
4008
4009 } // End extern "C"
4010
4011 const struct JNIInvokeInterface_ jni_InvokeInterface = {
4012 nullptr,
4013 nullptr,
4014 nullptr,
4015
4016 jni_DestroyJavaVM,
4017 jni_AttachCurrentThread,
4018 jni_DetachCurrentThread,
4019 jni_GetEnv,
4020 jni_AttachCurrentThreadAsDaemon
4021 };