1 /* 2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/classLoader.hpp" 27 #include "classfile/javaClasses.hpp" 28 #include "classfile/symbolTable.hpp" 29 #include "classfile/systemDictionary.hpp" 30 #include "classfile/vmSymbols.hpp" 31 #include "interpreter/linkResolver.hpp" 32 #ifndef SERIALGC 33 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp" 34 #endif // SERIALGC 35 #include "memory/allocation.inline.hpp" 36 #include "memory/gcLocker.inline.hpp" 37 #include "memory/oopFactory.hpp" 38 #include "memory/universe.inline.hpp" 39 #include "oops/instanceKlass.hpp" 40 #include "oops/instanceOop.hpp" 41 #include "oops/markOop.hpp" 42 #include "oops/methodOop.hpp" 43 #include "oops/objArrayKlass.hpp" 44 #include "oops/objArrayOop.hpp" 45 #include "oops/oop.inline.hpp" 46 #include "oops/symbol.hpp" 47 #include "oops/typeArrayKlass.hpp" 48 #include "oops/typeArrayOop.hpp" 49 #include "prims/jni.h" 50 #include "prims/jniCheck.hpp" 51 #include "prims/jniFastGetField.hpp" 52 #include "prims/jvm.h" 53 #include "prims/jvm_misc.hpp" 54 #include "prims/jvmtiExport.hpp" 55 #include "prims/jvmtiThreadState.hpp" 56 #include "runtime/compilationPolicy.hpp" 57 #include "runtime/fieldDescriptor.hpp" 58 #include "runtime/fprofiler.hpp" 59 #include "runtime/handles.inline.hpp" 60 #include "runtime/interfaceSupport.hpp" 61 #include "runtime/java.hpp" 62 #include "runtime/javaCalls.hpp" 63 #include "runtime/jfieldIDWorkaround.hpp" 64 #include "runtime/reflection.hpp" 65 #include "runtime/sharedRuntime.hpp" 66 #include "runtime/signature.hpp" 67 #include "runtime/vm_operations.hpp" 68 #include "services/runtimeService.hpp" 69 #include "utilities/defaultStream.hpp" 70 #include "utilities/dtrace.hpp" 71 #include "utilities/events.hpp" 72 #include "utilities/histogram.hpp" 73 #ifdef TARGET_OS_FAMILY_linux 74 # include "os_linux.inline.hpp" 75 # include "thread_linux.inline.hpp" 76 #endif 77 #ifdef TARGET_OS_FAMILY_solaris 78 # include "os_solaris.inline.hpp" 79 # include "thread_solaris.inline.hpp" 80 #endif 81 #ifdef TARGET_OS_FAMILY_windows 82 # include "os_windows.inline.hpp" 83 # include "thread_windows.inline.hpp" 84 #endif 85 #ifdef TARGET_OS_FAMILY_bsd 86 # include "os_bsd.inline.hpp" 87 # include "thread_bsd.inline.hpp" 88 #endif 89 90 static jint CurrentVersion = JNI_VERSION_1_6; 91 92 93 // The DT_RETURN_MARK macros create a scoped object to fire the dtrace 94 // '-return' probe regardless of the return path is taken out of the function. 95 // Methods that have multiple return paths use this to avoid having to 96 // instrument each return path. Methods that use CHECK or THROW must use this 97 // since those macros can cause an immedate uninstrumented return. 98 // 99 // In order to get the return value, a reference to the variable containing 100 // the return value must be passed to the contructor of the object, and 101 // the return value must be set before return (since the mark object has 102 // a reference to it). 103 // 104 // Example: 105 // DT_RETURN_MARK_DECL(SomeFunc, int); 106 // JNI_ENTRY(int, SomeFunc, ...) 107 // int return_value = 0; 108 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value); 109 // foo(CHECK_0) 110 // return_value = 5; 111 // return return_value; 112 // JNI_END 113 #define DT_RETURN_MARK_DECL(name, type) \ 114 HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \ 115 DTRACE_ONLY( \ 116 class DTraceReturnProbeMark_##name { \ 117 public: \ 118 const type& _ret_ref; \ 119 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \ 120 ~DTraceReturnProbeMark_##name() { \ 121 HS_DTRACE_PROBE1(hotspot_jni, name##__return, _ret_ref); \ 122 } \ 123 } \ 124 ) 125 // Void functions are simpler since there's no return value 126 #define DT_VOID_RETURN_MARK_DECL(name) \ 127 HS_DTRACE_PROBE_DECL0(hotspot_jni, name##__return); \ 128 DTRACE_ONLY( \ 129 class DTraceReturnProbeMark_##name { \ 130 public: \ 131 ~DTraceReturnProbeMark_##name() { \ 132 HS_DTRACE_PROBE0(hotspot_jni, name##__return); \ 133 } \ 134 } \ 135 ) 136 137 138 // Place these macros in the function to mark the return. Non-void 139 // functions need the type and address of the return value. 140 #define DT_RETURN_MARK(name, type, ref) \ 141 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) ) 142 #define DT_VOID_RETURN_MARK(name) \ 143 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark ) 144 145 146 // Use these to select distinct code for floating-point vs. non-floating point 147 // situations. Used from within common macros where we need slightly 148 // different behavior for Float/Double 149 #define FP_SELECT_Boolean(intcode, fpcode) intcode 150 #define FP_SELECT_Byte(intcode, fpcode) intcode 151 #define FP_SELECT_Char(intcode, fpcode) intcode 152 #define FP_SELECT_Short(intcode, fpcode) intcode 153 #define FP_SELECT_Object(intcode, fpcode) intcode 154 #define FP_SELECT_Int(intcode, fpcode) intcode 155 #define FP_SELECT_Long(intcode, fpcode) intcode 156 #define FP_SELECT_Float(intcode, fpcode) fpcode 157 #define FP_SELECT_Double(intcode, fpcode) fpcode 158 #define FP_SELECT(TypeName, intcode, fpcode) \ 159 FP_SELECT_##TypeName(intcode, fpcode) 160 161 #define COMMA , 162 163 // Choose DT_RETURN_MARK macros based on the type: float/double -> void 164 // (dtrace doesn't do FP yet) 165 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \ 166 FP_SELECT(TypeName, \ 167 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) ) 168 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ 169 FP_SELECT(TypeName, \ 170 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) 171 172 173 // out-of-line helpers for class jfieldIDWorkaround: 174 175 bool jfieldIDWorkaround::is_valid_jfieldID(klassOop k, jfieldID id) { 176 if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) { 177 uintptr_t as_uint = (uintptr_t) id; 178 intptr_t offset = raw_instance_offset(id); 179 if (is_checked_jfieldID(id)) { 180 if (!klass_hash_ok(k, id)) { 181 return false; 182 } 183 } 184 return instanceKlass::cast(k)->contains_field_offset(offset); 185 } else { 186 JNIid* result = (JNIid*) id; 187 #ifdef ASSERT 188 return result != NULL && result->is_static_field_id(); 189 #else 190 return result != NULL; 191 #endif 192 } 193 } 194 195 196 intptr_t jfieldIDWorkaround::encode_klass_hash(klassOop k, intptr_t offset) { 197 if (offset <= small_offset_mask) { 198 klassOop field_klass = k; 199 klassOop super_klass = Klass::cast(field_klass)->super(); 200 // With compressed oops the most super class with nonstatic fields would 201 // be the owner of fields embedded in the header. 202 while (instanceKlass::cast(super_klass)->has_nonstatic_fields() && 203 instanceKlass::cast(super_klass)->contains_field_offset(offset)) { 204 field_klass = super_klass; // super contains the field also 205 super_klass = Klass::cast(field_klass)->super(); 206 } 207 debug_only(No_Safepoint_Verifier nosafepoint;) 208 uintptr_t klass_hash = field_klass->identity_hash(); 209 return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place; 210 } else { 211 #if 0 212 #ifndef PRODUCT 213 { 214 ResourceMark rm; 215 warning("VerifyJNIFields: long offset %d in %s", offset, Klass::cast(k)->external_name()); 216 } 217 #endif 218 #endif 219 return 0; 220 } 221 } 222 223 bool jfieldIDWorkaround::klass_hash_ok(klassOop k, jfieldID id) { 224 uintptr_t as_uint = (uintptr_t) id; 225 intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask; 226 do { 227 debug_only(No_Safepoint_Verifier nosafepoint;) 228 // Could use a non-blocking query for identity_hash here... 229 if ((k->identity_hash() & klass_mask) == klass_hash) 230 return true; 231 k = Klass::cast(k)->super(); 232 } while (k != NULL); 233 return false; 234 } 235 236 void jfieldIDWorkaround::verify_instance_jfieldID(klassOop k, jfieldID id) { 237 guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" ); 238 uintptr_t as_uint = (uintptr_t) id; 239 intptr_t offset = raw_instance_offset(id); 240 if (VerifyJNIFields) { 241 if (is_checked_jfieldID(id)) { 242 guarantee(klass_hash_ok(k, id), 243 "Bug in native code: jfieldID class must match object"); 244 } else { 245 #if 0 246 #ifndef PRODUCT 247 if (Verbose) { 248 ResourceMark rm; 249 warning("VerifyJNIFields: unverified offset %d for %s", offset, Klass::cast(k)->external_name()); 250 } 251 #endif 252 #endif 253 } 254 } 255 guarantee(instanceKlass::cast(k)->contains_field_offset(offset), 256 "Bug in native code: jfieldID offset must address interior of object"); 257 } 258 259 // Pick a reasonable higher bound for local capacity requested 260 // for EnsureLocalCapacity and PushLocalFrame. We don't want it too 261 // high because a test (or very unusual application) may try to allocate 262 // that many handles and run out of swap space. An implementation is 263 // permitted to allocate more handles than the ensured capacity, so this 264 // value is set high enough to prevent compatibility problems. 265 const int MAX_REASONABLE_LOCAL_CAPACITY = 4*K; 266 267 268 // Wrapper to trace JNI functions 269 270 #ifdef ASSERT 271 Histogram* JNIHistogram; 272 static volatile jint JNIHistogram_lock = 0; 273 274 class JNITraceWrapper : public StackObj { 275 public: 276 JNITraceWrapper(const char* format, ...) { 277 if (TraceJNICalls) { 278 va_list ap; 279 va_start(ap, format); 280 tty->print("JNI "); 281 tty->vprint_cr(format, ap); 282 va_end(ap); 283 } 284 } 285 }; 286 287 class JNIHistogramElement : public HistogramElement { 288 public: 289 JNIHistogramElement(const char* name); 290 }; 291 292 JNIHistogramElement::JNIHistogramElement(const char* elementName) { 293 _name = elementName; 294 uintx count = 0; 295 296 while (Atomic::cmpxchg(1, &JNIHistogram_lock, 0) != 0) { 297 while (OrderAccess::load_acquire(&JNIHistogram_lock) != 0) { 298 count +=1; 299 if ( (WarnOnStalledSpinLock > 0) 300 && (count % WarnOnStalledSpinLock == 0)) { 301 warning("JNIHistogram_lock seems to be stalled"); 302 } 303 } 304 } 305 306 307 if(JNIHistogram == NULL) 308 JNIHistogram = new Histogram("JNI Call Counts",100); 309 310 JNIHistogram->add_element(this); 311 Atomic::dec(&JNIHistogram_lock); 312 } 313 314 #define JNICountWrapper(arg) \ 315 static JNIHistogramElement* e = new JNIHistogramElement(arg); \ 316 /* There is a MT-race condition in VC++. So we need to make sure that that e has been initialized */ \ 317 if (e != NULL) e->increment_count() 318 #define JNIWrapper(arg) JNICountWrapper(arg); JNITraceWrapper(arg) 319 #else 320 #define JNIWrapper(arg) 321 #endif 322 323 324 // Implementation of JNI entries 325 326 DT_RETURN_MARK_DECL(DefineClass, jclass); 327 328 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, 329 const jbyte *buf, jsize bufLen)) 330 JNIWrapper("DefineClass"); 331 332 DTRACE_PROBE5(hotspot_jni, DefineClass__entry, 333 env, name, loaderRef, buf, bufLen); 334 jclass cls = NULL; 335 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); 336 337 // Since exceptions can be thrown, class initialization can take place 338 // if name is NULL no check for class name in .class stream has to be made. 339 if (name != NULL) { 340 const int str_len = (int)strlen(name); 341 if (str_len > Symbol::max_length()) { 342 // It's impossible to create this class; the name cannot fit 343 // into the constant pool. 344 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); 345 } 346 } 347 TempNewSymbol class_name = SymbolTable::new_symbol(name, THREAD); 348 349 ResourceMark rm(THREAD); 350 ClassFileStream st((u1*) buf, bufLen, NULL); 351 Handle class_loader (THREAD, JNIHandles::resolve(loaderRef)); 352 353 if (UsePerfData && !class_loader.is_null()) { 354 // check whether the current caller thread holds the lock or not. 355 // If not, increment the corresponding counter 356 if (ObjectSynchronizer:: 357 query_lock_ownership((JavaThread*)THREAD, class_loader) != 358 ObjectSynchronizer::owner_self) { 359 ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc(); 360 } 361 } 362 klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, 363 Handle(), &st, true, 364 CHECK_NULL); 365 366 if (TraceClassResolution && k != NULL) { 367 trace_class_resolution(k); 368 } 369 370 cls = (jclass)JNIHandles::make_local( 371 env, Klass::cast(k)->java_mirror()); 372 return cls; 373 JNI_END 374 375 376 377 static bool first_time_FindClass = true; 378 379 DT_RETURN_MARK_DECL(FindClass, jclass); 380 381 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name)) 382 JNIWrapper("FindClass"); 383 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name); 384 385 jclass result = NULL; 386 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result); 387 388 // Remember if we are the first invocation of jni_FindClass 389 bool first_time = first_time_FindClass; 390 first_time_FindClass = false; 391 392 // Sanity check the name: it cannot be null or larger than the maximum size 393 // name we can fit in the constant pool. 394 if (name == NULL || (int)strlen(name) > Symbol::max_length()) { 395 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); 396 } 397 398 //%note jni_3 399 Handle loader; 400 Handle protection_domain; 401 // Find calling class 402 instanceKlassHandle k (THREAD, thread->security_get_caller_class(0)); 403 if (k.not_null()) { 404 loader = Handle(THREAD, k->class_loader()); 405 // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed 406 // in the correct class context. 407 if (loader.is_null() && 408 k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) { 409 JavaValue result(T_OBJECT); 410 JavaCalls::call_static(&result, k, 411 vmSymbols::getFromClass_name(), 412 vmSymbols::void_class_signature(), 413 thread); 414 if (HAS_PENDING_EXCEPTION) { 415 Handle ex(thread, thread->pending_exception()); 416 CLEAR_PENDING_EXCEPTION; 417 THROW_HANDLE_0(ex); 418 } 419 oop mirror = (oop) result.get_jobject(); 420 loader = Handle(THREAD, 421 instanceKlass::cast(java_lang_Class::as_klassOop(mirror))->class_loader()); 422 protection_domain = Handle(THREAD, 423 instanceKlass::cast(java_lang_Class::as_klassOop(mirror))->protection_domain()); 424 } 425 } else { 426 // We call ClassLoader.getSystemClassLoader to obtain the system class loader. 427 loader = Handle(THREAD, SystemDictionary::java_system_loader()); 428 } 429 430 TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL); 431 result = find_class_from_class_loader(env, sym, true, loader, 432 protection_domain, true, thread); 433 434 if (TraceClassResolution && result != NULL) { 435 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result))); 436 } 437 438 // If we were the first invocation of jni_FindClass, we enable compilation again 439 // rather than just allowing invocation counter to overflow and decay. 440 // Controlled by flag DelayCompilationDuringStartup. 441 if (first_time && !CompileTheWorld) 442 CompilationPolicy::completed_vm_startup(); 443 444 return result; 445 JNI_END 446 447 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID); 448 449 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method)) 450 JNIWrapper("FromReflectedMethod"); 451 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method); 452 jmethodID ret = NULL; 453 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret); 454 455 // method is a handle to a java.lang.reflect.Method object 456 oop reflected = JNIHandles::resolve_non_null(method); 457 oop mirror = NULL; 458 int slot = 0; 459 460 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) { 461 mirror = java_lang_reflect_Constructor::clazz(reflected); 462 slot = java_lang_reflect_Constructor::slot(reflected); 463 } else { 464 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type"); 465 mirror = java_lang_reflect_Method::clazz(reflected); 466 slot = java_lang_reflect_Method::slot(reflected); 467 } 468 klassOop k = java_lang_Class::as_klassOop(mirror); 469 470 KlassHandle k1(THREAD, k); 471 // Make sure class is initialized before handing id's out to methods 472 Klass::cast(k1())->initialize(CHECK_NULL); 473 methodOop m = instanceKlass::cast(k1())->method_with_idnum(slot); 474 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted 475 return ret; 476 JNI_END 477 478 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID); 479 480 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field)) 481 JNIWrapper("FromReflectedField"); 482 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field); 483 jfieldID ret = NULL; 484 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret); 485 486 // field is a handle to a java.lang.reflect.Field object 487 oop reflected = JNIHandles::resolve_non_null(field); 488 oop mirror = java_lang_reflect_Field::clazz(reflected); 489 klassOop k = java_lang_Class::as_klassOop(mirror); 490 int slot = java_lang_reflect_Field::slot(reflected); 491 int modifiers = java_lang_reflect_Field::modifiers(reflected); 492 493 KlassHandle k1(THREAD, k); 494 // Make sure class is initialized before handing id's out to fields 495 Klass::cast(k1())->initialize(CHECK_NULL); 496 497 // First check if this is a static field 498 if (modifiers & JVM_ACC_STATIC) { 499 intptr_t offset = instanceKlass::cast(k1())->field_offset( slot ); 500 JNIid* id = instanceKlass::cast(k1())->jni_id_for(offset); 501 assert(id != NULL, "corrupt Field object"); 502 debug_only(id->set_is_static_field_id();) 503 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop 504 ret = jfieldIDWorkaround::to_static_jfieldID(id); 505 return ret; 506 } 507 508 // The slot is the index of the field description in the field-array 509 // The jfieldID is the offset of the field within the object 510 // It may also have hash bits for k, if VerifyJNIFields is turned on. 511 intptr_t offset = instanceKlass::cast(k1())->field_offset( slot ); 512 assert(instanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); 513 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); 514 return ret; 515 JNI_END 516 517 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject); 518 519 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) 520 JNIWrapper("ToReflectedMethod"); 521 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic); 522 jobject ret = NULL; 523 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); 524 525 methodHandle m (THREAD, JNIHandles::resolve_jmethod_id(method_id)); 526 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); 527 oop reflection_method; 528 if (m->is_initializer()) { 529 reflection_method = Reflection::new_constructor(m, CHECK_NULL); 530 } else { 531 reflection_method = Reflection::new_method(m, UseNewReflection, false, CHECK_NULL); 532 } 533 ret = JNIHandles::make_local(env, reflection_method); 534 return ret; 535 JNI_END 536 537 DT_RETURN_MARK_DECL(GetSuperclass, jclass); 538 539 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub)) 540 JNIWrapper("GetSuperclass"); 541 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub); 542 jclass obj = NULL; 543 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj); 544 545 oop mirror = JNIHandles::resolve_non_null(sub); 546 // primitive classes return NULL 547 if (java_lang_Class::is_primitive(mirror)) return NULL; 548 549 // Rules of Class.getSuperClass as implemented by KLass::java_super: 550 // arrays return Object 551 // interfaces return NULL 552 // proper classes return Klass::super() 553 klassOop k = java_lang_Class::as_klassOop(mirror); 554 if (Klass::cast(k)->is_interface()) return NULL; 555 556 // return mirror for superclass 557 klassOop super = Klass::cast(k)->java_super(); 558 // super2 is the value computed by the compiler's getSuperClass intrinsic: 559 debug_only(klassOop super2 = ( Klass::cast(k)->oop_is_javaArray() 560 ? SystemDictionary::Object_klass() 561 : Klass::cast(k)->super() ) ); 562 assert(super == super2, 563 "java_super computation depends on interface, array, other super"); 564 obj = (super == NULL) ? NULL : (jclass) JNIHandles::make_local(Klass::cast(super)->java_mirror()); 565 return obj; 566 JNI_END 567 568 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) 569 JNIWrapper("IsSubclassOf"); 570 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); 571 oop sub_mirror = JNIHandles::resolve_non_null(sub); 572 oop super_mirror = JNIHandles::resolve_non_null(super); 573 if (java_lang_Class::is_primitive(sub_mirror) || 574 java_lang_Class::is_primitive(super_mirror)) { 575 jboolean ret = (sub_mirror == super_mirror); 576 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); 577 return ret; 578 } 579 klassOop sub_klass = java_lang_Class::as_klassOop(sub_mirror); 580 klassOop super_klass = java_lang_Class::as_klassOop(super_mirror); 581 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); 582 jboolean ret = Klass::cast(sub_klass)->is_subtype_of(super_klass) ? 583 JNI_TRUE : JNI_FALSE; 584 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); 585 return ret; 586 JNI_END 587 588 DT_RETURN_MARK_DECL(Throw, jint); 589 590 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) 591 JNIWrapper("Throw"); 592 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); 593 jint ret = JNI_OK; 594 DT_RETURN_MARK(Throw, jint, (const jint&)ret); 595 596 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); 597 ShouldNotReachHere(); 598 JNI_END 599 600 DT_RETURN_MARK_DECL(ThrowNew, jint); 601 602 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) 603 JNIWrapper("ThrowNew"); 604 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); 605 jint ret = JNI_OK; 606 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); 607 608 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); 609 Symbol* name = k->name(); 610 Handle class_loader (THREAD, k->class_loader()); 611 Handle protection_domain (THREAD, k->protection_domain()); 612 THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK); 613 ShouldNotReachHere(); 614 JNI_END 615 616 617 // JNI functions only transform a pending async exception to a synchronous 618 // exception in ExceptionOccurred and ExceptionCheck calls, since 619 // delivering an async exception in other places won't change the native 620 // code's control flow and would be harmful when native code further calls 621 // JNI functions with a pending exception. Async exception is also checked 622 // during the call, so ExceptionOccurred/ExceptionCheck won't return 623 // false but deliver the async exception at the very end during 624 // state transition. 625 626 static void jni_check_async_exceptions(JavaThread *thread) { 627 assert(thread == Thread::current(), "must be itself"); 628 thread->check_and_handle_async_exceptions(); 629 } 630 631 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) 632 JNIWrapper("ExceptionOccurred"); 633 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env); 634 jni_check_async_exceptions(thread); 635 oop exception = thread->pending_exception(); 636 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); 637 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret); 638 return ret; 639 JNI_END 640 641 642 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) 643 JNIWrapper("ExceptionDescribe"); 644 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env); 645 if (thread->has_pending_exception()) { 646 Handle ex(thread, thread->pending_exception()); 647 thread->clear_pending_exception(); 648 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { 649 // Don't print anything if we are being killed. 650 } else { 651 jio_fprintf(defaultStream::error_stream(), "Exception "); 652 if (thread != NULL && thread->threadObj() != NULL) { 653 ResourceMark rm(THREAD); 654 jio_fprintf(defaultStream::error_stream(), 655 "in thread \"%s\" ", thread->get_thread_name()); 656 } 657 if (ex->is_a(SystemDictionary::Throwable_klass())) { 658 JavaValue result(T_VOID); 659 JavaCalls::call_virtual(&result, 660 ex, 661 KlassHandle(THREAD, 662 SystemDictionary::Throwable_klass()), 663 vmSymbols::printStackTrace_name(), 664 vmSymbols::void_method_signature(), 665 THREAD); 666 // If an exception is thrown in the call it gets thrown away. Not much 667 // we can do with it. The native code that calls this, does not check 668 // for the exception - hence, it might still be in the thread when DestroyVM gets 669 // called, potentially causing a few asserts to trigger - since no pending exception 670 // is expected. 671 CLEAR_PENDING_EXCEPTION; 672 } else { 673 ResourceMark rm(THREAD); 674 jio_fprintf(defaultStream::error_stream(), 675 ". Uncaught exception of type %s.", 676 Klass::cast(ex->klass())->external_name()); 677 } 678 } 679 } 680 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); 681 JNI_END 682 683 684 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) 685 JNIWrapper("ExceptionClear"); 686 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); 687 688 // The jni code might be using this API to clear java thrown exception. 689 // So just mark jvmti thread exception state as exception caught. 690 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); 691 if (state != NULL && state->is_exception_detected()) { 692 state->set_exception_caught(); 693 } 694 thread->clear_pending_exception(); 695 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); 696 JNI_END 697 698 699 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) 700 JNIWrapper("FatalError"); 701 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); 702 tty->print_cr("FATAL ERROR in native method: %s", msg); 703 thread->print_stack(); 704 os::abort(); // Dump core and abort 705 JNI_END 706 707 708 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) 709 JNIWrapper("PushLocalFrame"); 710 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); 711 //%note jni_11 712 if (capacity < 0 && capacity > MAX_REASONABLE_LOCAL_CAPACITY) { 713 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); 714 return JNI_ERR; 715 } 716 JNIHandleBlock* old_handles = thread->active_handles(); 717 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); 718 assert(new_handles != NULL, "should not be NULL"); 719 new_handles->set_pop_frame_link(old_handles); 720 thread->set_active_handles(new_handles); 721 jint ret = JNI_OK; 722 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); 723 return ret; 724 JNI_END 725 726 727 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) 728 JNIWrapper("PopLocalFrame"); 729 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); 730 //%note jni_11 731 Handle result_handle(thread, JNIHandles::resolve(result)); 732 JNIHandleBlock* old_handles = thread->active_handles(); 733 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); 734 if (new_handles != NULL) { 735 // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL. 736 // This way code will still work if PopLocalFrame is called without a corresponding 737 // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise 738 // the release_block call will release the blocks. 739 thread->set_active_handles(new_handles); 740 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below 741 JNIHandleBlock::release_block(old_handles, thread); // may block 742 result = JNIHandles::make_local(thread, result_handle()); 743 } 744 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); 745 return result; 746 JNI_END 747 748 749 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) 750 JNIWrapper("NewGlobalRef"); 751 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); 752 Handle ref_handle(thread, JNIHandles::resolve(ref)); 753 jobject ret = JNIHandles::make_global(ref_handle); 754 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); 755 return ret; 756 JNI_END 757 758 // Must be JNI_ENTRY (with HandleMark) 759 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) 760 JNIWrapper("DeleteGlobalRef"); 761 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); 762 JNIHandles::destroy_global(ref); 763 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); 764 JNI_END 765 766 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) 767 JNIWrapper("DeleteLocalRef"); 768 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); 769 JNIHandles::destroy_local(obj); 770 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); 771 JNI_END 772 773 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) 774 JNIWrapper("IsSameObject"); 775 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); 776 oop a = JNIHandles::resolve(r1); 777 oop b = JNIHandles::resolve(r2); 778 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; 779 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); 780 return ret; 781 JNI_END 782 783 784 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) 785 JNIWrapper("NewLocalRef"); 786 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); 787 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); 788 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); 789 return ret; 790 JNI_END 791 792 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) 793 JNIWrapper("EnsureLocalCapacity"); 794 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); 795 jint ret; 796 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { 797 ret = JNI_OK; 798 } else { 799 ret = JNI_ERR; 800 } 801 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); 802 return ret; 803 JNI_END 804 805 // Return the Handle Type 806 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) 807 JNIWrapper("GetObjectRefType"); 808 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); 809 jobjectRefType ret; 810 if (JNIHandles::is_local_handle(thread, obj) || 811 JNIHandles::is_frame_handle(thread, obj)) 812 ret = JNILocalRefType; 813 else if (JNIHandles::is_global_handle(obj)) 814 ret = JNIGlobalRefType; 815 else if (JNIHandles::is_weak_global_handle(obj)) 816 ret = JNIWeakGlobalRefType; 817 else 818 ret = JNIInvalidRefType; 819 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); 820 return ret; 821 JNI_END 822 823 824 class JNI_ArgumentPusher : public SignatureIterator { 825 protected: 826 JavaCallArguments* _arguments; 827 828 virtual void get_bool () = 0; 829 virtual void get_char () = 0; 830 virtual void get_short () = 0; 831 virtual void get_byte () = 0; 832 virtual void get_int () = 0; 833 virtual void get_long () = 0; 834 virtual void get_float () = 0; 835 virtual void get_double () = 0; 836 virtual void get_object () = 0; 837 838 JNI_ArgumentPusher(Symbol* signature) : SignatureIterator(signature) { 839 this->_return_type = T_ILLEGAL; 840 _arguments = NULL; 841 } 842 843 public: 844 virtual void iterate( uint64_t fingerprint ) = 0; 845 846 void set_java_argument_object(JavaCallArguments *arguments) { _arguments = arguments; } 847 848 inline void do_bool() { if (!is_return_type()) get_bool(); } 849 inline void do_char() { if (!is_return_type()) get_char(); } 850 inline void do_short() { if (!is_return_type()) get_short(); } 851 inline void do_byte() { if (!is_return_type()) get_byte(); } 852 inline void do_int() { if (!is_return_type()) get_int(); } 853 inline void do_long() { if (!is_return_type()) get_long(); } 854 inline void do_float() { if (!is_return_type()) get_float(); } 855 inline void do_double() { if (!is_return_type()) get_double(); } 856 inline void do_object(int begin, int end) { if (!is_return_type()) get_object(); } 857 inline void do_array(int begin, int end) { if (!is_return_type()) get_object(); } // do_array uses get_object -- there is no get_array 858 inline void do_void() { } 859 860 JavaCallArguments* arguments() { return _arguments; } 861 void push_receiver(Handle h) { _arguments->push_oop(h); } 862 }; 863 864 865 class JNI_ArgumentPusherVaArg : public JNI_ArgumentPusher { 866 protected: 867 va_list _ap; 868 869 inline void get_bool() { _arguments->push_int(va_arg(_ap, jint)); } // bool is coerced to int when using va_arg 870 inline void get_char() { _arguments->push_int(va_arg(_ap, jint)); } // char is coerced to int when using va_arg 871 inline void get_short() { _arguments->push_int(va_arg(_ap, jint)); } // short is coerced to int when using va_arg 872 inline void get_byte() { _arguments->push_int(va_arg(_ap, jint)); } // byte is coerced to int when using va_arg 873 inline void get_int() { _arguments->push_int(va_arg(_ap, jint)); } 874 875 // each of these paths is exercized by the various jck Call[Static,Nonvirtual,][Void,Int,..]Method[A,V,] tests 876 877 inline void get_long() { _arguments->push_long(va_arg(_ap, jlong)); } 878 inline void get_float() { _arguments->push_float((jfloat)va_arg(_ap, jdouble)); } // float is coerced to double w/ va_arg 879 inline void get_double() { _arguments->push_double(va_arg(_ap, jdouble)); } 880 inline void get_object() { jobject l = va_arg(_ap, jobject); 881 _arguments->push_oop(Handle((oop *)l, false)); } 882 883 inline void set_ap(va_list rap) { 884 #ifdef va_copy 885 va_copy(_ap, rap); 886 #elif defined (__va_copy) 887 __va_copy(_ap, rap); 888 #else 889 _ap = rap; 890 #endif 891 } 892 893 public: 894 JNI_ArgumentPusherVaArg(Symbol* signature, va_list rap) 895 : JNI_ArgumentPusher(signature) { 896 set_ap(rap); 897 } 898 JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap) 899 : JNI_ArgumentPusher(JNIHandles::resolve_jmethod_id(method_id)->signature()) { 900 set_ap(rap); 901 } 902 903 // Optimized path if we have the bitvector form of signature 904 void iterate( uint64_t fingerprint ) { 905 if ( fingerprint == UCONST64(-1) ) SignatureIterator::iterate();// Must be too many arguments 906 else { 907 _return_type = (BasicType)((fingerprint >> static_feature_size) & 908 result_feature_mask); 909 910 assert(fingerprint, "Fingerprint should not be 0"); 911 fingerprint = fingerprint >> (static_feature_size + result_feature_size); 912 while ( 1 ) { 913 switch ( fingerprint & parameter_feature_mask ) { 914 case bool_parm: 915 case char_parm: 916 case short_parm: 917 case byte_parm: 918 case int_parm: 919 get_int(); 920 break; 921 case obj_parm: 922 get_object(); 923 break; 924 case long_parm: 925 get_long(); 926 break; 927 case float_parm: 928 get_float(); 929 break; 930 case double_parm: 931 get_double(); 932 break; 933 case done_parm: 934 return; 935 break; 936 default: 937 ShouldNotReachHere(); 938 break; 939 } 940 fingerprint >>= parameter_feature_size; 941 } 942 } 943 } 944 }; 945 946 947 class JNI_ArgumentPusherArray : public JNI_ArgumentPusher { 948 protected: 949 const jvalue *_ap; 950 951 inline void get_bool() { _arguments->push_int((jint)(_ap++)->z); } 952 inline void get_char() { _arguments->push_int((jint)(_ap++)->c); } 953 inline void get_short() { _arguments->push_int((jint)(_ap++)->s); } 954 inline void get_byte() { _arguments->push_int((jint)(_ap++)->b); } 955 inline void get_int() { _arguments->push_int((jint)(_ap++)->i); } 956 957 inline void get_long() { _arguments->push_long((_ap++)->j); } 958 inline void get_float() { _arguments->push_float((_ap++)->f); } 959 inline void get_double() { _arguments->push_double((_ap++)->d);} 960 inline void get_object() { _arguments->push_oop(Handle((oop *)(_ap++)->l, false)); } 961 962 inline void set_ap(const jvalue *rap) { _ap = rap; } 963 964 public: 965 JNI_ArgumentPusherArray(Symbol* signature, const jvalue *rap) 966 : JNI_ArgumentPusher(signature) { 967 set_ap(rap); 968 } 969 JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap) 970 : JNI_ArgumentPusher(JNIHandles::resolve_jmethod_id(method_id)->signature()) { 971 set_ap(rap); 972 } 973 974 // Optimized path if we have the bitvector form of signature 975 void iterate( uint64_t fingerprint ) { 976 if ( fingerprint == UCONST64(-1) ) SignatureIterator::iterate(); // Must be too many arguments 977 else { 978 _return_type = (BasicType)((fingerprint >> static_feature_size) & 979 result_feature_mask); 980 assert(fingerprint, "Fingerprint should not be 0"); 981 fingerprint = fingerprint >> (static_feature_size + result_feature_size); 982 while ( 1 ) { 983 switch ( fingerprint & parameter_feature_mask ) { 984 case bool_parm: 985 get_bool(); 986 break; 987 case char_parm: 988 get_char(); 989 break; 990 case short_parm: 991 get_short(); 992 break; 993 case byte_parm: 994 get_byte(); 995 break; 996 case int_parm: 997 get_int(); 998 break; 999 case obj_parm: 1000 get_object(); 1001 break; 1002 case long_parm: 1003 get_long(); 1004 break; 1005 case float_parm: 1006 get_float(); 1007 break; 1008 case double_parm: 1009 get_double(); 1010 break; 1011 case done_parm: 1012 return; 1013 break; 1014 default: 1015 ShouldNotReachHere(); 1016 break; 1017 } 1018 fingerprint >>= parameter_feature_size; 1019 } 1020 } 1021 } 1022 }; 1023 1024 1025 enum JNICallType { 1026 JNI_STATIC, 1027 JNI_VIRTUAL, 1028 JNI_NONVIRTUAL 1029 }; 1030 1031 static methodHandle jni_resolve_interface_call(Handle recv, methodHandle method, TRAPS) { 1032 assert(!method.is_null() , "method should not be null"); 1033 1034 KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc) 1035 if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass()); 1036 KlassHandle spec_klass (THREAD, method->method_holder()); 1037 Symbol* name = method->name(); 1038 Symbol* signature = method->signature(); 1039 CallInfo info; 1040 LinkResolver::resolve_interface_call(info, recv, recv_klass, spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle())); 1041 return info.selected_method(); 1042 } 1043 1044 static methodHandle jni_resolve_virtual_call(Handle recv, methodHandle method, TRAPS) { 1045 assert(!method.is_null() , "method should not be null"); 1046 1047 KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc) 1048 if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass()); 1049 KlassHandle spec_klass (THREAD, method->method_holder()); 1050 Symbol* name = method->name(); 1051 Symbol* signature = method->signature(); 1052 CallInfo info; 1053 LinkResolver::resolve_virtual_call(info, recv, recv_klass, spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle())); 1054 return info.selected_method(); 1055 } 1056 1057 1058 1059 static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) { 1060 methodHandle method(THREAD, JNIHandles::resolve_jmethod_id(method_id)); 1061 1062 // Create object to hold arguments for the JavaCall, and associate it with 1063 // the jni parser 1064 ResourceMark rm(THREAD); 1065 int number_of_parameters = method->size_of_parameters(); 1066 JavaCallArguments java_args(number_of_parameters); 1067 args->set_java_argument_object(&java_args); 1068 1069 assert(method->is_static(), "method should be static"); 1070 1071 // Fill out JavaCallArguments object 1072 args->iterate( Fingerprinter(method).fingerprint() ); 1073 // Initialize result type 1074 result->set_type(args->get_ret_type()); 1075 1076 // Invoke the method. Result is returned as oop. 1077 JavaCalls::call(result, method, &java_args, CHECK); 1078 1079 // Convert result 1080 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) { 1081 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject())); 1082 } 1083 } 1084 1085 1086 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) { 1087 oop recv = JNIHandles::resolve(receiver); 1088 if (recv == NULL) { 1089 THROW(vmSymbols::java_lang_NullPointerException()); 1090 } 1091 Handle h_recv(THREAD, recv); 1092 1093 int number_of_parameters; 1094 methodOop selected_method; 1095 { 1096 methodOop m = JNIHandles::resolve_jmethod_id(method_id); 1097 number_of_parameters = m->size_of_parameters(); 1098 klassOop holder = m->method_holder(); 1099 if (!(Klass::cast(holder))->is_interface()) { 1100 // non-interface call -- for that little speed boost, don't handlize 1101 debug_only(No_Safepoint_Verifier nosafepoint;) 1102 if (call_type == JNI_VIRTUAL) { 1103 // jni_GetMethodID makes sure class is linked and initialized 1104 // so m should have a valid vtable index. 1105 int vtbl_index = m->vtable_index(); 1106 if (vtbl_index != methodOopDesc::nonvirtual_vtable_index) { 1107 klassOop k = h_recv->klass(); 1108 // k might be an arrayKlassOop but all vtables start at 1109 // the same place. The cast is to avoid virtual call and assertion. 1110 instanceKlass *ik = (instanceKlass*)k->klass_part(); 1111 selected_method = ik->method_at_vtable(vtbl_index); 1112 } else { 1113 // final method 1114 selected_method = m; 1115 } 1116 } else { 1117 // JNI_NONVIRTUAL call 1118 selected_method = m; 1119 } 1120 } else { 1121 // interface call 1122 KlassHandle h_holder(THREAD, holder); 1123 1124 int itbl_index = m->cached_itable_index(); 1125 if (itbl_index == -1) { 1126 itbl_index = klassItable::compute_itable_index(m); 1127 m->set_cached_itable_index(itbl_index); 1128 // the above may have grabbed a lock, 'm' and anything non-handlized can't be used again 1129 } 1130 klassOop k = h_recv->klass(); 1131 selected_method = instanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK); 1132 } 1133 } 1134 1135 methodHandle method(THREAD, selected_method); 1136 1137 // Create object to hold arguments for the JavaCall, and associate it with 1138 // the jni parser 1139 ResourceMark rm(THREAD); 1140 JavaCallArguments java_args(number_of_parameters); 1141 args->set_java_argument_object(&java_args); 1142 1143 // handle arguments 1144 assert(!method->is_static(), "method should not be static"); 1145 args->push_receiver(h_recv); // Push jobject handle 1146 1147 // Fill out JavaCallArguments object 1148 args->iterate( Fingerprinter(method).fingerprint() ); 1149 // Initialize result type 1150 result->set_type(args->get_ret_type()); 1151 1152 // Invoke the method. Result is returned as oop. 1153 JavaCalls::call(result, method, &java_args, CHECK); 1154 1155 // Convert result 1156 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) { 1157 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject())); 1158 } 1159 } 1160 1161 1162 static instanceOop alloc_object(jclass clazz, TRAPS) { 1163 KlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); 1164 Klass::cast(k())->check_valid_for_instantiation(false, CHECK_NULL); 1165 instanceKlass::cast(k())->initialize(CHECK_NULL); 1166 instanceOop ih = instanceKlass::cast(k())->allocate_instance(THREAD); 1167 return ih; 1168 } 1169 1170 DT_RETURN_MARK_DECL(AllocObject, jobject); 1171 1172 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) 1173 JNIWrapper("AllocObject"); 1174 1175 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); 1176 jobject ret = NULL; 1177 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); 1178 1179 instanceOop i = alloc_object(clazz, CHECK_NULL); 1180 ret = JNIHandles::make_local(env, i); 1181 return ret; 1182 JNI_END 1183 1184 DT_RETURN_MARK_DECL(NewObjectA, jobject); 1185 1186 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) 1187 JNIWrapper("NewObjectA"); 1188 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); 1189 jobject obj = NULL; 1190 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); 1191 1192 instanceOop i = alloc_object(clazz, CHECK_NULL); 1193 obj = JNIHandles::make_local(env, i); 1194 JavaValue jvalue(T_VOID); 1195 JNI_ArgumentPusherArray ap(methodID, args); 1196 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1197 return obj; 1198 JNI_END 1199 1200 DT_RETURN_MARK_DECL(NewObjectV, jobject); 1201 1202 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) 1203 JNIWrapper("NewObjectV"); 1204 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID); 1205 jobject obj = NULL; 1206 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); 1207 1208 instanceOop i = alloc_object(clazz, CHECK_NULL); 1209 obj = JNIHandles::make_local(env, i); 1210 JavaValue jvalue(T_VOID); 1211 JNI_ArgumentPusherVaArg ap(methodID, args); 1212 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1213 return obj; 1214 JNI_END 1215 1216 DT_RETURN_MARK_DECL(NewObject, jobject); 1217 1218 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) 1219 JNIWrapper("NewObject"); 1220 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID); 1221 jobject obj = NULL; 1222 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); 1223 1224 instanceOop i = alloc_object(clazz, CHECK_NULL); 1225 obj = JNIHandles::make_local(env, i); 1226 va_list args; 1227 va_start(args, methodID); 1228 JavaValue jvalue(T_VOID); 1229 JNI_ArgumentPusherVaArg ap(methodID, args); 1230 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); 1231 va_end(args); 1232 return obj; 1233 JNI_END 1234 1235 1236 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) 1237 JNIWrapper("GetObjectClass"); 1238 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj); 1239 klassOop k = JNIHandles::resolve_non_null(obj)->klass(); 1240 jclass ret = 1241 (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); 1242 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret); 1243 return ret; 1244 JNI_END 1245 1246 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) 1247 JNIWrapper("IsInstanceOf"); 1248 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz); 1249 jboolean ret = JNI_TRUE; 1250 if (obj != NULL) { 1251 ret = JNI_FALSE; 1252 klassOop k = java_lang_Class::as_klassOop( 1253 JNIHandles::resolve_non_null(clazz)); 1254 if (k != NULL) { 1255 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; 1256 } 1257 } 1258 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret); 1259 return ret; 1260 JNI_END 1261 1262 1263 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, 1264 const char *sig, bool is_static, TRAPS) { 1265 // %%%% This code should probably just call into a method in the LinkResolver 1266 // 1267 // The class should have been loaded (we have an instance of the class 1268 // passed in) so the method and signature should already be in the symbol 1269 // table. If they're not there, the method doesn't exist. 1270 const char *name_to_probe = (name_str == NULL) 1271 ? vmSymbols::object_initializer_name()->as_C_string() 1272 : name_str; 1273 TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe)); 1274 TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig)); 1275 1276 if (name == NULL || signature == NULL) { 1277 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str); 1278 } 1279 1280 // Throw a NoSuchMethodError exception if we have an instance of a 1281 // primitive java.lang.Class 1282 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) { 1283 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str); 1284 } 1285 1286 KlassHandle klass(THREAD, 1287 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); 1288 1289 // Make sure class is linked and initialized before handing id's out to 1290 // methodOops. 1291 Klass::cast(klass())->initialize(CHECK_NULL); 1292 1293 methodOop m; 1294 if (name == vmSymbols::object_initializer_name() || 1295 name == vmSymbols::class_initializer_name()) { 1296 // Never search superclasses for constructors 1297 if (klass->oop_is_instance()) { 1298 m = instanceKlass::cast(klass())->find_method(name, signature); 1299 } else { 1300 m = NULL; 1301 } 1302 } else { 1303 m = klass->lookup_method(name, signature); 1304 // Look up interfaces 1305 if (m == NULL && klass->oop_is_instance()) { 1306 m = instanceKlass::cast(klass())->lookup_method_in_all_interfaces(name, 1307 signature); 1308 } 1309 } 1310 if (m == NULL || (m->is_static() != is_static)) { 1311 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str); 1312 } 1313 return m->jmethod_id(); 1314 } 1315 1316 1317 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, 1318 const char *name, const char *sig)) 1319 JNIWrapper("GetMethodID"); 1320 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); 1321 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); 1322 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); 1323 return ret; 1324 JNI_END 1325 1326 1327 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, 1328 const char *name, const char *sig)) 1329 JNIWrapper("GetStaticMethodID"); 1330 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); 1331 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); 1332 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); 1333 return ret; 1334 JNI_END 1335 1336 1337 1338 // 1339 // Calling Methods 1340 // 1341 1342 1343 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \ 1344 \ 1345 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\ 1346 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\ 1347 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\ 1348 \ 1349 JNI_ENTRY(ResultType, \ 1350 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ 1351 JNIWrapper("Call" XSTR(Result) "Method"); \ 1352 \ 1353 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID);\ 1354 ResultType ret = 0;\ 1355 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ 1356 (const ResultType&)ret);\ 1357 \ 1358 va_list args; \ 1359 va_start(args, methodID); \ 1360 JavaValue jvalue(Tag); \ 1361 JNI_ArgumentPusherVaArg ap(methodID, args); \ 1362 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ 1363 va_end(args); \ 1364 ret = jvalue.get_##ResultType(); \ 1365 return ret;\ 1366 JNI_END \ 1367 \ 1368 \ 1369 JNI_ENTRY(ResultType, \ 1370 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \ 1371 JNIWrapper("Call" XSTR(Result) "MethodV"); \ 1372 \ 1373 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID);\ 1374 ResultType ret = 0;\ 1375 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \ 1376 (const ResultType&)ret);\ 1377 \ 1378 JavaValue jvalue(Tag); \ 1379 JNI_ArgumentPusherVaArg ap(methodID, args); \ 1380 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ 1381 ret = jvalue.get_##ResultType(); \ 1382 return ret;\ 1383 JNI_END \ 1384 \ 1385 \ 1386 JNI_ENTRY(ResultType, \ 1387 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \ 1388 JNIWrapper("Call" XSTR(Result) "MethodA"); \ 1389 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID);\ 1390 ResultType ret = 0;\ 1391 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \ 1392 (const ResultType&)ret);\ 1393 \ 1394 JavaValue jvalue(Tag); \ 1395 JNI_ArgumentPusherArray ap(methodID, args); \ 1396 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ 1397 ret = jvalue.get_##ResultType(); \ 1398 return ret;\ 1399 JNI_END 1400 1401 // the runtime type of subword integral basic types is integer 1402 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN) 1403 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE) 1404 DEFINE_CALLMETHOD(jchar, Char, T_CHAR) 1405 DEFINE_CALLMETHOD(jshort, Short, T_SHORT) 1406 1407 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT) 1408 DEFINE_CALLMETHOD(jint, Int, T_INT) 1409 DEFINE_CALLMETHOD(jlong, Long, T_LONG) 1410 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT) 1411 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE) 1412 1413 DT_VOID_RETURN_MARK_DECL(CallVoidMethod); 1414 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV); 1415 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA); 1416 1417 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) 1418 JNIWrapper("CallVoidMethod"); 1419 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID); 1420 DT_VOID_RETURN_MARK(CallVoidMethod); 1421 1422 va_list args; 1423 va_start(args, methodID); 1424 JavaValue jvalue(T_VOID); 1425 JNI_ArgumentPusherVaArg ap(methodID, args); 1426 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1427 va_end(args); 1428 JNI_END 1429 1430 1431 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) 1432 JNIWrapper("CallVoidMethodV"); 1433 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); 1434 DT_VOID_RETURN_MARK(CallVoidMethodV); 1435 1436 JavaValue jvalue(T_VOID); 1437 JNI_ArgumentPusherVaArg ap(methodID, args); 1438 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1439 JNI_END 1440 1441 1442 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) 1443 JNIWrapper("CallVoidMethodA"); 1444 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); 1445 DT_VOID_RETURN_MARK(CallVoidMethodA); 1446 1447 JavaValue jvalue(T_VOID); 1448 JNI_ArgumentPusherArray ap(methodID, args); 1449 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); 1450 JNI_END 1451 1452 1453 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \ 1454 \ 1455 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\ 1456 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\ 1457 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\ 1458 \ 1459 JNI_ENTRY(ResultType, \ 1460 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \ 1461 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \ 1462 \ 1463 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\ 1464 ResultType ret;\ 1465 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \ 1466 (const ResultType&)ret);\ 1467 \ 1468 va_list args; \ 1469 va_start(args, methodID); \ 1470 JavaValue jvalue(Tag); \ 1471 JNI_ArgumentPusherVaArg ap(methodID, args); \ 1472 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ 1473 va_end(args); \ 1474 ret = jvalue.get_##ResultType(); \ 1475 return ret;\ 1476 JNI_END \ 1477 \ 1478 JNI_ENTRY(ResultType, \ 1479 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \ 1480 JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \ 1481 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\ 1482 ResultType ret;\ 1483 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \ 1484 (const ResultType&)ret);\ 1485 \ 1486 JavaValue jvalue(Tag); \ 1487 JNI_ArgumentPusherVaArg ap(methodID, args); \ 1488 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ 1489 ret = jvalue.get_##ResultType(); \ 1490 return ret;\ 1491 JNI_END \ 1492 \ 1493 JNI_ENTRY(ResultType, \ 1494 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \ 1495 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \ 1496 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\ 1497 ResultType ret;\ 1498 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \ 1499 (const ResultType&)ret);\ 1500 \ 1501 JavaValue jvalue(Tag); \ 1502 JNI_ArgumentPusherArray ap(methodID, args); \ 1503 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ 1504 ret = jvalue.get_##ResultType(); \ 1505 return ret;\ 1506 JNI_END 1507 1508 // the runtime type of subword integral basic types is integer 1509 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN) 1510 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE) 1511 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR) 1512 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT) 1513 1514 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT) 1515 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT) 1516 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG) 1517 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT) 1518 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE) 1519 1520 1521 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod); 1522 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV); 1523 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA); 1524 1525 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) 1526 JNIWrapper("CallNonvirtualVoidMethod"); 1527 1528 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, 1529 env, obj, cls, methodID); 1530 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); 1531 1532 va_list args; 1533 va_start(args, methodID); 1534 JavaValue jvalue(T_VOID); 1535 JNI_ArgumentPusherVaArg ap(methodID, args); 1536 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 1537 va_end(args); 1538 JNI_END 1539 1540 1541 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) 1542 JNIWrapper("CallNonvirtualVoidMethodV"); 1543 1544 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry, 1545 env, obj, cls, methodID); 1546 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); 1547 1548 JavaValue jvalue(T_VOID); 1549 JNI_ArgumentPusherVaArg ap(methodID, args); 1550 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 1551 JNI_END 1552 1553 1554 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) 1555 JNIWrapper("CallNonvirtualVoidMethodA"); 1556 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry, 1557 env, obj, cls, methodID); 1558 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); 1559 JavaValue jvalue(T_VOID); 1560 JNI_ArgumentPusherArray ap(methodID, args); 1561 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); 1562 JNI_END 1563 1564 1565 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \ 1566 \ 1567 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\ 1568 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\ 1569 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\ 1570 \ 1571 JNI_ENTRY(ResultType, \ 1572 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \ 1573 JNIWrapper("CallStatic" XSTR(Result) "Method"); \ 1574 \ 1575 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\ 1576 ResultType ret = 0;\ 1577 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \ 1578 (const ResultType&)ret);\ 1579 \ 1580 va_list args; \ 1581 va_start(args, methodID); \ 1582 JavaValue jvalue(Tag); \ 1583 JNI_ArgumentPusherVaArg ap(methodID, args); \ 1584 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ 1585 va_end(args); \ 1586 ret = jvalue.get_##ResultType(); \ 1587 return ret;\ 1588 JNI_END \ 1589 \ 1590 JNI_ENTRY(ResultType, \ 1591 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \ 1592 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \ 1593 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\ 1594 ResultType ret = 0;\ 1595 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \ 1596 (const ResultType&)ret);\ 1597 \ 1598 JavaValue jvalue(Tag); \ 1599 JNI_ArgumentPusherVaArg ap(methodID, args); \ 1600 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ 1601 ret = jvalue.get_##ResultType(); \ 1602 return ret;\ 1603 JNI_END \ 1604 \ 1605 JNI_ENTRY(ResultType, \ 1606 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \ 1607 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \ 1608 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\ 1609 ResultType ret = 0;\ 1610 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \ 1611 (const ResultType&)ret);\ 1612 \ 1613 JavaValue jvalue(Tag); \ 1614 JNI_ArgumentPusherArray ap(methodID, args); \ 1615 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ 1616 ret = jvalue.get_##ResultType(); \ 1617 return ret;\ 1618 JNI_END 1619 1620 // the runtime type of subword integral basic types is integer 1621 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN) 1622 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE) 1623 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR) 1624 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT) 1625 1626 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT) 1627 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT) 1628 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG) 1629 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT) 1630 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE) 1631 1632 1633 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod); 1634 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV); 1635 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA); 1636 1637 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) 1638 JNIWrapper("CallStaticVoidMethod"); 1639 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); 1640 DT_VOID_RETURN_MARK(CallStaticVoidMethod); 1641 1642 va_list args; 1643 va_start(args, methodID); 1644 JavaValue jvalue(T_VOID); 1645 JNI_ArgumentPusherVaArg ap(methodID, args); 1646 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 1647 va_end(args); 1648 JNI_END 1649 1650 1651 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) 1652 JNIWrapper("CallStaticVoidMethodV"); 1653 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); 1654 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); 1655 1656 JavaValue jvalue(T_VOID); 1657 JNI_ArgumentPusherVaArg ap(methodID, args); 1658 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 1659 JNI_END 1660 1661 1662 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) 1663 JNIWrapper("CallStaticVoidMethodA"); 1664 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); 1665 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); 1666 1667 JavaValue jvalue(T_VOID); 1668 JNI_ArgumentPusherArray ap(methodID, args); 1669 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); 1670 JNI_END 1671 1672 1673 // 1674 // Accessing Fields 1675 // 1676 1677 1678 DT_RETURN_MARK_DECL(GetFieldID, jfieldID); 1679 1680 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz, 1681 const char *name, const char *sig)) 1682 JNIWrapper("GetFieldID"); 1683 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig); 1684 jfieldID ret = 0; 1685 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret); 1686 1687 // The class should have been loaded (we have an instance of the class 1688 // passed in) so the field and signature should already be in the symbol 1689 // table. If they're not there, the field doesn't exist. 1690 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name)); 1691 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig)); 1692 if (fieldname == NULL || signame == NULL) { 1693 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name); 1694 } 1695 KlassHandle k(THREAD, 1696 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); 1697 // Make sure class is initialized before handing id's out to fields 1698 Klass::cast(k())->initialize(CHECK_NULL); 1699 1700 fieldDescriptor fd; 1701 if (!Klass::cast(k())->oop_is_instance() || 1702 !instanceKlass::cast(k())->find_field(fieldname, signame, false, &fd)) { 1703 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name); 1704 } 1705 1706 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop 1707 // It may also have hash bits for k, if VerifyJNIFields is turned on. 1708 ret = jfieldIDWorkaround::to_instance_jfieldID(k(), fd.offset()); 1709 return ret; 1710 JNI_END 1711 1712 1713 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)) 1714 JNIWrapper("GetObjectField"); 1715 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID); 1716 oop o = JNIHandles::resolve_non_null(obj); 1717 klassOop k = o->klass(); 1718 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 1719 // Keep JVMTI addition small and only check enabled flag here. 1720 // jni_GetField_probe() assumes that is okay to create handles. 1721 if (JvmtiExport::should_post_field_access()) { 1722 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false); 1723 } 1724 jobject ret = JNIHandles::make_local(env, o->obj_field(offset)); 1725 #ifndef SERIALGC 1726 // If G1 is enabled and we are accessing the value of the referent 1727 // field in a reference object then we need to register a non-null 1728 // referent with the SATB barrier. 1729 if (UseG1GC) { 1730 bool needs_barrier = false; 1731 1732 if (ret != NULL && 1733 offset == java_lang_ref_Reference::referent_offset && 1734 instanceKlass::cast(k)->reference_type() != REF_NONE) { 1735 assert(instanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity"); 1736 needs_barrier = true; 1737 } 1738 1739 if (needs_barrier) { 1740 oop referent = JNIHandles::resolve(ret); 1741 G1SATBCardTableModRefBS::enqueue(referent); 1742 } 1743 } 1744 #endif // SERIALGC 1745 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret); 1746 return ret; 1747 JNI_END 1748 1749 1750 #define DEFINE_GETFIELD(Return,Fieldname,Result) \ 1751 \ 1752 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\ 1753 \ 1754 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \ 1755 JNIWrapper("Get" XSTR(Result) "Field"); \ 1756 \ 1757 DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\ 1758 Return ret = 0;\ 1759 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\ 1760 \ 1761 oop o = JNIHandles::resolve_non_null(obj); \ 1762 klassOop k = o->klass(); \ 1763 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ 1764 /* Keep JVMTI addition small and only check enabled flag here. */ \ 1765 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \ 1766 /* and creates a ResetNoHandleMark. */ \ 1767 if (JvmtiExport::should_post_field_access()) { \ 1768 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \ 1769 } \ 1770 ret = o->Fieldname##_field(offset); \ 1771 return ret; \ 1772 JNI_END 1773 1774 DEFINE_GETFIELD(jboolean, bool, Boolean) 1775 DEFINE_GETFIELD(jbyte, byte, Byte) 1776 DEFINE_GETFIELD(jchar, char, Char) 1777 DEFINE_GETFIELD(jshort, short, Short) 1778 DEFINE_GETFIELD(jint, int, Int) 1779 DEFINE_GETFIELD(jlong, long, Long) 1780 DEFINE_GETFIELD(jfloat, float, Float) 1781 DEFINE_GETFIELD(jdouble, double, Double) 1782 1783 address jni_GetBooleanField_addr() { 1784 return (address)jni_GetBooleanField; 1785 } 1786 address jni_GetByteField_addr() { 1787 return (address)jni_GetByteField; 1788 } 1789 address jni_GetCharField_addr() { 1790 return (address)jni_GetCharField; 1791 } 1792 address jni_GetShortField_addr() { 1793 return (address)jni_GetShortField; 1794 } 1795 address jni_GetIntField_addr() { 1796 return (address)jni_GetIntField; 1797 } 1798 address jni_GetLongField_addr() { 1799 return (address)jni_GetLongField; 1800 } 1801 address jni_GetFloatField_addr() { 1802 return (address)jni_GetFloatField; 1803 } 1804 address jni_GetDoubleField_addr() { 1805 return (address)jni_GetDoubleField; 1806 } 1807 1808 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)) 1809 JNIWrapper("SetObjectField"); 1810 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value); 1811 oop o = JNIHandles::resolve_non_null(obj); 1812 klassOop k = o->klass(); 1813 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 1814 // Keep JVMTI addition small and only check enabled flag here. 1815 // jni_SetField_probe_nh() assumes that is not okay to create handles 1816 // and creates a ResetNoHandleMark. 1817 if (JvmtiExport::should_post_field_modification()) { 1818 jvalue field_value; 1819 field_value.l = value; 1820 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); 1821 } 1822 o->obj_field_put(offset, JNIHandles::resolve(value)); 1823 DTRACE_PROBE(hotspot_jni, SetObjectField__return); 1824 JNI_END 1825 1826 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \ 1827 \ 1828 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ 1829 JNIWrapper("Set" XSTR(Result) "Field"); \ 1830 \ 1831 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, Set##Result##Field__entry, \ 1832 ( JNIEnv*, jobject, jfieldID FP_SELECT_##Result(COMMA Argument,/*empty*/) ) ); \ 1833 HS_DTRACE_PROBE_N(hotspot_jni, Set##Result##Field__entry, \ 1834 ( env, obj, fieldID FP_SELECT_##Result(COMMA value,/*empty*/) ) ); \ 1835 \ 1836 oop o = JNIHandles::resolve_non_null(obj); \ 1837 klassOop k = o->klass(); \ 1838 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ 1839 /* Keep JVMTI addition small and only check enabled flag here. */ \ 1840 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \ 1841 /* and creates a ResetNoHandleMark. */ \ 1842 if (JvmtiExport::should_post_field_modification()) { \ 1843 jvalue field_value; \ 1844 field_value.unionType = value; \ 1845 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \ 1846 } \ 1847 o->Fieldname##_field_put(offset, value); \ 1848 DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\ 1849 JNI_END 1850 1851 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z) 1852 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b) 1853 DEFINE_SETFIELD(jchar, char, Char, 'C', c) 1854 DEFINE_SETFIELD(jshort, short, Short, 'S', s) 1855 DEFINE_SETFIELD(jint, int, Int, 'I', i) 1856 DEFINE_SETFIELD(jlong, long, Long, 'J', j) 1857 DEFINE_SETFIELD(jfloat, float, Float, 'F', f) 1858 DEFINE_SETFIELD(jdouble, double, Double, 'D', d) 1859 1860 DT_RETURN_MARK_DECL(ToReflectedField, jobject); 1861 1862 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) 1863 JNIWrapper("ToReflectedField"); 1864 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, 1865 env, cls, fieldID, isStatic); 1866 jobject ret = NULL; 1867 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); 1868 1869 fieldDescriptor fd; 1870 bool found = false; 1871 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1872 1873 assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID"); 1874 1875 if (isStatic) { 1876 // Static field. The fieldID a JNIid specifying the field holder and the offset within the klassOop. 1877 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 1878 assert(id->is_static_field_id(), "invalid static field id"); 1879 found = id->find_local_field(&fd); 1880 } else { 1881 // Non-static field. The fieldID is really the offset of the field within the instanceOop. 1882 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 1883 found = instanceKlass::cast(k)->find_field_from_offset(offset, false, &fd); 1884 } 1885 assert(found, "bad fieldID passed into jni_ToReflectedField"); 1886 oop reflected = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL); 1887 ret = JNIHandles::make_local(env, reflected); 1888 return ret; 1889 JNI_END 1890 1891 1892 // 1893 // Accessing Static Fields 1894 // 1895 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID); 1896 1897 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, 1898 const char *name, const char *sig)) 1899 JNIWrapper("GetStaticFieldID"); 1900 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig); 1901 jfieldID ret = NULL; 1902 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); 1903 1904 // The class should have been loaded (we have an instance of the class 1905 // passed in) so the field and signature should already be in the symbol 1906 // table. If they're not there, the field doesn't exist. 1907 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name)); 1908 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig)); 1909 if (fieldname == NULL || signame == NULL) { 1910 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name); 1911 } 1912 KlassHandle k(THREAD, 1913 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); 1914 // Make sure class is initialized before handing id's out to static fields 1915 Klass::cast(k())->initialize(CHECK_NULL); 1916 1917 fieldDescriptor fd; 1918 if (!Klass::cast(k())->oop_is_instance() || 1919 !instanceKlass::cast(k())->find_field(fieldname, signame, true, &fd)) { 1920 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name); 1921 } 1922 1923 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop 1924 JNIid* id = instanceKlass::cast(fd.field_holder())->jni_id_for(fd.offset()); 1925 debug_only(id->set_is_static_field_id();) 1926 1927 debug_only(id->verify(fd.field_holder())); 1928 1929 ret = jfieldIDWorkaround::to_static_jfieldID(id); 1930 return ret; 1931 JNI_END 1932 1933 1934 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)) 1935 JNIWrapper("GetStaticObjectField"); 1936 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID); 1937 #ifndef JNICHECK_KERNEL 1938 DEBUG_ONLY(klassOop param_k = jniCheck::validate_class(thread, clazz);) 1939 #endif // JNICHECK_KERNEL 1940 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 1941 assert(id->is_static_field_id(), "invalid static field id"); 1942 // Keep JVMTI addition small and only check enabled flag here. 1943 // jni_GetField_probe() assumes that is okay to create handles. 1944 if (JvmtiExport::should_post_field_access()) { 1945 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); 1946 } 1947 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); 1948 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret); 1949 return ret; 1950 JNI_END 1951 1952 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \ 1953 \ 1954 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\ 1955 \ 1956 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \ 1957 JNIWrapper("GetStatic" XSTR(Result) "Field"); \ 1958 DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\ 1959 Return ret = 0;\ 1960 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \ 1961 (const Return&)ret);\ 1962 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ 1963 assert(id->is_static_field_id(), "invalid static field id"); \ 1964 /* Keep JVMTI addition small and only check enabled flag here. */ \ 1965 /* jni_GetField_probe() assumes that is okay to create handles. */ \ 1966 if (JvmtiExport::should_post_field_access()) { \ 1967 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \ 1968 } \ 1969 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \ 1970 return ret;\ 1971 JNI_END 1972 1973 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean) 1974 DEFINE_GETSTATICFIELD(jbyte, byte, Byte) 1975 DEFINE_GETSTATICFIELD(jchar, char, Char) 1976 DEFINE_GETSTATICFIELD(jshort, short, Short) 1977 DEFINE_GETSTATICFIELD(jint, int, Int) 1978 DEFINE_GETSTATICFIELD(jlong, long, Long) 1979 DEFINE_GETSTATICFIELD(jfloat, float, Float) 1980 DEFINE_GETSTATICFIELD(jdouble, double, Double) 1981 1982 1983 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) 1984 JNIWrapper("SetStaticObjectField"); 1985 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); 1986 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 1987 assert(id->is_static_field_id(), "invalid static field id"); 1988 // Keep JVMTI addition small and only check enabled flag here. 1989 // jni_SetField_probe() assumes that is okay to create handles. 1990 if (JvmtiExport::should_post_field_modification()) { 1991 jvalue field_value; 1992 field_value.l = value; 1993 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); 1994 } 1995 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); 1996 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); 1997 JNI_END 1998 1999 2000 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \ 2001 \ 2002 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ 2003 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ 2004 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\ 2005 ( JNIEnv*, jclass, jfieldID FP_SELECT_##Result(COMMA Argument,/*empty*/) ) ); \ 2006 HS_DTRACE_PROBE_N(hotspot_jni, SetStatic##Result##Field__entry, \ 2007 ( env, clazz, fieldID FP_SELECT_##Result(COMMA value,/*empty*/) ) ); \ 2008 \ 2009 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ 2010 assert(id->is_static_field_id(), "invalid static field id"); \ 2011 /* Keep JVMTI addition small and only check enabled flag here. */ \ 2012 /* jni_SetField_probe() assumes that is okay to create handles. */ \ 2013 if (JvmtiExport::should_post_field_modification()) { \ 2014 jvalue field_value; \ 2015 field_value.unionType = value; \ 2016 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \ 2017 } \ 2018 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \ 2019 DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\ 2020 JNI_END 2021 2022 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z) 2023 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b) 2024 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c) 2025 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s) 2026 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i) 2027 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j) 2028 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f) 2029 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d) 2030 2031 2032 // 2033 // String Operations 2034 // 2035 2036 // Unicode Interface 2037 2038 DT_RETURN_MARK_DECL(NewString, jstring); 2039 2040 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) 2041 JNIWrapper("NewString"); 2042 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); 2043 jstring ret = NULL; 2044 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); 2045 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); 2046 ret = (jstring) JNIHandles::make_local(env, string); 2047 return ret; 2048 JNI_END 2049 2050 2051 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) 2052 JNIWrapper("GetStringLength"); 2053 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); 2054 jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string)); 2055 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); 2056 return ret; 2057 JNI_END 2058 2059 2060 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( 2061 JNIEnv *env, jstring string, jboolean *isCopy)) 2062 JNIWrapper("GetStringChars"); 2063 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); 2064 //%note jni_5 2065 if (isCopy != NULL) { 2066 *isCopy = JNI_TRUE; 2067 } 2068 oop s = JNIHandles::resolve_non_null(string); 2069 int s_len = java_lang_String::length(s); 2070 typeArrayOop s_value = java_lang_String::value(s); 2071 int s_offset = java_lang_String::offset(s); 2072 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination 2073 if (s_len > 0) { 2074 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len); 2075 } 2076 buf[s_len] = 0; 2077 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); 2078 return buf; 2079 JNI_END 2080 2081 2082 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) 2083 JNIWrapper("ReleaseStringChars"); 2084 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); 2085 //%note jni_6 2086 if (chars != NULL) { 2087 // Since String objects are supposed to be immutable, don't copy any 2088 // new data back. A bad user will have to go after the char array. 2089 FreeHeap((void*) chars); 2090 } 2091 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); 2092 JNI_END 2093 2094 2095 // UTF Interface 2096 2097 DT_RETURN_MARK_DECL(NewStringUTF, jstring); 2098 2099 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) 2100 JNIWrapper("NewStringUTF"); 2101 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); 2102 jstring ret; 2103 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); 2104 2105 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); 2106 ret = (jstring) JNIHandles::make_local(env, result); 2107 return ret; 2108 JNI_END 2109 2110 2111 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) 2112 JNIWrapper("GetStringUTFLength"); 2113 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); 2114 jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string)); 2115 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); 2116 return ret; 2117 JNI_END 2118 2119 2120 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) 2121 JNIWrapper("GetStringUTFChars"); 2122 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); 2123 oop java_string = JNIHandles::resolve_non_null(string); 2124 size_t length = java_lang_String::utf8_length(java_string); 2125 char* result = AllocateHeap(length + 1, "GetStringUTFChars"); 2126 java_lang_String::as_utf8_string(java_string, result, (int) length + 1); 2127 if (isCopy != NULL) *isCopy = JNI_TRUE; 2128 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); 2129 return result; 2130 JNI_END 2131 2132 2133 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) 2134 JNIWrapper("ReleaseStringUTFChars"); 2135 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); 2136 if (chars != NULL) { 2137 FreeHeap((char*) chars); 2138 } 2139 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); 2140 JNI_END 2141 2142 2143 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) 2144 JNIWrapper("GetArrayLength"); 2145 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); 2146 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); 2147 assert(a->is_array(), "must be array"); 2148 jsize ret = a->length(); 2149 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); 2150 return ret; 2151 JNI_END 2152 2153 2154 // 2155 // Object Array Operations 2156 // 2157 2158 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray); 2159 2160 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) 2161 JNIWrapper("NewObjectArray"); 2162 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); 2163 jobjectArray ret = NULL; 2164 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); 2165 KlassHandle ek(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(elementClass))); 2166 klassOop ako = Klass::cast(ek())->array_klass(CHECK_NULL); 2167 KlassHandle ak = KlassHandle(THREAD, ako); 2168 objArrayKlass::cast(ak())->initialize(CHECK_NULL); 2169 objArrayOop result = objArrayKlass::cast(ak())->allocate(length, CHECK_NULL); 2170 oop initial_value = JNIHandles::resolve(initialElement); 2171 if (initial_value != NULL) { // array already initialized with NULL 2172 for (int index = 0; index < length; index++) { 2173 result->obj_at_put(index, initial_value); 2174 } 2175 } 2176 ret = (jobjectArray) JNIHandles::make_local(env, result); 2177 return ret; 2178 JNI_END 2179 2180 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject); 2181 2182 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) 2183 JNIWrapper("GetObjectArrayElement"); 2184 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index); 2185 jobject ret = NULL; 2186 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); 2187 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 2188 if (a->is_within_bounds(index)) { 2189 ret = JNIHandles::make_local(env, a->obj_at(index)); 2190 return ret; 2191 } else { 2192 char buf[jintAsStringSize]; 2193 sprintf(buf, "%d", index); 2194 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); 2195 } 2196 JNI_END 2197 2198 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement); 2199 2200 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) 2201 JNIWrapper("SetObjectArrayElement"); 2202 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value); 2203 DT_VOID_RETURN_MARK(SetObjectArrayElement); 2204 2205 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 2206 oop v = JNIHandles::resolve(value); 2207 if (a->is_within_bounds(index)) { 2208 if (v == NULL || v->is_a(objArrayKlass::cast(a->klass())->element_klass())) { 2209 a->obj_at_put(index, v); 2210 } else { 2211 THROW(vmSymbols::java_lang_ArrayStoreException()); 2212 } 2213 } else { 2214 char buf[jintAsStringSize]; 2215 sprintf(buf, "%d", index); 2216 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); 2217 } 2218 JNI_END 2219 2220 2221 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \ 2222 \ 2223 DT_RETURN_MARK_DECL(New##Result##Array, Return);\ 2224 \ 2225 JNI_ENTRY(Return, \ 2226 jni_New##Result##Array(JNIEnv *env, jsize len)) \ 2227 JNIWrapper("New" XSTR(Result) "Array"); \ 2228 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\ 2229 Return ret = NULL;\ 2230 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\ 2231 \ 2232 oop obj= oopFactory::Allocator(len, CHECK_0); \ 2233 ret = (Return) JNIHandles::make_local(env, obj); \ 2234 return ret;\ 2235 JNI_END 2236 2237 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean) 2238 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte) 2239 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short) 2240 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char) 2241 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int) 2242 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long) 2243 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float) 2244 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double) 2245 2246 2247 // Return an address which will fault if the caller writes to it. 2248 2249 static char* get_bad_address() { 2250 static char* bad_address = NULL; 2251 if (bad_address == NULL) { 2252 size_t size = os::vm_allocation_granularity(); 2253 bad_address = os::reserve_memory(size); 2254 if (bad_address != NULL) { 2255 os::protect_memory(bad_address, size, os::MEM_PROT_READ, 2256 /*is_committed*/false); 2257 } 2258 } 2259 return bad_address; 2260 } 2261 2262 2263 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \ 2264 \ 2265 JNI_QUICK_ENTRY(ElementType*, \ 2266 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \ 2267 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \ 2268 DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\ 2269 /* allocate an chunk of memory in c land */ \ 2270 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ 2271 ElementType* result; \ 2272 int len = a->length(); \ 2273 if (len == 0) { \ 2274 /* Empty array: legal but useless, can't return NULL. \ 2275 * Return a pointer to something useless. \ 2276 * Avoid asserts in typeArrayOop. */ \ 2277 result = (ElementType*)get_bad_address(); \ 2278 } else { \ 2279 result = NEW_C_HEAP_ARRAY(ElementType, len); \ 2280 /* copy the array to the c chunk */ \ 2281 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \ 2282 } \ 2283 if (isCopy) *isCopy = JNI_TRUE; \ 2284 DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\ 2285 return result; \ 2286 JNI_END 2287 2288 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool) 2289 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte) 2290 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short) 2291 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char) 2292 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int) 2293 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long) 2294 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) 2295 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) 2296 2297 2298 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \ 2299 \ 2300 JNI_QUICK_ENTRY(void, \ 2301 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ 2302 ElementType *buf, jint mode)) \ 2303 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \ 2304 DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\ 2305 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ 2306 int len = a->length(); \ 2307 if (len != 0) { /* Empty array: nothing to free or copy. */ \ 2308 if ((mode == 0) || (mode == JNI_COMMIT)) { \ 2309 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \ 2310 } \ 2311 if ((mode == 0) || (mode == JNI_ABORT)) { \ 2312 FreeHeap(buf); \ 2313 } \ 2314 } \ 2315 DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\ 2316 JNI_END 2317 2318 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool) 2319 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte) 2320 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short) 2321 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char) 2322 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int) 2323 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long) 2324 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) 2325 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) 2326 2327 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ 2328 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\ 2329 \ 2330 JNI_ENTRY(void, \ 2331 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ 2332 jsize len, ElementType *buf)) \ 2333 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \ 2334 DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\ 2335 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \ 2336 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \ 2337 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \ 2338 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ 2339 } else { \ 2340 if (len > 0) { \ 2341 int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \ 2342 memcpy((u_char*) buf, \ 2343 (u_char*) src->Tag##_at_addr(start), \ 2344 len << sc); \ 2345 } \ 2346 } \ 2347 JNI_END 2348 2349 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool) 2350 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte) 2351 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short) 2352 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char) 2353 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int) 2354 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long) 2355 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) 2356 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) 2357 2358 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ 2359 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\ 2360 \ 2361 JNI_ENTRY(void, \ 2362 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ 2363 jsize len, const ElementType *buf)) \ 2364 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \ 2365 DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\ 2366 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \ 2367 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \ 2368 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \ 2369 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ 2370 } else { \ 2371 if (len > 0) { \ 2372 int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \ 2373 memcpy((u_char*) dst->Tag##_at_addr(start), \ 2374 (u_char*) buf, \ 2375 len << sc); \ 2376 } \ 2377 } \ 2378 JNI_END 2379 2380 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool) 2381 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte) 2382 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short) 2383 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char) 2384 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int) 2385 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long) 2386 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) 2387 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) 2388 2389 2390 // 2391 // Interception of natives 2392 // 2393 2394 // The RegisterNatives call being attempted tried to register with a method that 2395 // is not native. Ask JVM TI what prefixes have been specified. Then check 2396 // to see if the native method is now wrapped with the prefixes. See the 2397 // SetNativeMethodPrefix(es) functions in the JVM TI Spec for details. 2398 static methodOop find_prefixed_native(KlassHandle k, 2399 Symbol* name, Symbol* signature, TRAPS) { 2400 ResourceMark rm(THREAD); 2401 methodOop method; 2402 int name_len = name->utf8_length(); 2403 char* name_str = name->as_utf8(); 2404 int prefix_count; 2405 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count); 2406 for (int i = 0; i < prefix_count; i++) { 2407 char* prefix = prefixes[i]; 2408 int prefix_len = (int)strlen(prefix); 2409 2410 // try adding this prefix to the method name and see if it matches another method name 2411 int trial_len = name_len + prefix_len; 2412 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1); 2413 strcpy(trial_name_str, prefix); 2414 strcat(trial_name_str, name_str); 2415 TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len); 2416 if (trial_name == NULL) { 2417 continue; // no such symbol, so this prefix wasn't used, try the next prefix 2418 } 2419 method = Klass::cast(k())->lookup_method(trial_name, signature); 2420 if (method == NULL) { 2421 continue; // signature doesn't match, try the next prefix 2422 } 2423 if (method->is_native()) { 2424 method->set_is_prefixed_native(); 2425 return method; // wahoo, we found a prefixed version of the method, return it 2426 } 2427 // found as non-native, so prefix is good, add it, probably just need more prefixes 2428 name_len = trial_len; 2429 name_str = trial_name_str; 2430 } 2431 return NULL; // not found 2432 } 2433 2434 static bool register_native(KlassHandle k, Symbol* name, Symbol* signature, address entry, TRAPS) { 2435 methodOop method = Klass::cast(k())->lookup_method(name, signature); 2436 if (method == NULL) { 2437 ResourceMark rm; 2438 stringStream st; 2439 st.print("Method %s name or signature does not match", 2440 methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name, signature)); 2441 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false); 2442 } 2443 if (!method->is_native()) { 2444 // trying to register to a non-native method, see if a JVM TI agent has added prefix(es) 2445 method = find_prefixed_native(k, name, signature, THREAD); 2446 if (method == NULL) { 2447 ResourceMark rm; 2448 stringStream st; 2449 st.print("Method %s is not declared as native", 2450 methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name, signature)); 2451 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false); 2452 } 2453 } 2454 2455 if (entry != NULL) { 2456 method->set_native_function(entry, 2457 methodOopDesc::native_bind_event_is_interesting); 2458 } else { 2459 method->clear_native_function(); 2460 } 2461 if (PrintJNIResolving) { 2462 ResourceMark rm(THREAD); 2463 tty->print_cr("[Registering JNI native method %s.%s]", 2464 Klass::cast(method->method_holder())->external_name(), 2465 method->name()->as_C_string()); 2466 } 2467 return true; 2468 } 2469 2470 DT_RETURN_MARK_DECL(RegisterNatives, jint); 2471 2472 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz, 2473 const JNINativeMethod *methods, 2474 jint nMethods)) 2475 JNIWrapper("RegisterNatives"); 2476 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods); 2477 jint ret = 0; 2478 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret); 2479 2480 KlassHandle h_k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); 2481 2482 for (int index = 0; index < nMethods; index++) { 2483 const char* meth_name = methods[index].name; 2484 const char* meth_sig = methods[index].signature; 2485 int meth_name_len = (int)strlen(meth_name); 2486 2487 // The class should have been loaded (we have an instance of the class 2488 // passed in) so the method and signature should already be in the symbol 2489 // table. If they're not there, the method doesn't exist. 2490 TempNewSymbol name = SymbolTable::probe(meth_name, meth_name_len); 2491 TempNewSymbol signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig)); 2492 2493 if (name == NULL || signature == NULL) { 2494 ResourceMark rm; 2495 stringStream st; 2496 st.print("Method %s.%s%s not found", Klass::cast(h_k())->external_name(), meth_name, meth_sig); 2497 // Must return negative value on failure 2498 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1); 2499 } 2500 2501 bool res = register_native(h_k, name, signature, 2502 (address) methods[index].fnPtr, THREAD); 2503 if (!res) { 2504 ret = -1; 2505 break; 2506 } 2507 } 2508 return ret; 2509 JNI_END 2510 2511 2512 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz)) 2513 JNIWrapper("UnregisterNatives"); 2514 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz); 2515 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)); 2516 //%note jni_2 2517 if (Klass::cast(k)->oop_is_instance()) { 2518 for (int index = 0; index < instanceKlass::cast(k)->methods()->length(); index++) { 2519 methodOop m = methodOop(instanceKlass::cast(k)->methods()->obj_at(index)); 2520 if (m->is_native()) { 2521 m->clear_native_function(); 2522 m->set_signature_handler(NULL); 2523 } 2524 } 2525 } 2526 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0); 2527 return 0; 2528 JNI_END 2529 2530 // 2531 // Monitor functions 2532 // 2533 2534 DT_RETURN_MARK_DECL(MonitorEnter, jint); 2535 2536 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj)) 2537 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj); 2538 jint ret = JNI_ERR; 2539 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret); 2540 2541 // If the object is null, we can't do anything with it 2542 if (jobj == NULL) { 2543 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR); 2544 } 2545 2546 Handle obj(thread, JNIHandles::resolve_non_null(jobj)); 2547 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR)); 2548 ret = JNI_OK; 2549 return ret; 2550 JNI_END 2551 2552 DT_RETURN_MARK_DECL(MonitorExit, jint); 2553 2554 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj)) 2555 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj); 2556 jint ret = JNI_ERR; 2557 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret); 2558 2559 // Don't do anything with a null object 2560 if (jobj == NULL) { 2561 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR); 2562 } 2563 2564 Handle obj(THREAD, JNIHandles::resolve_non_null(jobj)); 2565 ObjectSynchronizer::jni_exit(obj(), CHECK_(JNI_ERR)); 2566 2567 ret = JNI_OK; 2568 return ret; 2569 JNI_END 2570 2571 // 2572 // Extensions 2573 // 2574 2575 DT_VOID_RETURN_MARK_DECL(GetStringRegion); 2576 2577 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) 2578 JNIWrapper("GetStringRegion"); 2579 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf); 2580 DT_VOID_RETURN_MARK(GetStringRegion); 2581 oop s = JNIHandles::resolve_non_null(string); 2582 int s_len = java_lang_String::length(s); 2583 if (start < 0 || len < 0 || start + len > s_len) { 2584 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); 2585 } else { 2586 if (len > 0) { 2587 int s_offset = java_lang_String::offset(s); 2588 typeArrayOop s_value = java_lang_String::value(s); 2589 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); 2590 } 2591 } 2592 JNI_END 2593 2594 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion); 2595 2596 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) 2597 JNIWrapper("GetStringUTFRegion"); 2598 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf); 2599 DT_VOID_RETURN_MARK(GetStringUTFRegion); 2600 oop s = JNIHandles::resolve_non_null(string); 2601 int s_len = java_lang_String::length(s); 2602 if (start < 0 || len < 0 || start + len > s_len) { 2603 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); 2604 } else { 2605 //%note jni_7 2606 if (len > 0) { 2607 ResourceMark rm(THREAD); 2608 char *utf_region = java_lang_String::as_utf8_string(s, start, len); 2609 int utf_len = (int)strlen(utf_region); 2610 memcpy(buf, utf_region, utf_len); 2611 buf[utf_len] = 0; 2612 } else { 2613 // JDK null-terminates the buffer even in len is zero 2614 if (buf != NULL) { 2615 buf[0] = 0; 2616 } 2617 } 2618 } 2619 JNI_END 2620 2621 2622 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) 2623 JNIWrapper("GetPrimitiveArrayCritical"); 2624 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy); 2625 GC_locker::lock_critical(thread); 2626 if (isCopy != NULL) { 2627 *isCopy = JNI_FALSE; 2628 } 2629 oop a = JNIHandles::resolve_non_null(array); 2630 assert(a->is_array(), "just checking"); 2631 BasicType type; 2632 if (a->is_objArray()) { 2633 type = T_OBJECT; 2634 } else { 2635 type = typeArrayKlass::cast(a->klass())->element_type(); 2636 } 2637 void* ret = arrayOop(a)->base(type); 2638 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); 2639 return ret; 2640 JNI_END 2641 2642 2643 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) 2644 JNIWrapper("ReleasePrimitiveArrayCritical"); 2645 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); 2646 // The array, carray and mode arguments are ignored 2647 GC_locker::unlock_critical(thread); 2648 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); 2649 JNI_END 2650 2651 2652 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) 2653 JNIWrapper("GetStringCritical"); 2654 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); 2655 GC_locker::lock_critical(thread); 2656 if (isCopy != NULL) { 2657 *isCopy = JNI_FALSE; 2658 } 2659 oop s = JNIHandles::resolve_non_null(string); 2660 int s_len = java_lang_String::length(s); 2661 typeArrayOop s_value = java_lang_String::value(s); 2662 int s_offset = java_lang_String::offset(s); 2663 const jchar* ret; 2664 if (s_len > 0) { 2665 ret = s_value->char_at_addr(s_offset); 2666 } else { 2667 ret = (jchar*) s_value->base(T_CHAR); 2668 } 2669 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); 2670 return ret; 2671 JNI_END 2672 2673 2674 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) 2675 JNIWrapper("ReleaseStringCritical"); 2676 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); 2677 // The str and chars arguments are ignored 2678 GC_locker::unlock_critical(thread); 2679 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); 2680 JNI_END 2681 2682 2683 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) 2684 JNIWrapper("jni_NewWeakGlobalRef"); 2685 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); 2686 Handle ref_handle(thread, JNIHandles::resolve(ref)); 2687 jweak ret = JNIHandles::make_weak_global(ref_handle); 2688 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); 2689 return ret; 2690 JNI_END 2691 2692 // Must be JNI_ENTRY (with HandleMark) 2693 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) 2694 JNIWrapper("jni_DeleteWeakGlobalRef"); 2695 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); 2696 JNIHandles::destroy_weak_global(ref); 2697 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); 2698 JNI_END 2699 2700 2701 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) 2702 JNIWrapper("jni_ExceptionCheck"); 2703 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); 2704 jni_check_async_exceptions(thread); 2705 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; 2706 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); 2707 return ret; 2708 JNI_END 2709 2710 2711 // Initialization state for three routines below relating to 2712 // java.nio.DirectBuffers 2713 static jint directBufferSupportInitializeStarted = 0; 2714 static volatile jint directBufferSupportInitializeEnded = 0; 2715 static volatile jint directBufferSupportInitializeFailed = 0; 2716 static jclass bufferClass = NULL; 2717 static jclass directBufferClass = NULL; 2718 static jclass directByteBufferClass = NULL; 2719 static jmethodID directByteBufferConstructor = NULL; 2720 static jfieldID directBufferAddressField = NULL; 2721 static jfieldID bufferCapacityField = NULL; 2722 2723 static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) { 2724 Handle loader; // null (bootstrap) loader 2725 Handle protection_domain; // null protection domain 2726 2727 TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL); 2728 jclass result = find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL); 2729 2730 if (TraceClassResolution && result != NULL) { 2731 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result))); 2732 } 2733 return result; 2734 } 2735 2736 // These lookups are done with the NULL (bootstrap) ClassLoader to 2737 // circumvent any security checks that would be done by jni_FindClass. 2738 JNI_ENTRY(bool, lookupDirectBufferClasses(JNIEnv* env)) 2739 { 2740 if ((bufferClass = lookupOne(env, "java/nio/Buffer", thread)) == NULL) { return false; } 2741 if ((directBufferClass = lookupOne(env, "sun/nio/ch/DirectBuffer", thread)) == NULL) { return false; } 2742 if ((directByteBufferClass = lookupOne(env, "java/nio/DirectByteBuffer", thread)) == NULL) { return false; } 2743 return true; 2744 } 2745 JNI_END 2746 2747 2748 static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) { 2749 if (directBufferSupportInitializeFailed) { 2750 return false; 2751 } 2752 2753 if (Atomic::cmpxchg(1, &directBufferSupportInitializeStarted, 0) == 0) { 2754 if (!lookupDirectBufferClasses(env)) { 2755 directBufferSupportInitializeFailed = 1; 2756 return false; 2757 } 2758 2759 // Make global references for these 2760 bufferClass = (jclass) env->NewGlobalRef(bufferClass); 2761 directBufferClass = (jclass) env->NewGlobalRef(directBufferClass); 2762 directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass); 2763 2764 // Get needed field and method IDs 2765 directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V"); 2766 directBufferAddressField = env->GetFieldID(bufferClass, "address", "J"); 2767 bufferCapacityField = env->GetFieldID(bufferClass, "capacity", "I"); 2768 2769 if ((directByteBufferConstructor == NULL) || 2770 (directBufferAddressField == NULL) || 2771 (bufferCapacityField == NULL)) { 2772 directBufferSupportInitializeFailed = 1; 2773 return false; 2774 } 2775 2776 directBufferSupportInitializeEnded = 1; 2777 } else { 2778 while (!directBufferSupportInitializeEnded && !directBufferSupportInitializeFailed) { 2779 // Set state as yield_all can call os:sleep. On Solaris, yield_all calls 2780 // os::sleep which requires the VM state transition. On other platforms, it 2781 // is not necessary. The following call to change the VM state is purposely 2782 // put inside the loop to avoid potential deadlock when multiple threads 2783 // try to call this method. See 6791815 for more details. 2784 ThreadInVMfromNative tivn(thread); 2785 os::yield_all(); 2786 } 2787 } 2788 2789 return !directBufferSupportInitializeFailed; 2790 } 2791 2792 extern "C" jobject JNICALL jni_NewDirectByteBuffer(JNIEnv *env, void* address, jlong capacity) 2793 { 2794 // thread_from_jni_environment() will block if VM is gone. 2795 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 2796 2797 JNIWrapper("jni_NewDirectByteBuffer"); 2798 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); 2799 2800 if (!directBufferSupportInitializeEnded) { 2801 if (!initializeDirectBufferSupport(env, thread)) { 2802 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); 2803 return NULL; 2804 } 2805 } 2806 2807 // Being paranoid about accidental sign extension on address 2808 jlong addr = (jlong) ((uintptr_t) address); 2809 // NOTE that package-private DirectByteBuffer constructor currently 2810 // takes int capacity 2811 jint cap = (jint) capacity; 2812 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); 2813 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); 2814 return ret; 2815 } 2816 2817 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*); 2818 2819 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) 2820 { 2821 // thread_from_jni_environment() will block if VM is gone. 2822 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 2823 2824 JNIWrapper("jni_GetDirectBufferAddress"); 2825 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); 2826 void* ret = NULL; 2827 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); 2828 2829 if (!directBufferSupportInitializeEnded) { 2830 if (!initializeDirectBufferSupport(env, thread)) { 2831 return 0; 2832 } 2833 } 2834 2835 if ((buf != NULL) && (!env->IsInstanceOf(buf, directBufferClass))) { 2836 return 0; 2837 } 2838 2839 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); 2840 return ret; 2841 } 2842 2843 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong); 2844 2845 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) 2846 { 2847 // thread_from_jni_environment() will block if VM is gone. 2848 JavaThread* thread = JavaThread::thread_from_jni_environment(env); 2849 2850 JNIWrapper("jni_GetDirectBufferCapacity"); 2851 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf); 2852 jlong ret = -1; 2853 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); 2854 2855 if (!directBufferSupportInitializeEnded) { 2856 if (!initializeDirectBufferSupport(env, thread)) { 2857 ret = 0; 2858 return ret; 2859 } 2860 } 2861 2862 if (buf == NULL) { 2863 return -1; 2864 } 2865 2866 if (!env->IsInstanceOf(buf, directBufferClass)) { 2867 return -1; 2868 } 2869 2870 // NOTE that capacity is currently an int in the implementation 2871 ret = env->GetIntField(buf, bufferCapacityField); 2872 return ret; 2873 } 2874 2875 2876 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) 2877 JNIWrapper("GetVersion"); 2878 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env); 2879 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion); 2880 return CurrentVersion; 2881 JNI_END 2882 2883 extern struct JavaVM_ main_vm; 2884 2885 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) 2886 JNIWrapper("jni_GetJavaVM"); 2887 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm); 2888 *vm = (JavaVM *)(&main_vm); 2889 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK); 2890 return JNI_OK; 2891 JNI_END 2892 2893 // Structure containing all jni functions 2894 struct JNINativeInterface_ jni_NativeInterface = { 2895 NULL, 2896 NULL, 2897 NULL, 2898 2899 NULL, 2900 2901 jni_GetVersion, 2902 2903 jni_DefineClass, 2904 jni_FindClass, 2905 2906 jni_FromReflectedMethod, 2907 jni_FromReflectedField, 2908 2909 jni_ToReflectedMethod, 2910 2911 jni_GetSuperclass, 2912 jni_IsAssignableFrom, 2913 2914 jni_ToReflectedField, 2915 2916 jni_Throw, 2917 jni_ThrowNew, 2918 jni_ExceptionOccurred, 2919 jni_ExceptionDescribe, 2920 jni_ExceptionClear, 2921 jni_FatalError, 2922 2923 jni_PushLocalFrame, 2924 jni_PopLocalFrame, 2925 2926 jni_NewGlobalRef, 2927 jni_DeleteGlobalRef, 2928 jni_DeleteLocalRef, 2929 jni_IsSameObject, 2930 2931 jni_NewLocalRef, 2932 jni_EnsureLocalCapacity, 2933 2934 jni_AllocObject, 2935 jni_NewObject, 2936 jni_NewObjectV, 2937 jni_NewObjectA, 2938 2939 jni_GetObjectClass, 2940 jni_IsInstanceOf, 2941 2942 jni_GetMethodID, 2943 2944 jni_CallObjectMethod, 2945 jni_CallObjectMethodV, 2946 jni_CallObjectMethodA, 2947 jni_CallBooleanMethod, 2948 jni_CallBooleanMethodV, 2949 jni_CallBooleanMethodA, 2950 jni_CallByteMethod, 2951 jni_CallByteMethodV, 2952 jni_CallByteMethodA, 2953 jni_CallCharMethod, 2954 jni_CallCharMethodV, 2955 jni_CallCharMethodA, 2956 jni_CallShortMethod, 2957 jni_CallShortMethodV, 2958 jni_CallShortMethodA, 2959 jni_CallIntMethod, 2960 jni_CallIntMethodV, 2961 jni_CallIntMethodA, 2962 jni_CallLongMethod, 2963 jni_CallLongMethodV, 2964 jni_CallLongMethodA, 2965 jni_CallFloatMethod, 2966 jni_CallFloatMethodV, 2967 jni_CallFloatMethodA, 2968 jni_CallDoubleMethod, 2969 jni_CallDoubleMethodV, 2970 jni_CallDoubleMethodA, 2971 jni_CallVoidMethod, 2972 jni_CallVoidMethodV, 2973 jni_CallVoidMethodA, 2974 2975 jni_CallNonvirtualObjectMethod, 2976 jni_CallNonvirtualObjectMethodV, 2977 jni_CallNonvirtualObjectMethodA, 2978 jni_CallNonvirtualBooleanMethod, 2979 jni_CallNonvirtualBooleanMethodV, 2980 jni_CallNonvirtualBooleanMethodA, 2981 jni_CallNonvirtualByteMethod, 2982 jni_CallNonvirtualByteMethodV, 2983 jni_CallNonvirtualByteMethodA, 2984 jni_CallNonvirtualCharMethod, 2985 jni_CallNonvirtualCharMethodV, 2986 jni_CallNonvirtualCharMethodA, 2987 jni_CallNonvirtualShortMethod, 2988 jni_CallNonvirtualShortMethodV, 2989 jni_CallNonvirtualShortMethodA, 2990 jni_CallNonvirtualIntMethod, 2991 jni_CallNonvirtualIntMethodV, 2992 jni_CallNonvirtualIntMethodA, 2993 jni_CallNonvirtualLongMethod, 2994 jni_CallNonvirtualLongMethodV, 2995 jni_CallNonvirtualLongMethodA, 2996 jni_CallNonvirtualFloatMethod, 2997 jni_CallNonvirtualFloatMethodV, 2998 jni_CallNonvirtualFloatMethodA, 2999 jni_CallNonvirtualDoubleMethod, 3000 jni_CallNonvirtualDoubleMethodV, 3001 jni_CallNonvirtualDoubleMethodA, 3002 jni_CallNonvirtualVoidMethod, 3003 jni_CallNonvirtualVoidMethodV, 3004 jni_CallNonvirtualVoidMethodA, 3005 3006 jni_GetFieldID, 3007 3008 jni_GetObjectField, 3009 jni_GetBooleanField, 3010 jni_GetByteField, 3011 jni_GetCharField, 3012 jni_GetShortField, 3013 jni_GetIntField, 3014 jni_GetLongField, 3015 jni_GetFloatField, 3016 jni_GetDoubleField, 3017 3018 jni_SetObjectField, 3019 jni_SetBooleanField, 3020 jni_SetByteField, 3021 jni_SetCharField, 3022 jni_SetShortField, 3023 jni_SetIntField, 3024 jni_SetLongField, 3025 jni_SetFloatField, 3026 jni_SetDoubleField, 3027 3028 jni_GetStaticMethodID, 3029 3030 jni_CallStaticObjectMethod, 3031 jni_CallStaticObjectMethodV, 3032 jni_CallStaticObjectMethodA, 3033 jni_CallStaticBooleanMethod, 3034 jni_CallStaticBooleanMethodV, 3035 jni_CallStaticBooleanMethodA, 3036 jni_CallStaticByteMethod, 3037 jni_CallStaticByteMethodV, 3038 jni_CallStaticByteMethodA, 3039 jni_CallStaticCharMethod, 3040 jni_CallStaticCharMethodV, 3041 jni_CallStaticCharMethodA, 3042 jni_CallStaticShortMethod, 3043 jni_CallStaticShortMethodV, 3044 jni_CallStaticShortMethodA, 3045 jni_CallStaticIntMethod, 3046 jni_CallStaticIntMethodV, 3047 jni_CallStaticIntMethodA, 3048 jni_CallStaticLongMethod, 3049 jni_CallStaticLongMethodV, 3050 jni_CallStaticLongMethodA, 3051 jni_CallStaticFloatMethod, 3052 jni_CallStaticFloatMethodV, 3053 jni_CallStaticFloatMethodA, 3054 jni_CallStaticDoubleMethod, 3055 jni_CallStaticDoubleMethodV, 3056 jni_CallStaticDoubleMethodA, 3057 jni_CallStaticVoidMethod, 3058 jni_CallStaticVoidMethodV, 3059 jni_CallStaticVoidMethodA, 3060 3061 jni_GetStaticFieldID, 3062 3063 jni_GetStaticObjectField, 3064 jni_GetStaticBooleanField, 3065 jni_GetStaticByteField, 3066 jni_GetStaticCharField, 3067 jni_GetStaticShortField, 3068 jni_GetStaticIntField, 3069 jni_GetStaticLongField, 3070 jni_GetStaticFloatField, 3071 jni_GetStaticDoubleField, 3072 3073 jni_SetStaticObjectField, 3074 jni_SetStaticBooleanField, 3075 jni_SetStaticByteField, 3076 jni_SetStaticCharField, 3077 jni_SetStaticShortField, 3078 jni_SetStaticIntField, 3079 jni_SetStaticLongField, 3080 jni_SetStaticFloatField, 3081 jni_SetStaticDoubleField, 3082 3083 jni_NewString, 3084 jni_GetStringLength, 3085 jni_GetStringChars, 3086 jni_ReleaseStringChars, 3087 3088 jni_NewStringUTF, 3089 jni_GetStringUTFLength, 3090 jni_GetStringUTFChars, 3091 jni_ReleaseStringUTFChars, 3092 3093 jni_GetArrayLength, 3094 3095 jni_NewObjectArray, 3096 jni_GetObjectArrayElement, 3097 jni_SetObjectArrayElement, 3098 3099 jni_NewBooleanArray, 3100 jni_NewByteArray, 3101 jni_NewCharArray, 3102 jni_NewShortArray, 3103 jni_NewIntArray, 3104 jni_NewLongArray, 3105 jni_NewFloatArray, 3106 jni_NewDoubleArray, 3107 3108 jni_GetBooleanArrayElements, 3109 jni_GetByteArrayElements, 3110 jni_GetCharArrayElements, 3111 jni_GetShortArrayElements, 3112 jni_GetIntArrayElements, 3113 jni_GetLongArrayElements, 3114 jni_GetFloatArrayElements, 3115 jni_GetDoubleArrayElements, 3116 3117 jni_ReleaseBooleanArrayElements, 3118 jni_ReleaseByteArrayElements, 3119 jni_ReleaseCharArrayElements, 3120 jni_ReleaseShortArrayElements, 3121 jni_ReleaseIntArrayElements, 3122 jni_ReleaseLongArrayElements, 3123 jni_ReleaseFloatArrayElements, 3124 jni_ReleaseDoubleArrayElements, 3125 3126 jni_GetBooleanArrayRegion, 3127 jni_GetByteArrayRegion, 3128 jni_GetCharArrayRegion, 3129 jni_GetShortArrayRegion, 3130 jni_GetIntArrayRegion, 3131 jni_GetLongArrayRegion, 3132 jni_GetFloatArrayRegion, 3133 jni_GetDoubleArrayRegion, 3134 3135 jni_SetBooleanArrayRegion, 3136 jni_SetByteArrayRegion, 3137 jni_SetCharArrayRegion, 3138 jni_SetShortArrayRegion, 3139 jni_SetIntArrayRegion, 3140 jni_SetLongArrayRegion, 3141 jni_SetFloatArrayRegion, 3142 jni_SetDoubleArrayRegion, 3143 3144 jni_RegisterNatives, 3145 jni_UnregisterNatives, 3146 3147 jni_MonitorEnter, 3148 jni_MonitorExit, 3149 3150 jni_GetJavaVM, 3151 3152 jni_GetStringRegion, 3153 jni_GetStringUTFRegion, 3154 3155 jni_GetPrimitiveArrayCritical, 3156 jni_ReleasePrimitiveArrayCritical, 3157 3158 jni_GetStringCritical, 3159 jni_ReleaseStringCritical, 3160 3161 jni_NewWeakGlobalRef, 3162 jni_DeleteWeakGlobalRef, 3163 3164 jni_ExceptionCheck, 3165 3166 jni_NewDirectByteBuffer, 3167 jni_GetDirectBufferAddress, 3168 jni_GetDirectBufferCapacity, 3169 3170 // New 1_6 features 3171 3172 jni_GetObjectRefType 3173 }; 3174 3175 3176 // For jvmti use to modify jni function table. 3177 // Java threads in native contiues to run until it is transitioned 3178 // to VM at safepoint. Before the transition or before it is blocked 3179 // for safepoint it may access jni function table. VM could crash if 3180 // any java thread access the jni function table in the middle of memcpy. 3181 // To avoid this each function pointers are copied automically. 3182 void copy_jni_function_table(const struct JNINativeInterface_ *new_jni_NativeInterface) { 3183 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); 3184 intptr_t *a = (intptr_t *) jni_functions(); 3185 intptr_t *b = (intptr_t *) new_jni_NativeInterface; 3186 for (uint i=0; i < sizeof(struct JNINativeInterface_)/sizeof(void *); i++) { 3187 Atomic::store_ptr(*b++, a++); 3188 } 3189 } 3190 3191 void quicken_jni_functions() { 3192 // Replace Get<Primitive>Field with fast versions 3193 if (UseFastJNIAccessors && !JvmtiExport::can_post_field_access() 3194 && !VerifyJNIFields && !TraceJNICalls && !CountJNICalls && !CheckJNICalls 3195 #if defined(_WINDOWS) && defined(IA32) && defined(COMPILER2) 3196 // windows x86 currently needs SEH wrapper and the gain of the fast 3197 // versions currently isn't certain for server vm on uniprocessor. 3198 && os::is_MP() 3199 #endif 3200 ) { 3201 address func; 3202 func = JNI_FastGetField::generate_fast_get_boolean_field(); 3203 if (func != (address)-1) { 3204 jni_NativeInterface.GetBooleanField = (GetBooleanField_t)func; 3205 } 3206 func = JNI_FastGetField::generate_fast_get_byte_field(); 3207 if (func != (address)-1) { 3208 jni_NativeInterface.GetByteField = (GetByteField_t)func; 3209 } 3210 func = JNI_FastGetField::generate_fast_get_char_field(); 3211 if (func != (address)-1) { 3212 jni_NativeInterface.GetCharField = (GetCharField_t)func; 3213 } 3214 func = JNI_FastGetField::generate_fast_get_short_field(); 3215 if (func != (address)-1) { 3216 jni_NativeInterface.GetShortField = (GetShortField_t)func; 3217 } 3218 func = JNI_FastGetField::generate_fast_get_int_field(); 3219 if (func != (address)-1) { 3220 jni_NativeInterface.GetIntField = (GetIntField_t)func; 3221 } 3222 func = JNI_FastGetField::generate_fast_get_long_field(); 3223 if (func != (address)-1) { 3224 jni_NativeInterface.GetLongField = (GetLongField_t)func; 3225 } 3226 func = JNI_FastGetField::generate_fast_get_float_field(); 3227 if (func != (address)-1) { 3228 jni_NativeInterface.GetFloatField = (GetFloatField_t)func; 3229 } 3230 func = JNI_FastGetField::generate_fast_get_double_field(); 3231 if (func != (address)-1) { 3232 jni_NativeInterface.GetDoubleField = (GetDoubleField_t)func; 3233 } 3234 } 3235 } 3236 3237 // Returns the function structure 3238 struct JNINativeInterface_* jni_functions() { 3239 #ifndef JNICHECK_KERNEL 3240 if (CheckJNICalls) return jni_functions_check(); 3241 #else // JNICHECK_KERNEL 3242 if (CheckJNICalls) warning("-Xcheck:jni is not supported in kernel vm."); 3243 #endif // JNICHECK_KERNEL 3244 return &jni_NativeInterface; 3245 } 3246 3247 // Returns the function structure 3248 struct JNINativeInterface_* jni_functions_nocheck() { 3249 return &jni_NativeInterface; 3250 } 3251 3252 3253 // Invocation API 3254 3255 3256 // Forward declaration 3257 extern const struct JNIInvokeInterface_ jni_InvokeInterface; 3258 3259 // Global invocation API vars 3260 volatile jint vm_created = 0; 3261 // Indicate whether it is safe to recreate VM 3262 volatile jint safe_to_recreate_vm = 1; 3263 struct JavaVM_ main_vm = {&jni_InvokeInterface}; 3264 3265 3266 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */ 3267 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL }; 3268 3269 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*); 3270 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint); 3271 3272 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) { 3273 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_); 3274 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_; 3275 jint ret = JNI_ERR; 3276 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret); 3277 3278 if (Threads::is_supported_jni_version(args->version)) { 3279 ret = JNI_OK; 3280 } 3281 // 1.1 style no longer supported in hotspot. 3282 // According the JNI spec, we should update args->version on return. 3283 // We also use the structure to communicate with launcher about default 3284 // stack size. 3285 if (args->version == JNI_VERSION_1_1) { 3286 args->version = JNI_VERSION_1_2; 3287 // javaStackSize is int in arguments structure 3288 assert(jlong(ThreadStackSize) * K < INT_MAX, "integer overflow"); 3289 args->javaStackSize = (jint)(ThreadStackSize * K); 3290 } 3291 return ret; 3292 } 3293 3294 #ifndef PRODUCT 3295 3296 #include "utilities/quickSort.hpp" 3297 3298 void execute_internal_vm_tests() { 3299 if (ExecuteInternalVMTests) { 3300 assert(QuickSort::test_quick_sort(), "test_quick_sort failed"); 3301 tty->print_cr("All tests passed"); 3302 } 3303 } 3304 3305 #endif 3306 3307 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); 3308 DT_RETURN_MARK_DECL(CreateJavaVM, jint); 3309 3310 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) { 3311 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); 3312 3313 jint result = JNI_ERR; 3314 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result); 3315 3316 // We're about to use Atomic::xchg for synchronization. Some Zero 3317 // platforms use the GCC builtin __sync_lock_test_and_set for this, 3318 // but __sync_lock_test_and_set is not guaranteed to do what we want 3319 // on all architectures. So we check it works before relying on it. 3320 #if defined(ZERO) && defined(ASSERT) 3321 { 3322 jint a = 0xcafebabe; 3323 jint b = Atomic::xchg(0xdeadbeef, &a); 3324 void *c = &a; 3325 void *d = Atomic::xchg_ptr(&b, &c); 3326 assert(a == (jint) 0xdeadbeef && b == (jint) 0xcafebabe, "Atomic::xchg() works"); 3327 assert(c == &b && d == &a, "Atomic::xchg_ptr() works"); 3328 } 3329 #endif // ZERO && ASSERT 3330 3331 // At the moment it's only possible to have one Java VM, 3332 // since some of the runtime state is in global variables. 3333 3334 // We cannot use our mutex locks here, since they only work on 3335 // Threads. We do an atomic compare and exchange to ensure only 3336 // one thread can call this method at a time 3337 3338 // We use Atomic::xchg rather than Atomic::add/dec since on some platforms 3339 // the add/dec implementations are dependent on whether we are running 3340 // on a multiprocessor, and at this stage of initialization the os::is_MP 3341 // function used to determine this will always return false. Atomic::xchg 3342 // does not have this problem. 3343 if (Atomic::xchg(1, &vm_created) == 1) { 3344 return JNI_ERR; // already created, or create attempt in progress 3345 } 3346 if (Atomic::xchg(0, &safe_to_recreate_vm) == 0) { 3347 return JNI_ERR; // someone tried and failed and retry not allowed. 3348 } 3349 3350 assert(vm_created == 1, "vm_created is true during the creation"); 3351 3352 /** 3353 * Certain errors during initialization are recoverable and do not 3354 * prevent this method from being called again at a later time 3355 * (perhaps with different arguments). However, at a certain 3356 * point during initialization if an error occurs we cannot allow 3357 * this function to be called again (or it will crash). In those 3358 * situations, the 'canTryAgain' flag is set to false, which atomically 3359 * sets safe_to_recreate_vm to 1, such that any new call to 3360 * JNI_CreateJavaVM will immediately fail using the above logic. 3361 */ 3362 bool can_try_again = true; 3363 3364 result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again); 3365 if (result == JNI_OK) { 3366 JavaThread *thread = JavaThread::current(); 3367 /* thread is thread_in_vm here */ 3368 *vm = (JavaVM *)(&main_vm); 3369 *(JNIEnv**)penv = thread->jni_environment(); 3370 3371 // Tracks the time application was running before GC 3372 RuntimeService::record_application_start(); 3373 3374 // Notify JVMTI 3375 if (JvmtiExport::should_post_thread_life()) { 3376 JvmtiExport::post_thread_start(thread); 3377 } 3378 // Check if we should compile all classes on bootclasspath 3379 NOT_PRODUCT(if (CompileTheWorld) ClassLoader::compile_the_world();) 3380 // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving. 3381 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native); 3382 } else { 3383 if (can_try_again) { 3384 // reset safe_to_recreate_vm to 1 so that retrial would be possible 3385 safe_to_recreate_vm = 1; 3386 } 3387 3388 // Creation failed. We must reset vm_created 3389 *vm = 0; 3390 *(JNIEnv**)penv = 0; 3391 // reset vm_created last to avoid race condition. Use OrderAccess to 3392 // control both compiler and architectural-based reordering. 3393 OrderAccess::release_store(&vm_created, 0); 3394 } 3395 3396 NOT_PRODUCT(test_error_handler(ErrorHandlerTest)); 3397 NOT_PRODUCT(execute_internal_vm_tests()); 3398 return result; 3399 } 3400 3401 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \ 3402 JavaVM**, jsize, jsize*); 3403 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint); 3404 3405 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { 3406 // See bug 4367188, the wrapper can sometimes cause VM crashes 3407 // JNIWrapper("GetCreatedJavaVMs"); 3408 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ 3409 vm_buf, bufLen, numVMs); 3410 if (vm_created) { 3411 if (numVMs != NULL) *numVMs = 1; 3412 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); 3413 } else { 3414 if (numVMs != NULL) *numVMs = 0; 3415 } 3416 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); 3417 return JNI_OK; 3418 } 3419 3420 extern "C" { 3421 3422 DT_RETURN_MARK_DECL(DestroyJavaVM, jint); 3423 3424 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { 3425 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); 3426 jint res = JNI_ERR; 3427 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); 3428 3429 if (!vm_created) { 3430 res = JNI_ERR; 3431 return res; 3432 } 3433 3434 JNIWrapper("DestroyJavaVM"); 3435 JNIEnv *env; 3436 JavaVMAttachArgs destroyargs; 3437 destroyargs.version = CurrentVersion; 3438 destroyargs.name = (char *)"DestroyJavaVM"; 3439 destroyargs.group = NULL; 3440 res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs); 3441 if (res != JNI_OK) { 3442 return res; 3443 } 3444 3445 // Since this is not a JVM_ENTRY we have to set the thread state manually before entering. 3446 JavaThread* thread = JavaThread::current(); 3447 ThreadStateTransition::transition_from_native(thread, _thread_in_vm); 3448 if (Threads::destroy_vm()) { 3449 // Should not change thread state, VM is gone 3450 vm_created = false; 3451 res = JNI_OK; 3452 return res; 3453 } else { 3454 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native); 3455 res = JNI_ERR; 3456 return res; 3457 } 3458 } 3459 3460 3461 static jint attach_current_thread(JavaVM *vm, void **penv, void *_args, bool daemon) { 3462 JavaVMAttachArgs *args = (JavaVMAttachArgs *) _args; 3463 3464 // Check below commented out from JDK1.2fcs as well 3465 /* 3466 if (args && (args->version != JNI_VERSION_1_1 || args->version != JNI_VERSION_1_2)) { 3467 return JNI_EVERSION; 3468 } 3469 */ 3470 3471 Thread* t = ThreadLocalStorage::get_thread_slow(); 3472 if (t != NULL) { 3473 // If the thread has been attached this operation is a no-op 3474 *(JNIEnv**)penv = ((JavaThread*) t)->jni_environment(); 3475 return JNI_OK; 3476 } 3477 3478 // Create a thread and mark it as attaching so it will be skipped by the 3479 // ThreadsListEnumerator - see CR 6404306 3480 JavaThread* thread = new JavaThread(true); 3481 3482 // Set correct safepoint info. The thread is going to call into Java when 3483 // initializing the Java level thread object. Hence, the correct state must 3484 // be set in order for the Safepoint code to deal with it correctly. 3485 thread->set_thread_state(_thread_in_vm); 3486 // Must do this before initialize_thread_local_storage 3487 thread->record_stack_base_and_size(); 3488 3489 thread->initialize_thread_local_storage(); 3490 3491 if (!os::create_attached_thread(thread)) { 3492 delete thread; 3493 return JNI_ERR; 3494 } 3495 // Enable stack overflow checks 3496 thread->create_stack_guard_pages(); 3497 3498 thread->initialize_tlab(); 3499 3500 thread->cache_global_variables(); 3501 3502 // Crucial that we do not have a safepoint check for this thread, since it has 3503 // not been added to the Thread list yet. 3504 { Threads_lock->lock_without_safepoint_check(); 3505 // This must be inside this lock in order to get FullGCALot to work properly, i.e., to 3506 // avoid this thread trying to do a GC before it is added to the thread-list 3507 thread->set_active_handles(JNIHandleBlock::allocate_block()); 3508 Threads::add(thread, daemon); 3509 Threads_lock->unlock(); 3510 } 3511 // Create thread group and name info from attach arguments 3512 oop group = NULL; 3513 char* thread_name = NULL; 3514 if (args != NULL && Threads::is_supported_jni_version(args->version)) { 3515 group = JNIHandles::resolve(args->group); 3516 thread_name = args->name; // may be NULL 3517 } 3518 if (group == NULL) group = Universe::main_thread_group(); 3519 3520 // Create Java level thread object and attach it to this thread 3521 bool attach_failed = false; 3522 { 3523 EXCEPTION_MARK; 3524 HandleMark hm(THREAD); 3525 Handle thread_group(THREAD, group); 3526 thread->allocate_threadObj(thread_group, thread_name, daemon, THREAD); 3527 if (HAS_PENDING_EXCEPTION) { 3528 CLEAR_PENDING_EXCEPTION; 3529 // cleanup outside the handle mark. 3530 attach_failed = true; 3531 } 3532 } 3533 3534 if (attach_failed) { 3535 // Added missing cleanup 3536 thread->cleanup_failed_attach_current_thread(); 3537 return JNI_ERR; 3538 } 3539 3540 // mark the thread as no longer attaching 3541 // this uses a fence to push the change through so we don't have 3542 // to regrab the threads_lock 3543 thread->set_attached(); 3544 3545 // Set java thread status. 3546 java_lang_Thread::set_thread_status(thread->threadObj(), 3547 java_lang_Thread::RUNNABLE); 3548 3549 // Notify the debugger 3550 if (JvmtiExport::should_post_thread_life()) { 3551 JvmtiExport::post_thread_start(thread); 3552 } 3553 3554 *(JNIEnv**)penv = thread->jni_environment(); 3555 3556 // Now leaving the VM, so change thread_state. This is normally automatically taken care 3557 // of in the JVM_ENTRY. But in this situation we have to do it manually. Notice, that by 3558 // using ThreadStateTransition::transition, we do a callback to the safepoint code if 3559 // needed. 3560 3561 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native); 3562 3563 // Perform any platform dependent FPU setup 3564 os::setup_fpu(); 3565 3566 return JNI_OK; 3567 } 3568 3569 3570 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { 3571 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); 3572 if (!vm_created) { 3573 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); 3574 return JNI_ERR; 3575 } 3576 3577 JNIWrapper("AttachCurrentThread"); 3578 jint ret = attach_current_thread(vm, penv, _args, false); 3579 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); 3580 return ret; 3581 } 3582 3583 3584 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { 3585 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); 3586 VM_Exit::block_if_vm_exited(); 3587 3588 JNIWrapper("DetachCurrentThread"); 3589 3590 // If the thread has been deattacted the operations is a no-op 3591 if (ThreadLocalStorage::thread() == NULL) { 3592 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); 3593 return JNI_OK; 3594 } 3595 3596 JavaThread* thread = JavaThread::current(); 3597 if (thread->has_last_Java_frame()) { 3598 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); 3599 // Can't detach a thread that's running java, that can't work. 3600 return JNI_ERR; 3601 } 3602 3603 // Safepoint support. Have to do call-back to safepoint code, if in the 3604 // middel of a safepoint operation 3605 ThreadStateTransition::transition_from_native(thread, _thread_in_vm); 3606 3607 // XXX: Note that JavaThread::exit() call below removes the guards on the 3608 // stack pages set up via enable_stack_{red,yellow}_zone() calls 3609 // above in jni_AttachCurrentThread. Unfortunately, while the setting 3610 // of the guards is visible in jni_AttachCurrentThread above, 3611 // the removal of the guards is buried below in JavaThread::exit() 3612 // here. The abstraction should be more symmetrically either exposed 3613 // or hidden (e.g. it could probably be hidden in the same 3614 // (platform-dependent) methods where we do alternate stack 3615 // maintenance work?) 3616 thread->exit(false, JavaThread::jni_detach); 3617 delete thread; 3618 3619 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); 3620 return JNI_OK; 3621 } 3622 3623 DT_RETURN_MARK_DECL(GetEnv, jint); 3624 3625 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) { 3626 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version); 3627 jint ret = JNI_ERR; 3628 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret); 3629 3630 if (!vm_created) { 3631 *penv = NULL; 3632 ret = JNI_EDETACHED; 3633 return ret; 3634 } 3635 3636 if (JvmtiExport::is_jvmti_version(version)) { 3637 ret = JvmtiExport::get_jvmti_interface(vm, penv, version); 3638 return ret; 3639 } 3640 3641 #ifndef JVMPI_VERSION_1 3642 // need these in order to be polite about older agents 3643 #define JVMPI_VERSION_1 ((jint)0x10000001) 3644 #define JVMPI_VERSION_1_1 ((jint)0x10000002) 3645 #define JVMPI_VERSION_1_2 ((jint)0x10000003) 3646 #endif // !JVMPI_VERSION_1 3647 3648 Thread* thread = ThreadLocalStorage::thread(); 3649 if (thread != NULL && thread->is_Java_thread()) { 3650 if (Threads::is_supported_jni_version_including_1_1(version)) { 3651 *(JNIEnv**)penv = ((JavaThread*) thread)->jni_environment(); 3652 ret = JNI_OK; 3653 return ret; 3654 3655 } else if (version == JVMPI_VERSION_1 || 3656 version == JVMPI_VERSION_1_1 || 3657 version == JVMPI_VERSION_1_2) { 3658 tty->print_cr("ERROR: JVMPI, an experimental interface, is no longer supported."); 3659 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI)."); 3660 ret = JNI_EVERSION; 3661 return ret; 3662 } else if (JvmtiExport::is_jvmdi_version(version)) { 3663 tty->print_cr("FATAL ERROR: JVMDI is no longer supported."); 3664 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI)."); 3665 ret = JNI_EVERSION; 3666 return ret; 3667 } else { 3668 *penv = NULL; 3669 ret = JNI_EVERSION; 3670 return ret; 3671 } 3672 } else { 3673 *penv = NULL; 3674 ret = JNI_EDETACHED; 3675 return ret; 3676 } 3677 } 3678 3679 3680 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) { 3681 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args); 3682 if (!vm_created) { 3683 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR); 3684 return JNI_ERR; 3685 } 3686 3687 JNIWrapper("AttachCurrentThreadAsDaemon"); 3688 jint ret = attach_current_thread(vm, penv, _args, true); 3689 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret); 3690 return ret; 3691 } 3692 3693 3694 } // End extern "C" 3695 3696 const struct JNIInvokeInterface_ jni_InvokeInterface = { 3697 NULL, 3698 NULL, 3699 NULL, 3700 3701 jni_DestroyJavaVM, 3702 jni_AttachCurrentThread, 3703 jni_DetachCurrentThread, 3704 jni_GetEnv, 3705 jni_AttachCurrentThreadAsDaemon 3706 };