369
370 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
371
372 jclass result = NULL;
373 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
374
375 // Remember if we are the first invocation of jni_FindClass
376 bool first_time = first_time_FindClass;
377 first_time_FindClass = false;
378
379 // Sanity check the name: it cannot be null or larger than the maximum size
380 // name we can fit in the constant pool.
381 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
382 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
383 }
384
385 //%note jni_3
386 Handle loader;
387 Handle protection_domain;
388 // Find calling class
389 instanceKlassHandle k (THREAD, thread->security_get_caller_class(0));
390 if (k.not_null()) {
391 loader = Handle(THREAD, k->class_loader());
392 // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
393 // in the correct class context.
394 if (loader.is_null() &&
395 k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
396 JavaValue result(T_OBJECT);
397 JavaCalls::call_static(&result, k,
398 vmSymbols::getFromClass_name(),
399 vmSymbols::void_class_signature(),
400 thread);
401 if (HAS_PENDING_EXCEPTION) {
402 Handle ex(thread, thread->pending_exception());
403 CLEAR_PENDING_EXCEPTION;
404 THROW_HANDLE_0(ex);
405 }
406 oop mirror = (oop) result.get_jobject();
407 loader = Handle(THREAD,
408 InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->class_loader());
409 protection_domain = Handle(THREAD,
410 InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->protection_domain());
438 JNIWrapper("FromReflectedMethod");
439
440 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
441
442 jmethodID ret = NULL;
443 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
444
445 // method is a handle to a java.lang.reflect.Method object
446 oop reflected = JNIHandles::resolve_non_null(method);
447 oop mirror = NULL;
448 int slot = 0;
449
450 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
451 mirror = java_lang_reflect_Constructor::clazz(reflected);
452 slot = java_lang_reflect_Constructor::slot(reflected);
453 } else {
454 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
455 mirror = java_lang_reflect_Method::clazz(reflected);
456 slot = java_lang_reflect_Method::slot(reflected);
457 }
458 Klass* k = java_lang_Class::as_Klass(mirror);
459
460 KlassHandle k1(THREAD, k);
461 // Make sure class is initialized before handing id's out to methods
462 k1()->initialize(CHECK_NULL);
463 Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot);
464 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
465 return ret;
466 JNI_END
467
468 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
469 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
470
471 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
472 JNIWrapper("FromReflectedField");
473
474 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
475
476 jfieldID ret = NULL;
477 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
478
479 // field is a handle to a java.lang.reflect.Field object
480 oop reflected = JNIHandles::resolve_non_null(field);
481 oop mirror = java_lang_reflect_Field::clazz(reflected);
482 Klass* k = java_lang_Class::as_Klass(mirror);
483 int slot = java_lang_reflect_Field::slot(reflected);
484 int modifiers = java_lang_reflect_Field::modifiers(reflected);
485
486 KlassHandle k1(THREAD, k);
487 // Make sure class is initialized before handing id's out to fields
488 k1()->initialize(CHECK_NULL);
489
490 // First check if this is a static field
491 if (modifiers & JVM_ACC_STATIC) {
492 intptr_t offset = InstanceKlass::cast(k1())->field_offset( slot );
493 JNIid* id = InstanceKlass::cast(k1())->jni_id_for(offset);
494 assert(id != NULL, "corrupt Field object");
495 debug_only(id->set_is_static_field_id();)
496 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
497 ret = jfieldIDWorkaround::to_static_jfieldID(id);
498 return ret;
499 }
500
501 // The slot is the index of the field description in the field-array
502 // The jfieldID is the offset of the field within the object
503 // It may also have hash bits for k, if VerifyJNIFields is turned on.
504 intptr_t offset = InstanceKlass::cast(k1())->field_offset( slot );
505 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
506 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
507 return ret;
508 JNI_END
509
510
511 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
512 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
513
514 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
515 JNIWrapper("ToReflectedMethod");
516
517 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
518
519 jobject ret = NULL;
520 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
521
522 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
523 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
524 oop reflection_method;
525 if (m->is_initializer()) {
526 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
660 JNIWrapper("ExceptionDescribe");
661
662 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
663
664 if (thread->has_pending_exception()) {
665 Handle ex(thread, thread->pending_exception());
666 thread->clear_pending_exception();
667 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
668 // Don't print anything if we are being killed.
669 } else {
670 jio_fprintf(defaultStream::error_stream(), "Exception ");
671 if (thread != NULL && thread->threadObj() != NULL) {
672 ResourceMark rm(THREAD);
673 jio_fprintf(defaultStream::error_stream(),
674 "in thread \"%s\" ", thread->get_thread_name());
675 }
676 if (ex->is_a(SystemDictionary::Throwable_klass())) {
677 JavaValue result(T_VOID);
678 JavaCalls::call_virtual(&result,
679 ex,
680 KlassHandle(THREAD,
681 SystemDictionary::Throwable_klass()),
682 vmSymbols::printStackTrace_name(),
683 vmSymbols::void_method_signature(),
684 THREAD);
685 // If an exception is thrown in the call it gets thrown away. Not much
686 // we can do with it. The native code that calls this, does not check
687 // for the exception - hence, it might still be in the thread when DestroyVM gets
688 // called, potentially causing a few asserts to trigger - since no pending exception
689 // is expected.
690 CLEAR_PENDING_EXCEPTION;
691 } else {
692 ResourceMark rm(THREAD);
693 jio_fprintf(defaultStream::error_stream(),
694 ". Uncaught exception of type %s.",
695 ex->klass()->external_name());
696 }
697 }
698 }
699
700 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
701 JNI_END
1139 Method* m = Method::resolve_jmethod_id(method_id);
1140 number_of_parameters = m->size_of_parameters();
1141 Klass* holder = m->method_holder();
1142 if (call_type != JNI_VIRTUAL) {
1143 selected_method = m;
1144 } else if (!m->has_itable_index()) {
1145 // non-interface call -- for that little speed boost, don't handlize
1146 debug_only(NoSafepointVerifier nosafepoint;)
1147 // jni_GetMethodID makes sure class is linked and initialized
1148 // so m should have a valid vtable index.
1149 assert(m->valid_vtable_index(), "no valid vtable index");
1150 int vtbl_index = m->vtable_index();
1151 if (vtbl_index != Method::nonvirtual_vtable_index) {
1152 selected_method = h_recv->klass()->method_at_vtable(vtbl_index);
1153 } else {
1154 // final method
1155 selected_method = m;
1156 }
1157 } else {
1158 // interface call
1159 KlassHandle h_holder(THREAD, holder);
1160
1161 int itbl_index = m->itable_index();
1162 Klass* k = h_recv->klass();
1163 selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
1164 }
1165 }
1166
1167 methodHandle method(THREAD, selected_method);
1168
1169 // Create object to hold arguments for the JavaCall, and associate it with
1170 // the jni parser
1171 ResourceMark rm(THREAD);
1172 JavaCallArguments java_args(number_of_parameters);
1173 args->set_java_argument_object(&java_args);
1174
1175 // handle arguments
1176 assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
1177 args->push_receiver(h_recv); // Push jobject handle
1178
1179 // Fill out JavaCallArguments object
1180 args->iterate( Fingerprinter(method).fingerprint() );
1181 // Initialize result type
1182 result->set_type(args->get_ret_type());
1183
1184 // Invoke the method. Result is returned as oop.
1185 JavaCalls::call(result, method, &java_args, CHECK);
1186
1187 // Convert result
1188 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
1189 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
1190 }
1191 }
1192
1193
1194 static instanceOop alloc_object(jclass clazz, TRAPS) {
1195 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1196 if (k == NULL) {
1197 ResourceMark rm(THREAD);
1198 THROW_(vmSymbols::java_lang_InstantiationException(), NULL);
1199 }
1200 k()->check_valid_for_instantiation(false, CHECK_NULL);
1201 InstanceKlass::cast(k())->initialize(CHECK_NULL);
1202 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD);
1203 return ih;
1204 }
1205
1206 DT_RETURN_MARK_DECL(AllocObject, jobject
1207 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1208
1209 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1210 JNIWrapper("AllocObject");
1211
1212 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
1213
1214 jobject ret = NULL;
1215 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1216
1217 instanceOop i = alloc_object(clazz, CHECK_NULL);
1218 ret = JNIHandles::make_local(env, i);
1219 return ret;
1220 JNI_END
1221
1222 DT_RETURN_MARK_DECL(NewObjectA, jobject
1321 //
1322 // The class should have been loaded (we have an instance of the class
1323 // passed in) so the method and signature should already be in the symbol
1324 // table. If they're not there, the method doesn't exist.
1325 const char *name_to_probe = (name_str == NULL)
1326 ? vmSymbols::object_initializer_name()->as_C_string()
1327 : name_str;
1328 TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
1329 TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
1330
1331 if (name == NULL || signature == NULL) {
1332 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1333 }
1334
1335 // Throw a NoSuchMethodError exception if we have an instance of a
1336 // primitive java.lang.Class
1337 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) {
1338 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1339 }
1340
1341 KlassHandle klass(THREAD,
1342 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1343
1344 // Make sure class is linked and initialized before handing id's out to
1345 // Method*s.
1346 klass()->initialize(CHECK_NULL);
1347
1348 Method* m;
1349 if (name == vmSymbols::object_initializer_name() ||
1350 name == vmSymbols::class_initializer_name()) {
1351 // Never search superclasses for constructors
1352 if (klass->is_instance_klass()) {
1353 m = InstanceKlass::cast(klass())->find_method(name, signature);
1354 } else {
1355 m = NULL;
1356 }
1357 } else {
1358 m = klass->lookup_method(name, signature);
1359 if (m == NULL && klass->is_instance_klass()) {
1360 m = InstanceKlass::cast(klass())->lookup_method_in_ordered_interfaces(name, signature);
1361 }
1362 }
1363 if (m == NULL || (m->is_static() != is_static)) {
1364 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1365 }
1366 return m->jmethod_id();
1367 }
1368
1369
1370 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
1371 const char *name, const char *sig))
1372 JNIWrapper("GetMethodID");
1373 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1374 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1375 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1376 return ret;
1377 JNI_END
1378
1379
1380 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
1862 HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN());
1863
1864 #define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \
1865 , EntryProbe, ResultProbe) \
1866 \
1867 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \
1868 , ResultProbe); \
1869 \
1870 JNI_ENTRY(ResultType, \
1871 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
1872 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
1873 \
1874 EntryProbe; \
1875 ResultType ret = 0;\
1876 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
1877 (const ResultType&)ret);\
1878 \
1879 JavaValue jvalue(Tag); \
1880 JNI_ArgumentPusherVaArg ap(methodID, args); \
1881 /* Make sure class is initialized before trying to invoke its method */ \
1882 KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls))); \
1883 k()->initialize(CHECK_0); \
1884 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
1885 va_end(args); \
1886 ret = jvalue.get_##ResultType(); \
1887 return ret;\
1888 JNI_END
1889
1890 // the runtime type of subword integral basic types is integer
1891 DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN
1892 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1893 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref));
1894 DEFINE_CALLSTATICMETHODV(jbyte, Byte, T_BYTE
1895 , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1896 HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref));
1897 DEFINE_CALLSTATICMETHODV(jchar, Char, T_CHAR
1898 , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1899 HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref));
1900 DEFINE_CALLSTATICMETHODV(jshort, Short, T_SHORT
1901 , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1902 HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref));
1903
2020
2021
2022 DT_RETURN_MARK_DECL(GetFieldID, jfieldID
2023 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
2024
2025 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
2026 const char *name, const char *sig))
2027 JNIWrapper("GetFieldID");
2028 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2029 jfieldID ret = 0;
2030 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
2031
2032 // The class should have been loaded (we have an instance of the class
2033 // passed in) so the field and signature should already be in the symbol
2034 // table. If they're not there, the field doesn't exist.
2035 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
2036 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
2037 if (fieldname == NULL || signame == NULL) {
2038 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2039 }
2040 KlassHandle k(THREAD,
2041 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
2042 // Make sure class is initialized before handing id's out to fields
2043 k()->initialize(CHECK_NULL);
2044
2045 fieldDescriptor fd;
2046 if (!k()->is_instance_klass() ||
2047 !InstanceKlass::cast(k())->find_field(fieldname, signame, false, &fd)) {
2048 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2049 }
2050
2051 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
2052 // It may also have hash bits for k, if VerifyJNIFields is turned on.
2053 ret = jfieldIDWorkaround::to_instance_jfieldID(k(), fd.offset());
2054 return ret;
2055 JNI_END
2056
2057
2058 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
2059 JNIWrapper("GetObjectField");
2060 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
2061 oop o = JNIHandles::resolve_non_null(obj);
2062 Klass* k = o->klass();
2063 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2064 // Keep JVMTI addition small and only check enabled flag here.
2065 // jni_GetField_probe() assumes that is okay to create handles.
2066 if (JvmtiExport::should_post_field_access()) {
2067 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
2068 }
2069 jobject ret = JNIHandles::make_local(env, o->obj_field(offset));
2070 #if INCLUDE_ALL_GCS
2071 // If G1 is enabled and we are accessing the value of the referent
2072 // field in a reference object then we need to register a non-null
2073 // referent with the SATB barrier.
2275 // Accessing Static Fields
2276 //
2277 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2278 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2279
2280 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2281 const char *name, const char *sig))
2282 JNIWrapper("GetStaticFieldID");
2283 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2284 jfieldID ret = NULL;
2285 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2286
2287 // The class should have been loaded (we have an instance of the class
2288 // passed in) so the field and signature should already be in the symbol
2289 // table. If they're not there, the field doesn't exist.
2290 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
2291 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
2292 if (fieldname == NULL || signame == NULL) {
2293 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2294 }
2295 KlassHandle k(THREAD,
2296 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
2297 // Make sure class is initialized before handing id's out to static fields
2298 k()->initialize(CHECK_NULL);
2299
2300 fieldDescriptor fd;
2301 if (!k()->is_instance_klass() ||
2302 !InstanceKlass::cast(k())->find_field(fieldname, signame, true, &fd)) {
2303 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2304 }
2305
2306 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
2307 JNIid* id = fd.field_holder()->jni_id_for(fd.offset());
2308 debug_only(id->set_is_static_field_id();)
2309
2310 debug_only(id->verify(fd.field_holder()));
2311
2312 ret = jfieldIDWorkaround::to_static_jfieldID(id);
2313 return ret;
2314 JNI_END
2315
2316
2317 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2318 JNIWrapper("GetStaticObjectField");
2319 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
2320 #if INCLUDE_JNI_CHECK
2321 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2322 #endif // INCLUDE_JNI_CHECK
2586 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
2587 assert(a->is_array(), "must be array");
2588 jsize ret = a->length();
2589 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
2590 return ret;
2591 JNI_END
2592
2593
2594 //
2595 // Object Array Operations
2596 //
2597
2598 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
2599 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
2600
2601 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
2602 JNIWrapper("NewObjectArray");
2603 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
2604 jobjectArray ret = NULL;
2605 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
2606 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
2607 Klass* ako = ek()->array_klass(CHECK_NULL);
2608 KlassHandle ak = KlassHandle(THREAD, ako);
2609 ObjArrayKlass::cast(ak())->initialize(CHECK_NULL);
2610 objArrayOop result = ObjArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
2611 oop initial_value = JNIHandles::resolve(initialElement);
2612 if (initial_value != NULL) { // array already initialized with NULL
2613 for (int index = 0; index < length; index++) {
2614 result->obj_at_put(index, initial_value);
2615 }
2616 }
2617 ret = (jobjectArray) JNIHandles::make_local(env, result);
2618 return ret;
2619 JNI_END
2620
2621 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
2622 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
2623
2624 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
2625 JNIWrapper("GetObjectArrayElement");
2626 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
2627 jobject ret = NULL;
2628 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
2629 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2630 if (a->is_within_bounds(index)) {
2919 HOTSPOT_JNI_SETINTARRAYREGION_RETURN())
2920 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long
2921 , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
2922 HOTSPOT_JNI_SETLONGARRAYREGION_RETURN())
2923 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float
2924 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
2925 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
2926 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
2927 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
2928 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
2929
2930
2931 //
2932 // Interception of natives
2933 //
2934
2935 // The RegisterNatives call being attempted tried to register with a method that
2936 // is not native. Ask JVM TI what prefixes have been specified. Then check
2937 // to see if the native method is now wrapped with the prefixes. See the
2938 // SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
2939 static Method* find_prefixed_native(KlassHandle k,
2940 Symbol* name, Symbol* signature, TRAPS) {
2941 #if INCLUDE_JVMTI
2942 ResourceMark rm(THREAD);
2943 Method* method;
2944 int name_len = name->utf8_length();
2945 char* name_str = name->as_utf8();
2946 int prefix_count;
2947 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
2948 for (int i = 0; i < prefix_count; i++) {
2949 char* prefix = prefixes[i];
2950 int prefix_len = (int)strlen(prefix);
2951
2952 // try adding this prefix to the method name and see if it matches another method name
2953 int trial_len = name_len + prefix_len;
2954 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
2955 strcpy(trial_name_str, prefix);
2956 strcat(trial_name_str, name_str);
2957 TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
2958 if (trial_name == NULL) {
2959 continue; // no such symbol, so this prefix wasn't used, try the next prefix
2960 }
2961 method = k()->lookup_method(trial_name, signature);
2962 if (method == NULL) {
2963 continue; // signature doesn't match, try the next prefix
2964 }
2965 if (method->is_native()) {
2966 method->set_is_prefixed_native();
2967 return method; // wahoo, we found a prefixed version of the method, return it
2968 }
2969 // found as non-native, so prefix is good, add it, probably just need more prefixes
2970 name_len = trial_len;
2971 name_str = trial_name_str;
2972 }
2973 #endif // INCLUDE_JVMTI
2974 return NULL; // not found
2975 }
2976
2977 static bool register_native(KlassHandle k, Symbol* name, Symbol* signature, address entry, TRAPS) {
2978 Method* method = k()->lookup_method(name, signature);
2979 if (method == NULL) {
2980 ResourceMark rm;
2981 stringStream st;
2982 st.print("Method %s name or signature does not match",
2983 Method::name_and_sig_as_C_string(k(), name, signature));
2984 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
2985 }
2986 if (!method->is_native()) {
2987 // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
2988 method = find_prefixed_native(k, name, signature, THREAD);
2989 if (method == NULL) {
2990 ResourceMark rm;
2991 stringStream st;
2992 st.print("Method %s is not declared as native",
2993 Method::name_and_sig_as_C_string(k(), name, signature));
2994 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
2995 }
2996 }
2997
2998 if (entry != NULL) {
2999 method->set_native_function(entry,
3000 Method::native_bind_event_is_interesting);
3001 } else {
3002 method->clear_native_function();
3003 }
3004 if (PrintJNIResolving) {
3005 ResourceMark rm(THREAD);
3006 tty->print_cr("[Registering JNI native method %s.%s]",
3007 method->method_holder()->external_name(),
3008 method->name()->as_C_string());
3009 }
3010 return true;
3011 }
3012
3013 DT_RETURN_MARK_DECL(RegisterNatives, jint
3014 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
3015
3016 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
3017 const JNINativeMethod *methods,
3018 jint nMethods))
3019 JNIWrapper("RegisterNatives");
3020 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
3021 jint ret = 0;
3022 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
3023
3024 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
3025
3026 for (int index = 0; index < nMethods; index++) {
3027 const char* meth_name = methods[index].name;
3028 const char* meth_sig = methods[index].signature;
3029 int meth_name_len = (int)strlen(meth_name);
3030
3031 // The class should have been loaded (we have an instance of the class
3032 // passed in) so the method and signature should already be in the symbol
3033 // table. If they're not there, the method doesn't exist.
3034 TempNewSymbol name = SymbolTable::probe(meth_name, meth_name_len);
3035 TempNewSymbol signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
3036
3037 if (name == NULL || signature == NULL) {
3038 ResourceMark rm;
3039 stringStream st;
3040 st.print("Method %s.%s%s not found", h_k()->external_name(), meth_name, meth_sig);
3041 // Must return negative value on failure
3042 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
3043 }
3044
3045 bool res = register_native(h_k, name, signature,
3046 (address) methods[index].fnPtr, THREAD);
3047 if (!res) {
3048 ret = -1;
3049 break;
3050 }
3051 }
3052 return ret;
3053 JNI_END
3054
3055
3056 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
3057 JNIWrapper("UnregisterNatives");
3058 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
3059 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
3060 //%note jni_2
3061 if (k->is_instance_klass()) {
3062 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
3063 Method* m = InstanceKlass::cast(k)->methods()->at(index);
3064 if (m->is_native()) {
3065 m->clear_native_function();
|
369
370 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
371
372 jclass result = NULL;
373 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
374
375 // Remember if we are the first invocation of jni_FindClass
376 bool first_time = first_time_FindClass;
377 first_time_FindClass = false;
378
379 // Sanity check the name: it cannot be null or larger than the maximum size
380 // name we can fit in the constant pool.
381 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
382 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
383 }
384
385 //%note jni_3
386 Handle loader;
387 Handle protection_domain;
388 // Find calling class
389 Klass* k = thread->security_get_caller_class(0);
390 if (k != NULL) {
391 loader = Handle(THREAD, k->class_loader());
392 // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
393 // in the correct class context.
394 if (loader.is_null() &&
395 k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
396 JavaValue result(T_OBJECT);
397 JavaCalls::call_static(&result, k,
398 vmSymbols::getFromClass_name(),
399 vmSymbols::void_class_signature(),
400 thread);
401 if (HAS_PENDING_EXCEPTION) {
402 Handle ex(thread, thread->pending_exception());
403 CLEAR_PENDING_EXCEPTION;
404 THROW_HANDLE_0(ex);
405 }
406 oop mirror = (oop) result.get_jobject();
407 loader = Handle(THREAD,
408 InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->class_loader());
409 protection_domain = Handle(THREAD,
410 InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->protection_domain());
438 JNIWrapper("FromReflectedMethod");
439
440 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
441
442 jmethodID ret = NULL;
443 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
444
445 // method is a handle to a java.lang.reflect.Method object
446 oop reflected = JNIHandles::resolve_non_null(method);
447 oop mirror = NULL;
448 int slot = 0;
449
450 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
451 mirror = java_lang_reflect_Constructor::clazz(reflected);
452 slot = java_lang_reflect_Constructor::slot(reflected);
453 } else {
454 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
455 mirror = java_lang_reflect_Method::clazz(reflected);
456 slot = java_lang_reflect_Method::slot(reflected);
457 }
458 Klass* k1 = java_lang_Class::as_Klass(mirror);
459
460 // Make sure class is initialized before handing id's out to methods
461 k1->initialize(CHECK_NULL);
462 Method* m = InstanceKlass::cast(k1)->method_with_idnum(slot);
463 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
464 return ret;
465 JNI_END
466
467 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
468 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
469
470 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
471 JNIWrapper("FromReflectedField");
472
473 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
474
475 jfieldID ret = NULL;
476 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
477
478 // field is a handle to a java.lang.reflect.Field object
479 oop reflected = JNIHandles::resolve_non_null(field);
480 oop mirror = java_lang_reflect_Field::clazz(reflected);
481 Klass* k1 = java_lang_Class::as_Klass(mirror);
482 int slot = java_lang_reflect_Field::slot(reflected);
483 int modifiers = java_lang_reflect_Field::modifiers(reflected);
484
485 // Make sure class is initialized before handing id's out to fields
486 k1->initialize(CHECK_NULL);
487
488 // First check if this is a static field
489 if (modifiers & JVM_ACC_STATIC) {
490 intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
491 JNIid* id = InstanceKlass::cast(k1)->jni_id_for(offset);
492 assert(id != NULL, "corrupt Field object");
493 debug_only(id->set_is_static_field_id();)
494 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
495 ret = jfieldIDWorkaround::to_static_jfieldID(id);
496 return ret;
497 }
498
499 // The slot is the index of the field description in the field-array
500 // The jfieldID is the offset of the field within the object
501 // It may also have hash bits for k, if VerifyJNIFields is turned on.
502 intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
503 assert(InstanceKlass::cast(k1)->contains_field_offset(offset), "stay within object");
504 ret = jfieldIDWorkaround::to_instance_jfieldID(k1, offset);
505 return ret;
506 JNI_END
507
508
509 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
510 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
511
512 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
513 JNIWrapper("ToReflectedMethod");
514
515 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
516
517 jobject ret = NULL;
518 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
519
520 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
521 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
522 oop reflection_method;
523 if (m->is_initializer()) {
524 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
658 JNIWrapper("ExceptionDescribe");
659
660 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
661
662 if (thread->has_pending_exception()) {
663 Handle ex(thread, thread->pending_exception());
664 thread->clear_pending_exception();
665 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
666 // Don't print anything if we are being killed.
667 } else {
668 jio_fprintf(defaultStream::error_stream(), "Exception ");
669 if (thread != NULL && thread->threadObj() != NULL) {
670 ResourceMark rm(THREAD);
671 jio_fprintf(defaultStream::error_stream(),
672 "in thread \"%s\" ", thread->get_thread_name());
673 }
674 if (ex->is_a(SystemDictionary::Throwable_klass())) {
675 JavaValue result(T_VOID);
676 JavaCalls::call_virtual(&result,
677 ex,
678 SystemDictionary::Throwable_klass(),
679 vmSymbols::printStackTrace_name(),
680 vmSymbols::void_method_signature(),
681 THREAD);
682 // If an exception is thrown in the call it gets thrown away. Not much
683 // we can do with it. The native code that calls this, does not check
684 // for the exception - hence, it might still be in the thread when DestroyVM gets
685 // called, potentially causing a few asserts to trigger - since no pending exception
686 // is expected.
687 CLEAR_PENDING_EXCEPTION;
688 } else {
689 ResourceMark rm(THREAD);
690 jio_fprintf(defaultStream::error_stream(),
691 ". Uncaught exception of type %s.",
692 ex->klass()->external_name());
693 }
694 }
695 }
696
697 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
698 JNI_END
1136 Method* m = Method::resolve_jmethod_id(method_id);
1137 number_of_parameters = m->size_of_parameters();
1138 Klass* holder = m->method_holder();
1139 if (call_type != JNI_VIRTUAL) {
1140 selected_method = m;
1141 } else if (!m->has_itable_index()) {
1142 // non-interface call -- for that little speed boost, don't handlize
1143 debug_only(NoSafepointVerifier nosafepoint;)
1144 // jni_GetMethodID makes sure class is linked and initialized
1145 // so m should have a valid vtable index.
1146 assert(m->valid_vtable_index(), "no valid vtable index");
1147 int vtbl_index = m->vtable_index();
1148 if (vtbl_index != Method::nonvirtual_vtable_index) {
1149 selected_method = h_recv->klass()->method_at_vtable(vtbl_index);
1150 } else {
1151 // final method
1152 selected_method = m;
1153 }
1154 } else {
1155 // interface call
1156 int itbl_index = m->itable_index();
1157 Klass* k = h_recv->klass();
1158 selected_method = InstanceKlass::cast(k)->method_at_itable(holder, itbl_index, CHECK);
1159 }
1160 }
1161
1162 methodHandle method(THREAD, selected_method);
1163
1164 // Create object to hold arguments for the JavaCall, and associate it with
1165 // the jni parser
1166 ResourceMark rm(THREAD);
1167 JavaCallArguments java_args(number_of_parameters);
1168 args->set_java_argument_object(&java_args);
1169
1170 // handle arguments
1171 assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
1172 args->push_receiver(h_recv); // Push jobject handle
1173
1174 // Fill out JavaCallArguments object
1175 args->iterate( Fingerprinter(method).fingerprint() );
1176 // Initialize result type
1177 result->set_type(args->get_ret_type());
1178
1179 // Invoke the method. Result is returned as oop.
1180 JavaCalls::call(result, method, &java_args, CHECK);
1181
1182 // Convert result
1183 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
1184 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
1185 }
1186 }
1187
1188
1189 static instanceOop alloc_object(jclass clazz, TRAPS) {
1190 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1191 if (k == NULL) {
1192 ResourceMark rm(THREAD);
1193 THROW_(vmSymbols::java_lang_InstantiationException(), NULL);
1194 }
1195 k->check_valid_for_instantiation(false, CHECK_NULL);
1196 k->initialize(CHECK_NULL);
1197 instanceOop ih = InstanceKlass::cast(k)->allocate_instance(THREAD);
1198 return ih;
1199 }
1200
1201 DT_RETURN_MARK_DECL(AllocObject, jobject
1202 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1203
1204 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
1205 JNIWrapper("AllocObject");
1206
1207 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
1208
1209 jobject ret = NULL;
1210 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1211
1212 instanceOop i = alloc_object(clazz, CHECK_NULL);
1213 ret = JNIHandles::make_local(env, i);
1214 return ret;
1215 JNI_END
1216
1217 DT_RETURN_MARK_DECL(NewObjectA, jobject
1316 //
1317 // The class should have been loaded (we have an instance of the class
1318 // passed in) so the method and signature should already be in the symbol
1319 // table. If they're not there, the method doesn't exist.
1320 const char *name_to_probe = (name_str == NULL)
1321 ? vmSymbols::object_initializer_name()->as_C_string()
1322 : name_str;
1323 TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
1324 TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
1325
1326 if (name == NULL || signature == NULL) {
1327 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1328 }
1329
1330 // Throw a NoSuchMethodError exception if we have an instance of a
1331 // primitive java.lang.Class
1332 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) {
1333 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1334 }
1335
1336 Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1337
1338 // Make sure class is linked and initialized before handing id's out to
1339 // Method*s.
1340 klass->initialize(CHECK_NULL);
1341
1342 Method* m;
1343 if (name == vmSymbols::object_initializer_name() ||
1344 name == vmSymbols::class_initializer_name()) {
1345 // Never search superclasses for constructors
1346 if (klass->is_instance_klass()) {
1347 m = InstanceKlass::cast(klass)->find_method(name, signature);
1348 } else {
1349 m = NULL;
1350 }
1351 } else {
1352 m = klass->lookup_method(name, signature);
1353 if (m == NULL && klass->is_instance_klass()) {
1354 m = InstanceKlass::cast(klass)->lookup_method_in_ordered_interfaces(name, signature);
1355 }
1356 }
1357 if (m == NULL || (m->is_static() != is_static)) {
1358 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
1359 }
1360 return m->jmethod_id();
1361 }
1362
1363
1364 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
1365 const char *name, const char *sig))
1366 JNIWrapper("GetMethodID");
1367 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1368 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1369 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1370 return ret;
1371 JNI_END
1372
1373
1374 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
1856 HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN());
1857
1858 #define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \
1859 , EntryProbe, ResultProbe) \
1860 \
1861 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \
1862 , ResultProbe); \
1863 \
1864 JNI_ENTRY(ResultType, \
1865 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
1866 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
1867 \
1868 EntryProbe; \
1869 ResultType ret = 0;\
1870 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
1871 (const ResultType&)ret);\
1872 \
1873 JavaValue jvalue(Tag); \
1874 JNI_ArgumentPusherVaArg ap(methodID, args); \
1875 /* Make sure class is initialized before trying to invoke its method */ \
1876 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); \
1877 k->initialize(CHECK_0); \
1878 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
1879 va_end(args); \
1880 ret = jvalue.get_##ResultType(); \
1881 return ret;\
1882 JNI_END
1883
1884 // the runtime type of subword integral basic types is integer
1885 DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN
1886 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1887 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref));
1888 DEFINE_CALLSTATICMETHODV(jbyte, Byte, T_BYTE
1889 , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1890 HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref));
1891 DEFINE_CALLSTATICMETHODV(jchar, Char, T_CHAR
1892 , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1893 HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref));
1894 DEFINE_CALLSTATICMETHODV(jshort, Short, T_SHORT
1895 , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
1896 HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref));
1897
2014
2015
2016 DT_RETURN_MARK_DECL(GetFieldID, jfieldID
2017 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
2018
2019 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
2020 const char *name, const char *sig))
2021 JNIWrapper("GetFieldID");
2022 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2023 jfieldID ret = 0;
2024 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
2025
2026 // The class should have been loaded (we have an instance of the class
2027 // passed in) so the field and signature should already be in the symbol
2028 // table. If they're not there, the field doesn't exist.
2029 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
2030 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
2031 if (fieldname == NULL || signame == NULL) {
2032 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2033 }
2034 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
2035 // Make sure class is initialized before handing id's out to fields
2036 k->initialize(CHECK_NULL);
2037
2038 fieldDescriptor fd;
2039 if (!k->is_instance_klass() ||
2040 !InstanceKlass::cast(k)->find_field(fieldname, signame, false, &fd)) {
2041 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2042 }
2043
2044 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
2045 // It may also have hash bits for k, if VerifyJNIFields is turned on.
2046 ret = jfieldIDWorkaround::to_instance_jfieldID(k, fd.offset());
2047 return ret;
2048 JNI_END
2049
2050
2051 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
2052 JNIWrapper("GetObjectField");
2053 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
2054 oop o = JNIHandles::resolve_non_null(obj);
2055 Klass* k = o->klass();
2056 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2057 // Keep JVMTI addition small and only check enabled flag here.
2058 // jni_GetField_probe() assumes that is okay to create handles.
2059 if (JvmtiExport::should_post_field_access()) {
2060 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
2061 }
2062 jobject ret = JNIHandles::make_local(env, o->obj_field(offset));
2063 #if INCLUDE_ALL_GCS
2064 // If G1 is enabled and we are accessing the value of the referent
2065 // field in a reference object then we need to register a non-null
2066 // referent with the SATB barrier.
2268 // Accessing Static Fields
2269 //
2270 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
2271 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
2272
2273 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
2274 const char *name, const char *sig))
2275 JNIWrapper("GetStaticFieldID");
2276 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2277 jfieldID ret = NULL;
2278 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2279
2280 // The class should have been loaded (we have an instance of the class
2281 // passed in) so the field and signature should already be in the symbol
2282 // table. If they're not there, the field doesn't exist.
2283 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
2284 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
2285 if (fieldname == NULL || signame == NULL) {
2286 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2287 }
2288 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
2289 // Make sure class is initialized before handing id's out to static fields
2290 k->initialize(CHECK_NULL);
2291
2292 fieldDescriptor fd;
2293 if (!k->is_instance_klass() ||
2294 !InstanceKlass::cast(k)->find_field(fieldname, signame, true, &fd)) {
2295 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
2296 }
2297
2298 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
2299 JNIid* id = fd.field_holder()->jni_id_for(fd.offset());
2300 debug_only(id->set_is_static_field_id();)
2301
2302 debug_only(id->verify(fd.field_holder()));
2303
2304 ret = jfieldIDWorkaround::to_static_jfieldID(id);
2305 return ret;
2306 JNI_END
2307
2308
2309 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2310 JNIWrapper("GetStaticObjectField");
2311 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
2312 #if INCLUDE_JNI_CHECK
2313 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2314 #endif // INCLUDE_JNI_CHECK
2578 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
2579 assert(a->is_array(), "must be array");
2580 jsize ret = a->length();
2581 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
2582 return ret;
2583 JNI_END
2584
2585
2586 //
2587 // Object Array Operations
2588 //
2589
2590 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
2591 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
2592
2593 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
2594 JNIWrapper("NewObjectArray");
2595 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
2596 jobjectArray ret = NULL;
2597 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
2598 Klass* ek = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass));
2599 Klass* ak = ek->array_klass(CHECK_NULL);
2600 ObjArrayKlass::cast(ak)->initialize(CHECK_NULL);
2601 objArrayOop result = ObjArrayKlass::cast(ak)->allocate(length, CHECK_NULL);
2602 oop initial_value = JNIHandles::resolve(initialElement);
2603 if (initial_value != NULL) { // array already initialized with NULL
2604 for (int index = 0; index < length; index++) {
2605 result->obj_at_put(index, initial_value);
2606 }
2607 }
2608 ret = (jobjectArray) JNIHandles::make_local(env, result);
2609 return ret;
2610 JNI_END
2611
2612 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
2613 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
2614
2615 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
2616 JNIWrapper("GetObjectArrayElement");
2617 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
2618 jobject ret = NULL;
2619 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
2620 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
2621 if (a->is_within_bounds(index)) {
2910 HOTSPOT_JNI_SETINTARRAYREGION_RETURN())
2911 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long
2912 , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
2913 HOTSPOT_JNI_SETLONGARRAYREGION_RETURN())
2914 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float
2915 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
2916 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
2917 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
2918 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
2919 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
2920
2921
2922 //
2923 // Interception of natives
2924 //
2925
2926 // The RegisterNatives call being attempted tried to register with a method that
2927 // is not native. Ask JVM TI what prefixes have been specified. Then check
2928 // to see if the native method is now wrapped with the prefixes. See the
2929 // SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
2930 static Method* find_prefixed_native(Klass* k, Symbol* name, Symbol* signature, TRAPS) {
2931 #if INCLUDE_JVMTI
2932 ResourceMark rm(THREAD);
2933 Method* method;
2934 int name_len = name->utf8_length();
2935 char* name_str = name->as_utf8();
2936 int prefix_count;
2937 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
2938 for (int i = 0; i < prefix_count; i++) {
2939 char* prefix = prefixes[i];
2940 int prefix_len = (int)strlen(prefix);
2941
2942 // try adding this prefix to the method name and see if it matches another method name
2943 int trial_len = name_len + prefix_len;
2944 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
2945 strcpy(trial_name_str, prefix);
2946 strcat(trial_name_str, name_str);
2947 TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
2948 if (trial_name == NULL) {
2949 continue; // no such symbol, so this prefix wasn't used, try the next prefix
2950 }
2951 method = k->lookup_method(trial_name, signature);
2952 if (method == NULL) {
2953 continue; // signature doesn't match, try the next prefix
2954 }
2955 if (method->is_native()) {
2956 method->set_is_prefixed_native();
2957 return method; // wahoo, we found a prefixed version of the method, return it
2958 }
2959 // found as non-native, so prefix is good, add it, probably just need more prefixes
2960 name_len = trial_len;
2961 name_str = trial_name_str;
2962 }
2963 #endif // INCLUDE_JVMTI
2964 return NULL; // not found
2965 }
2966
2967 static bool register_native(Klass* k, Symbol* name, Symbol* signature, address entry, TRAPS) {
2968 Method* method = k->lookup_method(name, signature);
2969 if (method == NULL) {
2970 ResourceMark rm;
2971 stringStream st;
2972 st.print("Method %s name or signature does not match",
2973 Method::name_and_sig_as_C_string(k, name, signature));
2974 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
2975 }
2976 if (!method->is_native()) {
2977 // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
2978 method = find_prefixed_native(k, name, signature, THREAD);
2979 if (method == NULL) {
2980 ResourceMark rm;
2981 stringStream st;
2982 st.print("Method %s is not declared as native",
2983 Method::name_and_sig_as_C_string(k, name, signature));
2984 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
2985 }
2986 }
2987
2988 if (entry != NULL) {
2989 method->set_native_function(entry,
2990 Method::native_bind_event_is_interesting);
2991 } else {
2992 method->clear_native_function();
2993 }
2994 if (PrintJNIResolving) {
2995 ResourceMark rm(THREAD);
2996 tty->print_cr("[Registering JNI native method %s.%s]",
2997 method->method_holder()->external_name(),
2998 method->name()->as_C_string());
2999 }
3000 return true;
3001 }
3002
3003 DT_RETURN_MARK_DECL(RegisterNatives, jint
3004 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
3005
3006 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
3007 const JNINativeMethod *methods,
3008 jint nMethods))
3009 JNIWrapper("RegisterNatives");
3010 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
3011 jint ret = 0;
3012 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
3013
3014 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
3015
3016 for (int index = 0; index < nMethods; index++) {
3017 const char* meth_name = methods[index].name;
3018 const char* meth_sig = methods[index].signature;
3019 int meth_name_len = (int)strlen(meth_name);
3020
3021 // The class should have been loaded (we have an instance of the class
3022 // passed in) so the method and signature should already be in the symbol
3023 // table. If they're not there, the method doesn't exist.
3024 TempNewSymbol name = SymbolTable::probe(meth_name, meth_name_len);
3025 TempNewSymbol signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
3026
3027 if (name == NULL || signature == NULL) {
3028 ResourceMark rm;
3029 stringStream st;
3030 st.print("Method %s.%s%s not found", k->external_name(), meth_name, meth_sig);
3031 // Must return negative value on failure
3032 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
3033 }
3034
3035 bool res = register_native(k, name, signature,
3036 (address) methods[index].fnPtr, THREAD);
3037 if (!res) {
3038 ret = -1;
3039 break;
3040 }
3041 }
3042 return ret;
3043 JNI_END
3044
3045
3046 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
3047 JNIWrapper("UnregisterNatives");
3048 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
3049 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
3050 //%note jni_2
3051 if (k->is_instance_klass()) {
3052 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
3053 Method* m = InstanceKlass::cast(k)->methods()->at(index);
3054 if (m->is_native()) {
3055 m->clear_native_function();
|