< prev index next >

src/share/vm/prims/jni.cpp

Print this page




 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();


< prev index next >