jvm.cpp revision 356:1ee8caae33af
1/* 2 * Copyright 1997-2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 20 * CA 95054 USA or visit www.sun.com if you need additional information or 21 * have any questions. 22 * 23 */ 24 25#include "incls/_precompiled.incl" 26#include "incls/_jvm.cpp.incl" 27#include <errno.h> 28 29/* 30 NOTE about use of any ctor or function call that can trigger a safepoint/GC: 31 such ctors and calls MUST NOT come between an oop declaration/init and its 32 usage because if objects are move this may cause various memory stomps, bus 33 errors and segfaults. Here is a cookbook for causing so called "naked oop 34 failures": 35 36 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> { 37 JVMWrapper("JVM_GetClassDeclaredFields"); 38 39 // Object address to be held directly in mirror & not visible to GC 40 oop mirror = JNIHandles::resolve_non_null(ofClass); 41 42 // If this ctor can hit a safepoint, moving objects around, then 43 ComplexConstructor foo; 44 45 // Boom! mirror may point to JUNK instead of the intended object 46 (some dereference of mirror) 47 48 // Here's another call that may block for GC, making mirror stale 49 MutexLocker ml(some_lock); 50 51 // And here's an initializer that can result in a stale oop 52 // all in one step. 53 oop o = call_that_can_throw_exception(TRAPS); 54 55 56 The solution is to keep the oop declaration BELOW the ctor or function 57 call that might cause a GC, do another resolve to reassign the oop, or 58 consider use of a Handle instead of an oop so there is immunity from object 59 motion. But note that the "QUICK" entries below do not have a handlemark 60 and thus can only support use of handles passed in. 61*/ 62 63static void trace_class_resolution_impl(klassOop to_class, TRAPS) { 64 ResourceMark rm; 65 int line_number = -1; 66 const char * source_file = NULL; 67 klassOop caller = NULL; 68 JavaThread* jthread = JavaThread::current(); 69 if (jthread->has_last_Java_frame()) { 70 vframeStream vfst(jthread); 71 72 // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames 73 symbolHandle access_controller = oopFactory::new_symbol_handle("java/security/AccessController", CHECK); 74 klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK); 75 symbolHandle privileged_action = oopFactory::new_symbol_handle("java/security/PrivilegedAction", CHECK); 76 klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK); 77 78 methodOop last_caller = NULL; 79 80 while (!vfst.at_end()) { 81 methodOop m = vfst.method(); 82 if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::classloader_klass())&& 83 !vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) && 84 !vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) { 85 break; 86 } 87 last_caller = m; 88 vfst.next(); 89 } 90 // if this is called from Class.forName0 and that is called from Class.forName, 91 // then print the caller of Class.forName. If this is Class.loadClass, then print 92 // that caller, otherwise keep quiet since this should be picked up elsewhere. 93 bool found_it = false; 94 if (!vfst.at_end() && 95 instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() && 96 vfst.method()->name() == vmSymbols::forName0_name()) { 97 vfst.next(); 98 if (!vfst.at_end() && 99 instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() && 100 vfst.method()->name() == vmSymbols::forName_name()) { 101 vfst.next(); 102 found_it = true; 103 } 104 } else if (last_caller != NULL && 105 instanceKlass::cast(last_caller->method_holder())->name() == 106 vmSymbols::java_lang_ClassLoader() && 107 (last_caller->name() == vmSymbols::loadClassInternal_name() || 108 last_caller->name() == vmSymbols::loadClass_name())) { 109 found_it = true; 110 } 111 if (found_it && !vfst.at_end()) { 112 // found the caller 113 caller = vfst.method()->method_holder(); 114 line_number = vfst.method()->line_number_from_bci(vfst.bci()); 115 symbolOop s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name(); 116 if (s != NULL) { 117 source_file = s->as_C_string(); 118 } 119 } 120 } 121 if (caller != NULL) { 122 if (to_class != caller) { 123 const char * from = Klass::cast(caller)->external_name(); 124 const char * to = Klass::cast(to_class)->external_name(); 125 // print in a single call to reduce interleaving between threads 126 if (source_file != NULL) { 127 tty->print("RESOLVE %s %s %s:%d (explicit)\n", from, to, source_file, line_number); 128 } else { 129 tty->print("RESOLVE %s %s (explicit)\n", from, to); 130 } 131 } 132 } 133} 134 135static void trace_class_resolution(klassOop to_class) { 136 EXCEPTION_MARK; 137 trace_class_resolution_impl(to_class, THREAD); 138 if (HAS_PENDING_EXCEPTION) { 139 CLEAR_PENDING_EXCEPTION; 140 } 141} 142 143// Wrapper to trace JVM functions 144 145#ifdef ASSERT 146 class JVMTraceWrapper : public StackObj { 147 public: 148 JVMTraceWrapper(const char* format, ...) { 149 if (TraceJVMCalls) { 150 va_list ap; 151 va_start(ap, format); 152 tty->print("JVM "); 153 tty->vprint_cr(format, ap); 154 va_end(ap); 155 } 156 } 157 }; 158 159 Histogram* JVMHistogram; 160 volatile jint JVMHistogram_lock = 0; 161 162 class JVMHistogramElement : public HistogramElement { 163 public: 164 JVMHistogramElement(const char* name); 165 }; 166 167 JVMHistogramElement::JVMHistogramElement(const char* elementName) { 168 _name = elementName; 169 uintx count = 0; 170 171 while (Atomic::cmpxchg(1, &JVMHistogram_lock, 0) != 0) { 172 while (OrderAccess::load_acquire(&JVMHistogram_lock) != 0) { 173 count +=1; 174 if ( (WarnOnStalledSpinLock > 0) 175 && (count % WarnOnStalledSpinLock == 0)) { 176 warning("JVMHistogram_lock seems to be stalled"); 177 } 178 } 179 } 180 181 if(JVMHistogram == NULL) 182 JVMHistogram = new Histogram("JVM Call Counts",100); 183 184 JVMHistogram->add_element(this); 185 Atomic::dec(&JVMHistogram_lock); 186 } 187 188 #define JVMCountWrapper(arg) \ 189 static JVMHistogramElement* e = new JVMHistogramElement(arg); \ 190 if (e != NULL) e->increment_count(); // Due to bug in VC++, we need a NULL check here eventhough it should never happen! 191 192 #define JVMWrapper(arg1) JVMCountWrapper(arg1); JVMTraceWrapper(arg1) 193 #define JVMWrapper2(arg1, arg2) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2) 194 #define JVMWrapper3(arg1, arg2, arg3) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3) 195 #define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4) 196#else 197 #define JVMWrapper(arg1) 198 #define JVMWrapper2(arg1, arg2) 199 #define JVMWrapper3(arg1, arg2, arg3) 200 #define JVMWrapper4(arg1, arg2, arg3, arg4) 201#endif 202 203 204// Interface version ///////////////////////////////////////////////////////////////////// 205 206 207JVM_LEAF(jint, JVM_GetInterfaceVersion()) 208 return JVM_INTERFACE_VERSION; 209JVM_END 210 211 212// java.lang.System ////////////////////////////////////////////////////////////////////// 213 214 215JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)) 216 JVMWrapper("JVM_CurrentTimeMillis"); 217 return os::javaTimeMillis(); 218JVM_END 219 220JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored)) 221 JVMWrapper("JVM_NanoTime"); 222 return os::javaTimeNanos(); 223JVM_END 224 225 226JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, 227 jobject dst, jint dst_pos, jint length)) 228 JVMWrapper("JVM_ArrayCopy"); 229 // Check if we have null pointers 230 if (src == NULL || dst == NULL) { 231 THROW(vmSymbols::java_lang_NullPointerException()); 232 } 233 arrayOop s = arrayOop(JNIHandles::resolve_non_null(src)); 234 arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst)); 235 assert(s->is_oop(), "JVM_ArrayCopy: src not an oop"); 236 assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop"); 237 // Do copy 238 Klass::cast(s->klass())->copy_array(s, src_pos, d, dst_pos, length, thread); 239JVM_END 240 241 242static void set_property(Handle props, const char* key, const char* value, TRAPS) { 243 JavaValue r(T_OBJECT); 244 // public synchronized Object put(Object key, Object value); 245 HandleMark hm(THREAD); 246 Handle key_str = java_lang_String::create_from_platform_dependent_str(key, CHECK); 247 Handle value_str = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK); 248 JavaCalls::call_virtual(&r, 249 props, 250 KlassHandle(THREAD, SystemDictionary::properties_klass()), 251 vmSymbolHandles::put_name(), 252 vmSymbolHandles::object_object_object_signature(), 253 key_str, 254 value_str, 255 THREAD); 256} 257 258 259#define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties)); 260 261 262JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties)) 263 JVMWrapper("JVM_InitProperties"); 264 ResourceMark rm; 265 266 Handle props(THREAD, JNIHandles::resolve_non_null(properties)); 267 268 // System property list includes both user set via -D option and 269 // jvm system specific properties. 270 for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) { 271 PUTPROP(props, p->key(), p->value()); 272 } 273 274 // Convert the -XX:MaxDirectMemorySize= command line flag 275 // to the sun.nio.MaxDirectMemorySize property. 276 // Do this after setting user properties to prevent people 277 // from setting the value with a -D option, as requested. 278 { 279 char as_chars[256]; 280 jio_snprintf(as_chars, sizeof(as_chars), INTX_FORMAT, MaxDirectMemorySize); 281 PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars); 282 } 283 284 // JVM monitoring and management support 285 // Add the sun.management.compiler property for the compiler's name 286 { 287#undef CSIZE 288#if defined(_LP64) || defined(_WIN64) 289 #define CSIZE "64-Bit " 290#else 291 #define CSIZE 292#endif // 64bit 293 294#ifdef TIERED 295 const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers"; 296#else 297#if defined(COMPILER1) 298 const char* compiler_name = "HotSpot " CSIZE "Client Compiler"; 299#elif defined(COMPILER2) 300 const char* compiler_name = "HotSpot " CSIZE "Server Compiler"; 301#else 302 const char* compiler_name = ""; 303#endif // compilers 304#endif // TIERED 305 306 if (*compiler_name != '\0' && 307 (Arguments::mode() != Arguments::_int)) { 308 PUTPROP(props, "sun.management.compiler", compiler_name); 309 } 310 } 311 312 return properties; 313JVM_END 314 315 316// java.lang.Runtime ///////////////////////////////////////////////////////////////////////// 317 318extern volatile jint vm_created; 319 320JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code)) 321 if (vm_created != 0 && (code == 0)) { 322 // The VM is about to exit. We call back into Java to check whether finalizers should be run 323 Universe::run_finalizers_on_exit(); 324 } 325 before_exit(thread); 326 vm_exit(code); 327JVM_END 328 329 330JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code)) 331 before_exit(thread); 332 vm_exit(code); 333JVM_END 334 335 336JVM_LEAF(void, JVM_OnExit(void (*func)(void))) 337 register_on_exit_function(func); 338JVM_END 339 340 341JVM_ENTRY_NO_ENV(void, JVM_GC(void)) 342 JVMWrapper("JVM_GC"); 343 if (!DisableExplicitGC) { 344 Universe::heap()->collect(GCCause::_java_lang_system_gc); 345 } 346JVM_END 347 348 349JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void)) 350 JVMWrapper("JVM_MaxObjectInspectionAge"); 351 return Universe::heap()->millis_since_last_gc(); 352JVM_END 353 354 355JVM_LEAF(void, JVM_TraceInstructions(jboolean on)) 356 if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported"); 357JVM_END 358 359 360JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on)) 361 if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported"); 362JVM_END 363 364static inline jlong convert_size_t_to_jlong(size_t val) { 365 // In the 64-bit vm, a size_t can overflow a jlong (which is signed). 366 NOT_LP64 (return (jlong)val;) 367 LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);) 368} 369 370JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void)) 371 JVMWrapper("JVM_TotalMemory"); 372 size_t n = Universe::heap()->capacity(); 373 return convert_size_t_to_jlong(n); 374JVM_END 375 376 377JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void)) 378 JVMWrapper("JVM_FreeMemory"); 379 CollectedHeap* ch = Universe::heap(); 380 size_t n; 381 { 382 MutexLocker x(Heap_lock); 383 n = ch->capacity() - ch->used(); 384 } 385 return convert_size_t_to_jlong(n); 386JVM_END 387 388 389JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void)) 390 JVMWrapper("JVM_MaxMemory"); 391 size_t n = Universe::heap()->max_capacity(); 392 return convert_size_t_to_jlong(n); 393JVM_END 394 395 396JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void)) 397 JVMWrapper("JVM_ActiveProcessorCount"); 398 return os::active_processor_count(); 399JVM_END 400 401 402 403// java.lang.Throwable ////////////////////////////////////////////////////// 404 405 406JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver)) 407 JVMWrapper("JVM_FillInStackTrace"); 408 Handle exception(thread, JNIHandles::resolve_non_null(receiver)); 409 java_lang_Throwable::fill_in_stack_trace(exception); 410JVM_END 411 412 413JVM_ENTRY(void, JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)) 414 JVMWrapper("JVM_PrintStackTrace"); 415 // Note: This is no longer used in Merlin, but we still support it for compatibility. 416 oop exception = JNIHandles::resolve_non_null(receiver); 417 oop stream = JNIHandles::resolve_non_null(printable); 418 java_lang_Throwable::print_stack_trace(exception, stream); 419JVM_END 420 421 422JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)) 423 JVMWrapper("JVM_GetStackTraceDepth"); 424 oop exception = JNIHandles::resolve(throwable); 425 return java_lang_Throwable::get_stack_trace_depth(exception, THREAD); 426JVM_END 427 428 429JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)) 430 JVMWrapper("JVM_GetStackTraceElement"); 431 JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC 432 oop exception = JNIHandles::resolve(throwable); 433 oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL); 434 return JNIHandles::make_local(env, element); 435JVM_END 436 437 438// java.lang.Object /////////////////////////////////////////////// 439 440 441JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle)) 442 JVMWrapper("JVM_IHashCode"); 443 // as implemented in the classic virtual machine; return 0 if object is NULL 444 return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ; 445JVM_END 446 447 448JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)) 449 JVMWrapper("JVM_MonitorWait"); 450 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 451 assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object"); 452 JavaThreadInObjectWaitState jtiows(thread, ms != 0); 453 if (JvmtiExport::should_post_monitor_wait()) { 454 JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms); 455 } 456 ObjectSynchronizer::wait(obj, ms, CHECK); 457JVM_END 458 459 460JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle)) 461 JVMWrapper("JVM_MonitorNotify"); 462 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 463 assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object"); 464 ObjectSynchronizer::notify(obj, CHECK); 465JVM_END 466 467 468JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)) 469 JVMWrapper("JVM_MonitorNotifyAll"); 470 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 471 assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object"); 472 ObjectSynchronizer::notifyall(obj, CHECK); 473JVM_END 474 475 476JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle)) 477 JVMWrapper("JVM_Clone"); 478 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 479 const KlassHandle klass (THREAD, obj->klass()); 480 JvmtiVMObjectAllocEventCollector oam; 481 482#ifdef ASSERT 483 // Just checking that the cloneable flag is set correct 484 if (obj->is_javaArray()) { 485 guarantee(klass->is_cloneable(), "all arrays are cloneable"); 486 } else { 487 guarantee(obj->is_instance(), "should be instanceOop"); 488 bool cloneable = klass->is_subtype_of(SystemDictionary::cloneable_klass()); 489 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag"); 490 } 491#endif 492 493 // Check if class of obj supports the Cloneable interface. 494 // All arrays are considered to be cloneable (See JLS 20.1.5) 495 if (!klass->is_cloneable()) { 496 ResourceMark rm(THREAD); 497 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name()); 498 } 499 500 // Make shallow object copy 501 const int size = obj->size(); 502 oop new_obj = NULL; 503 if (obj->is_javaArray()) { 504 const int length = ((arrayOop)obj())->length(); 505 new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL); 506 } else { 507 new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL); 508 } 509 // 4839641 (4840070): We must do an oop-atomic copy, because if another thread 510 // is modifying a reference field in the clonee, a non-oop-atomic copy might 511 // be suspended in the middle of copying the pointer and end up with parts 512 // of two different pointers in the field. Subsequent dereferences will crash. 513 // 4846409: an oop-copy of objects with long or double fields or arrays of same 514 // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead 515 // of oops. We know objects are aligned on a minimum of an jlong boundary. 516 // The same is true of StubRoutines::object_copy and the various oop_copy 517 // variants, and of the code generated by the inline_native_clone intrinsic. 518 assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned"); 519 Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj, 520 (size_t)align_object_size(size) / HeapWordsPerLong); 521 // Clear the header 522 new_obj->init_mark(); 523 524 // Store check (mark entire object and let gc sort it out) 525 BarrierSet* bs = Universe::heap()->barrier_set(); 526 assert(bs->has_write_region_opt(), "Barrier set does not have write_region"); 527 bs->write_region(MemRegion((HeapWord*)new_obj, size)); 528 529 // Caution: this involves a java upcall, so the clone should be 530 // "gc-robust" by this stage. 531 if (klass->has_finalizer()) { 532 assert(obj->is_instance(), "should be instanceOop"); 533 new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL); 534 } 535 536 return JNIHandles::make_local(env, oop(new_obj)); 537JVM_END 538 539// java.lang.Compiler //////////////////////////////////////////////////// 540 541// The initial cuts of the HotSpot VM will not support JITs, and all existing 542// JITs would need extensive changes to work with HotSpot. The JIT-related JVM 543// functions are all silently ignored unless JVM warnings are printed. 544 545JVM_LEAF(void, JVM_InitializeCompiler (JNIEnv *env, jclass compCls)) 546 if (PrintJVMWarnings) warning("JVM_InitializeCompiler not supported"); 547JVM_END 548 549 550JVM_LEAF(jboolean, JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)) 551 if (PrintJVMWarnings) warning("JVM_IsSilentCompiler not supported"); 552 return JNI_FALSE; 553JVM_END 554 555 556JVM_LEAF(jboolean, JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)) 557 if (PrintJVMWarnings) warning("JVM_CompileClass not supported"); 558 return JNI_FALSE; 559JVM_END 560 561 562JVM_LEAF(jboolean, JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)) 563 if (PrintJVMWarnings) warning("JVM_CompileClasses not supported"); 564 return JNI_FALSE; 565JVM_END 566 567 568JVM_LEAF(jobject, JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)) 569 if (PrintJVMWarnings) warning("JVM_CompilerCommand not supported"); 570 return NULL; 571JVM_END 572 573 574JVM_LEAF(void, JVM_EnableCompiler(JNIEnv *env, jclass compCls)) 575 if (PrintJVMWarnings) warning("JVM_EnableCompiler not supported"); 576JVM_END 577 578 579JVM_LEAF(void, JVM_DisableCompiler(JNIEnv *env, jclass compCls)) 580 if (PrintJVMWarnings) warning("JVM_DisableCompiler not supported"); 581JVM_END 582 583 584 585// Error message support ////////////////////////////////////////////////////// 586 587JVM_LEAF(jint, JVM_GetLastErrorString(char *buf, int len)) 588 JVMWrapper("JVM_GetLastErrorString"); 589 return hpi::lasterror(buf, len); 590JVM_END 591 592 593// java.io.File /////////////////////////////////////////////////////////////// 594 595JVM_LEAF(char*, JVM_NativePath(char* path)) 596 JVMWrapper2("JVM_NativePath (%s)", path); 597 return hpi::native_path(path); 598JVM_END 599 600 601// Misc. class handling /////////////////////////////////////////////////////////// 602 603 604JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth)) 605 JVMWrapper("JVM_GetCallerClass"); 606 klassOop k = thread->security_get_caller_class(depth); 607 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); 608JVM_END 609 610 611JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf)) 612 JVMWrapper("JVM_FindPrimitiveClass"); 613 oop mirror = NULL; 614 BasicType t = name2type(utf); 615 if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) { 616 mirror = Universe::java_mirror(t); 617 } 618 if (mirror == NULL) { 619 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf); 620 } else { 621 return (jclass) JNIHandles::make_local(env, mirror); 622 } 623JVM_END 624 625 626JVM_ENTRY(void, JVM_ResolveClass(JNIEnv* env, jclass cls)) 627 JVMWrapper("JVM_ResolveClass"); 628 if (PrintJVMWarnings) warning("JVM_ResolveClass not implemented"); 629JVM_END 630 631// Rationale behind JVM_FindClassFromBootLoader 632// a> JVM_FindClassFromClassLoader was never exported in the export tables. 633// b> because of (a) java.dll has a direct dependecy on the unexported 634// private symbol "_JVM_FindClassFromClassLoader@20". 635// c> the launcher cannot use the private symbol as it dynamically opens 636// the entry point, so if something changes, the launcher will fail 637// unexpectedly at runtime, it is safest for the launcher to dlopen a 638// stable exported interface. 639// d> re-exporting JVM_FindClassFromClassLoader as public, will cause its 640// signature to change from _JVM_FindClassFromClassLoader@20 to 641// JVM_FindClassFromClassLoader and will not be backward compatible 642// with older JDKs. 643// Thus a public/stable exported entry point is the right solution, 644// public here means public in linker semantics, and is exported only 645// to the JDK, and is not intended to be a public API. 646 647JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env, 648 const char* name, 649 jboolean throwError)) 650 JVMWrapper3("JVM_FindClassFromBootLoader %s throw %s", name, 651 throwError ? "error" : "exception"); 652 return JVM_FindClassFromClassLoader(env, name, JNI_FALSE, 653 (jobject)NULL, throwError); 654JVM_END 655 656JVM_ENTRY(jclass, JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, 657 jboolean init, jobject loader, 658 jboolean throwError)) 659 JVMWrapper3("JVM_FindClassFromClassLoader %s throw %s", name, 660 throwError ? "error" : "exception"); 661 // Java libraries should ensure that name is never null... 662 if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) { 663 // It's impossible to create this class; the name cannot fit 664 // into the constant pool. 665 if (throwError) { 666 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); 667 } else { 668 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), name); 669 } 670 } 671 symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL); 672 Handle h_loader(THREAD, JNIHandles::resolve(loader)); 673 jclass result = find_class_from_class_loader(env, h_name, init, h_loader, 674 Handle(), throwError, thread); 675 676 if (TraceClassResolution && result != NULL) { 677 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result))); 678 } 679 680 return result; 681JVM_END 682 683 684JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name, 685 jboolean init, jclass from)) 686 JVMWrapper2("JVM_FindClassFromClass %s", name); 687 if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) { 688 // It's impossible to create this class; the name cannot fit 689 // into the constant pool. 690 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); 691 } 692 symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL); 693 oop from_class_oop = JNIHandles::resolve(from); 694 klassOop from_class = (from_class_oop == NULL) 695 ? (klassOop)NULL 696 : java_lang_Class::as_klassOop(from_class_oop); 697 oop class_loader = NULL; 698 oop protection_domain = NULL; 699 if (from_class != NULL) { 700 class_loader = Klass::cast(from_class)->class_loader(); 701 protection_domain = Klass::cast(from_class)->protection_domain(); 702 } 703 Handle h_loader(THREAD, class_loader); 704 Handle h_prot (THREAD, protection_domain); 705 jclass result = find_class_from_class_loader(env, h_name, init, h_loader, 706 h_prot, true, thread); 707 708 if (TraceClassResolution && result != NULL) { 709 // this function is generally only used for class loading during verification. 710 ResourceMark rm; 711 oop from_mirror = JNIHandles::resolve_non_null(from); 712 klassOop from_class = java_lang_Class::as_klassOop(from_mirror); 713 const char * from_name = Klass::cast(from_class)->external_name(); 714 715 oop mirror = JNIHandles::resolve_non_null(result); 716 klassOop to_class = java_lang_Class::as_klassOop(mirror); 717 const char * to = Klass::cast(to_class)->external_name(); 718 tty->print("RESOLVE %s %s (verification)\n", from_name, to); 719 } 720 721 return result; 722JVM_END 723 724static void is_lock_held_by_thread(Handle loader, PerfCounter* counter, TRAPS) { 725 if (loader.is_null()) { 726 return; 727 } 728 729 // check whether the current caller thread holds the lock or not. 730 // If not, increment the corresponding counter 731 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader) != 732 ObjectSynchronizer::owner_self) { 733 counter->inc(); 734 } 735} 736 737// common code for JVM_DefineClass() and JVM_DefineClassWithSource() 738static jclass jvm_define_class_common(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source, TRAPS) { 739 740 // Since exceptions can be thrown, class initialization can take place 741 // if name is NULL no check for class name in .class stream has to be made. 742 symbolHandle class_name; 743 if (name != NULL) { 744 const int str_len = (int)strlen(name); 745 if (str_len > symbolOopDesc::max_length()) { 746 // It's impossible to create this class; the name cannot fit 747 // into the constant pool. 748 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name); 749 } 750 class_name = oopFactory::new_symbol_handle(name, str_len, CHECK_NULL); 751 } 752 753 ResourceMark rm(THREAD); 754 ClassFileStream st((u1*) buf, len, (char *)source); 755 Handle class_loader (THREAD, JNIHandles::resolve(loader)); 756 if (UsePerfData) { 757 is_lock_held_by_thread(class_loader, 758 ClassLoader::sync_JVMDefineClassLockFreeCounter(), 759 THREAD); 760 } 761 Handle protection_domain (THREAD, JNIHandles::resolve(pd)); 762 klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, 763 protection_domain, &st, 764 CHECK_NULL); 765 766 if (TraceClassResolution && k != NULL) { 767 trace_class_resolution(k); 768 } 769 770 return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); 771} 772 773 774JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)) 775 JVMWrapper2("JVM_DefineClass %s", name); 776 777 return jvm_define_class_common(env, name, loader, buf, len, pd, "__JVM_DefineClass__", THREAD); 778JVM_END 779 780 781JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)) 782 JVMWrapper2("JVM_DefineClassWithSource %s", name); 783 784 return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD); 785JVM_END 786 787 788JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)) 789 JVMWrapper("JVM_FindLoadedClass"); 790 ResourceMark rm(THREAD); 791 792 Handle h_name (THREAD, JNIHandles::resolve_non_null(name)); 793 Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL); 794 795 const char* str = java_lang_String::as_utf8_string(string()); 796 // Sanity check, don't expect null 797 if (str == NULL) return NULL; 798 799 const int str_len = (int)strlen(str); 800 if (str_len > symbolOopDesc::max_length()) { 801 // It's impossible to create this class; the name cannot fit 802 // into the constant pool. 803 return NULL; 804 } 805 symbolHandle klass_name = oopFactory::new_symbol_handle(str, str_len,CHECK_NULL); 806 807 // Security Note: 808 // The Java level wrapper will perform the necessary security check allowing 809 // us to pass the NULL as the initiating class loader. 810 Handle h_loader(THREAD, JNIHandles::resolve(loader)); 811 if (UsePerfData) { 812 is_lock_held_by_thread(h_loader, 813 ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(), 814 THREAD); 815 } 816 817 klassOop k = SystemDictionary::find_instance_or_array_klass(klass_name, 818 h_loader, 819 Handle(), 820 CHECK_NULL); 821 822 return (k == NULL) ? NULL : 823 (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); 824JVM_END 825 826 827// Reflection support ////////////////////////////////////////////////////////////////////////////// 828 829JVM_ENTRY(jstring, JVM_GetClassName(JNIEnv *env, jclass cls)) 830 assert (cls != NULL, "illegal class"); 831 JVMWrapper("JVM_GetClassName"); 832 JvmtiVMObjectAllocEventCollector oam; 833 ResourceMark rm(THREAD); 834 const char* name; 835 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 836 name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls))); 837 } else { 838 // Consider caching interned string in Klass 839 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); 840 assert(k->is_klass(), "just checking"); 841 name = Klass::cast(k)->external_name(); 842 } 843 oop result = StringTable::intern((char*) name, CHECK_NULL); 844 return (jstring) JNIHandles::make_local(env, result); 845JVM_END 846 847 848JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls)) 849 JVMWrapper("JVM_GetClassInterfaces"); 850 JvmtiVMObjectAllocEventCollector oam; 851 oop mirror = JNIHandles::resolve_non_null(cls); 852 853 // Special handling for primitive objects 854 if (java_lang_Class::is_primitive(mirror)) { 855 // Primitive objects does not have any interfaces 856 objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL); 857 return (jobjectArray) JNIHandles::make_local(env, r); 858 } 859 860 KlassHandle klass(thread, java_lang_Class::as_klassOop(mirror)); 861 // Figure size of result array 862 int size; 863 if (klass->oop_is_instance()) { 864 size = instanceKlass::cast(klass())->local_interfaces()->length(); 865 } else { 866 assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass"); 867 size = 2; 868 } 869 870 // Allocate result array 871 objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), size, CHECK_NULL); 872 objArrayHandle result (THREAD, r); 873 // Fill in result 874 if (klass->oop_is_instance()) { 875 // Regular instance klass, fill in all local interfaces 876 for (int index = 0; index < size; index++) { 877 klassOop k = klassOop(instanceKlass::cast(klass())->local_interfaces()->obj_at(index)); 878 result->obj_at_put(index, Klass::cast(k)->java_mirror()); 879 } 880 } else { 881 // All arrays implement java.lang.Cloneable and java.io.Serializable 882 result->obj_at_put(0, Klass::cast(SystemDictionary::cloneable_klass())->java_mirror()); 883 result->obj_at_put(1, Klass::cast(SystemDictionary::serializable_klass())->java_mirror()); 884 } 885 return (jobjectArray) JNIHandles::make_local(env, result()); 886JVM_END 887 888 889JVM_ENTRY(jobject, JVM_GetClassLoader(JNIEnv *env, jclass cls)) 890 JVMWrapper("JVM_GetClassLoader"); 891 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 892 return NULL; 893 } 894 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 895 oop loader = Klass::cast(k)->class_loader(); 896 return JNIHandles::make_local(env, loader); 897JVM_END 898 899 900JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls)) 901 JVMWrapper("JVM_IsInterface"); 902 oop mirror = JNIHandles::resolve_non_null(cls); 903 if (java_lang_Class::is_primitive(mirror)) { 904 return JNI_FALSE; 905 } 906 klassOop k = java_lang_Class::as_klassOop(mirror); 907 jboolean result = Klass::cast(k)->is_interface(); 908 assert(!result || Klass::cast(k)->oop_is_instance(), 909 "all interfaces are instance types"); 910 // The compiler intrinsic for isInterface tests the 911 // Klass::_access_flags bits in the same way. 912 return result; 913JVM_END 914 915 916JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls)) 917 JVMWrapper("JVM_GetClassSigners"); 918 JvmtiVMObjectAllocEventCollector oam; 919 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 920 // There are no signers for primitive types 921 return NULL; 922 } 923 924 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 925 objArrayOop signers = NULL; 926 if (Klass::cast(k)->oop_is_instance()) { 927 signers = instanceKlass::cast(k)->signers(); 928 } 929 930 // If there are no signers set in the class, or if the class 931 // is an array, return NULL. 932 if (signers == NULL) return NULL; 933 934 // copy of the signers array 935 klassOop element = objArrayKlass::cast(signers->klass())->element_klass(); 936 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL); 937 for (int index = 0; index < signers->length(); index++) { 938 signers_copy->obj_at_put(index, signers->obj_at(index)); 939 } 940 941 // return the copy 942 return (jobjectArray) JNIHandles::make_local(env, signers_copy); 943JVM_END 944 945 946JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)) 947 JVMWrapper("JVM_SetClassSigners"); 948 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 949 // This call is ignored for primitive types and arrays. 950 // Signers are only set once, ClassLoader.java, and thus shouldn't 951 // be called with an array. Only the bootstrap loader creates arrays. 952 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 953 if (Klass::cast(k)->oop_is_instance()) { 954 instanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers))); 955 } 956 } 957JVM_END 958 959 960JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls)) 961 JVMWrapper("JVM_GetProtectionDomain"); 962 if (JNIHandles::resolve(cls) == NULL) { 963 THROW_(vmSymbols::java_lang_NullPointerException(), NULL); 964 } 965 966 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 967 // Primitive types does not have a protection domain. 968 return NULL; 969 } 970 971 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); 972 return (jobject) JNIHandles::make_local(env, Klass::cast(k)->protection_domain()); 973JVM_END 974 975 976// Obsolete since 1.2 (Class.setProtectionDomain removed), although 977// still defined in core libraries as of 1.5. 978JVM_ENTRY(void, JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)) 979 JVMWrapper("JVM_SetProtectionDomain"); 980 if (JNIHandles::resolve(cls) == NULL) { 981 THROW(vmSymbols::java_lang_NullPointerException()); 982 } 983 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 984 // Call is ignored for primitive types 985 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); 986 987 // cls won't be an array, as this called only from ClassLoader.defineClass 988 if (Klass::cast(k)->oop_is_instance()) { 989 oop pd = JNIHandles::resolve(protection_domain); 990 assert(pd == NULL || pd->is_oop(), "just checking"); 991 instanceKlass::cast(k)->set_protection_domain(pd); 992 } 993 } 994JVM_END 995 996 997JVM_ENTRY(jobject, JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)) 998 JVMWrapper("JVM_DoPrivileged"); 999 1000 if (action == NULL) { 1001 THROW_MSG_0(vmSymbols::java_lang_NullPointerException(), "Null action"); 1002 } 1003 1004 // Stack allocated list of privileged stack elements 1005 PrivilegedElement pi; 1006 1007 // Check that action object understands "Object run()" 1008 Handle object (THREAD, JNIHandles::resolve(action)); 1009 1010 // get run() method 1011 methodOop m_oop = Klass::cast(object->klass())->uncached_lookup_method( 1012 vmSymbols::run_method_name(), 1013 vmSymbols::void_object_signature()); 1014 methodHandle m (THREAD, m_oop); 1015 if (m.is_null() || !m->is_method() || !methodOop(m())->is_public() || methodOop(m())->is_static()) { 1016 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method"); 1017 } 1018 1019 // Compute the frame initiating the do privileged operation and setup the privileged stack 1020 vframeStream vfst(thread); 1021 vfst.security_get_caller_frame(1); 1022 1023 if (!vfst.at_end()) { 1024 pi.initialize(&vfst, JNIHandles::resolve(context), thread->privileged_stack_top(), CHECK_NULL); 1025 thread->set_privileged_stack_top(&pi); 1026 } 1027 1028 1029 // invoke the Object run() in the action object. We cannot use call_interface here, since the static type 1030 // is not really known - it is either java.security.PrivilegedAction or java.security.PrivilegedExceptionAction 1031 Handle pending_exception; 1032 JavaValue result(T_OBJECT); 1033 JavaCallArguments args(object); 1034 JavaCalls::call(&result, m, &args, THREAD); 1035 1036 // done with action, remove ourselves from the list 1037 if (!vfst.at_end()) { 1038 assert(thread->privileged_stack_top() != NULL && thread->privileged_stack_top() == &pi, "wrong top element"); 1039 thread->set_privileged_stack_top(thread->privileged_stack_top()->next()); 1040 } 1041 1042 if (HAS_PENDING_EXCEPTION) { 1043 pending_exception = Handle(THREAD, PENDING_EXCEPTION); 1044 CLEAR_PENDING_EXCEPTION; 1045 1046 if ( pending_exception->is_a(SystemDictionary::exception_klass()) && 1047 !pending_exception->is_a(SystemDictionary::runtime_exception_klass())) { 1048 // Throw a java.security.PrivilegedActionException(Exception e) exception 1049 JavaCallArguments args(pending_exception); 1050 THROW_ARG_0(vmSymbolHandles::java_security_PrivilegedActionException(), 1051 vmSymbolHandles::exception_void_signature(), 1052 &args); 1053 } 1054 } 1055 1056 if (pending_exception.not_null()) THROW_OOP_0(pending_exception()); 1057 return JNIHandles::make_local(env, (oop) result.get_jobject()); 1058JVM_END 1059 1060 1061// Returns the inherited_access_control_context field of the running thread. 1062JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)) 1063 JVMWrapper("JVM_GetInheritedAccessControlContext"); 1064 oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj()); 1065 return JNIHandles::make_local(env, result); 1066JVM_END 1067 1068class RegisterArrayForGC { 1069 private: 1070 JavaThread *_thread; 1071 public: 1072 RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array) { 1073 _thread = thread; 1074 _thread->register_array_for_gc(array); 1075 } 1076 1077 ~RegisterArrayForGC() { 1078 _thread->register_array_for_gc(NULL); 1079 } 1080}; 1081 1082 1083JVM_ENTRY(jobject, JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)) 1084 JVMWrapper("JVM_GetStackAccessControlContext"); 1085 if (!UsePrivilegedStack) return NULL; 1086 1087 ResourceMark rm(THREAD); 1088 GrowableArray<oop>* local_array = new GrowableArray<oop>(12); 1089 JvmtiVMObjectAllocEventCollector oam; 1090 1091 // count the protection domains on the execution stack. We collapse 1092 // duplicate consecutive protection domains into a single one, as 1093 // well as stopping when we hit a privileged frame. 1094 1095 // Use vframeStream to iterate through Java frames 1096 vframeStream vfst(thread); 1097 1098 oop previous_protection_domain = NULL; 1099 Handle privileged_context(thread, NULL); 1100 bool is_privileged = false; 1101 oop protection_domain = NULL; 1102 1103 for(; !vfst.at_end(); vfst.next()) { 1104 // get method of frame 1105 methodOop method = vfst.method(); 1106 intptr_t* frame_id = vfst.frame_id(); 1107 1108 // check the privileged frames to see if we have a match 1109 if (thread->privileged_stack_top() && thread->privileged_stack_top()->frame_id() == frame_id) { 1110 // this frame is privileged 1111 is_privileged = true; 1112 privileged_context = Handle(thread, thread->privileged_stack_top()->privileged_context()); 1113 protection_domain = thread->privileged_stack_top()->protection_domain(); 1114 } else { 1115 protection_domain = instanceKlass::cast(method->method_holder())->protection_domain(); 1116 } 1117 1118 if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) { 1119 local_array->push(protection_domain); 1120 previous_protection_domain = protection_domain; 1121 } 1122 1123 if (is_privileged) break; 1124 } 1125 1126 1127 // either all the domains on the stack were system domains, or 1128 // we had a privileged system domain 1129 if (local_array->is_empty()) { 1130 if (is_privileged && privileged_context.is_null()) return NULL; 1131 1132 oop result = java_security_AccessControlContext::create(objArrayHandle(), is_privileged, privileged_context, CHECK_NULL); 1133 return JNIHandles::make_local(env, result); 1134 } 1135 1136 // the resource area must be registered in case of a gc 1137 RegisterArrayForGC ragc(thread, local_array); 1138 objArrayOop context = oopFactory::new_objArray(SystemDictionary::protectionDomain_klass(), 1139 local_array->length(), CHECK_NULL); 1140 objArrayHandle h_context(thread, context); 1141 for (int index = 0; index < local_array->length(); index++) { 1142 h_context->obj_at_put(index, local_array->at(index)); 1143 } 1144 1145 oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL); 1146 1147 return JNIHandles::make_local(env, result); 1148JVM_END 1149 1150 1151JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls)) 1152 JVMWrapper("JVM_IsArrayClass"); 1153 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1154 return (k != NULL) && Klass::cast(k)->oop_is_javaArray() ? true : false; 1155JVM_END 1156 1157 1158JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)) 1159 JVMWrapper("JVM_IsPrimitiveClass"); 1160 oop mirror = JNIHandles::resolve_non_null(cls); 1161 return (jboolean) java_lang_Class::is_primitive(mirror); 1162JVM_END 1163 1164 1165JVM_ENTRY(jclass, JVM_GetComponentType(JNIEnv *env, jclass cls)) 1166 JVMWrapper("JVM_GetComponentType"); 1167 oop mirror = JNIHandles::resolve_non_null(cls); 1168 oop result = Reflection::array_component_type(mirror, CHECK_NULL); 1169 return (jclass) JNIHandles::make_local(env, result); 1170JVM_END 1171 1172 1173JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls)) 1174 JVMWrapper("JVM_GetClassModifiers"); 1175 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1176 // Primitive type 1177 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; 1178 } 1179 1180 Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); 1181 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0)); 1182 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK"); 1183 return k->modifier_flags(); 1184JVM_END 1185 1186 1187// Inner class reflection /////////////////////////////////////////////////////////////////////////////// 1188 1189JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)) 1190 const int inner_class_info_index = 0; 1191 const int outer_class_info_index = 1; 1192 1193 JvmtiVMObjectAllocEventCollector oam; 1194 // ofClass is a reference to a java_lang_Class object. The mirror object 1195 // of an instanceKlass 1196 1197 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1198 ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) { 1199 oop result = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL); 1200 return (jobjectArray)JNIHandles::make_local(env, result); 1201 } 1202 1203 instanceKlassHandle k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); 1204 1205 if (k->inner_classes()->length() == 0) { 1206 // Neither an inner nor outer class 1207 oop result = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL); 1208 return (jobjectArray)JNIHandles::make_local(env, result); 1209 } 1210 1211 // find inner class info 1212 typeArrayHandle icls(thread, k->inner_classes()); 1213 constantPoolHandle cp(thread, k->constants()); 1214 int length = icls->length(); 1215 1216 // Allocate temp. result array 1217 objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), length/4, CHECK_NULL); 1218 objArrayHandle result (THREAD, r); 1219 int members = 0; 1220 1221 for(int i = 0; i < length; i += 4) { 1222 int ioff = icls->ushort_at(i + inner_class_info_index); 1223 int ooff = icls->ushort_at(i + outer_class_info_index); 1224 1225 if (ioff != 0 && ooff != 0) { 1226 // Check to see if the name matches the class we're looking for 1227 // before attempting to find the class. 1228 if (cp->klass_name_at_matches(k, ooff)) { 1229 klassOop outer_klass = cp->klass_at(ooff, CHECK_NULL); 1230 if (outer_klass == k()) { 1231 klassOop ik = cp->klass_at(ioff, CHECK_NULL); 1232 instanceKlassHandle inner_klass (THREAD, ik); 1233 1234 // Throws an exception if outer klass has not declared k as 1235 // an inner klass 1236 Reflection::check_for_inner_class(k, inner_klass, CHECK_NULL); 1237 1238 result->obj_at_put(members, inner_klass->java_mirror()); 1239 members++; 1240 } 1241 } 1242 } 1243 } 1244 1245 if (members != length) { 1246 // Return array of right length 1247 objArrayOop res = oopFactory::new_objArray(SystemDictionary::class_klass(), members, CHECK_NULL); 1248 for(int i = 0; i < members; i++) { 1249 res->obj_at_put(i, result->obj_at(i)); 1250 } 1251 return (jobjectArray)JNIHandles::make_local(env, res); 1252 } 1253 1254 return (jobjectArray)JNIHandles::make_local(env, result()); 1255JVM_END 1256 1257 1258JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)) 1259 const int inner_class_info_index = 0; 1260 const int outer_class_info_index = 1; 1261 1262 // ofClass is a reference to a java_lang_Class object. 1263 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1264 ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) { 1265 return NULL; 1266 } 1267 1268 instanceKlassHandle k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); 1269 1270 if (k->inner_classes()->length() == 0) { 1271 // No inner class info => no declaring class 1272 return NULL; 1273 } 1274 1275 typeArrayHandle i_icls(thread, k->inner_classes()); 1276 constantPoolHandle i_cp(thread, k->constants()); 1277 int i_length = i_icls->length(); 1278 1279 bool found = false; 1280 klassOop ok; 1281 instanceKlassHandle outer_klass; 1282 1283 // Find inner_klass attribute 1284 for(int i = 0; i < i_length && !found; i+= 4) { 1285 int ioff = i_icls->ushort_at(i + inner_class_info_index); 1286 int ooff = i_icls->ushort_at(i + outer_class_info_index); 1287 1288 if (ioff != 0 && ooff != 0) { 1289 // Check to see if the name matches the class we're looking for 1290 // before attempting to find the class. 1291 if (i_cp->klass_name_at_matches(k, ioff)) { 1292 klassOop inner_klass = i_cp->klass_at(ioff, CHECK_NULL); 1293 if (k() == inner_klass) { 1294 found = true; 1295 ok = i_cp->klass_at(ooff, CHECK_NULL); 1296 outer_klass = instanceKlassHandle(thread, ok); 1297 } 1298 } 1299 } 1300 } 1301 1302 // If no inner class attribute found for this class. 1303 if (!found) return NULL; 1304 1305 // Throws an exception if outer klass has not declared k as an inner klass 1306 Reflection::check_for_inner_class(outer_klass, k, CHECK_NULL); 1307 1308 return (jclass)JNIHandles::make_local(env, outer_klass->java_mirror()); 1309JVM_END 1310 1311 1312JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls)) 1313 assert (cls != NULL, "illegal class"); 1314 JVMWrapper("JVM_GetClassSignature"); 1315 JvmtiVMObjectAllocEventCollector oam; 1316 ResourceMark rm(THREAD); 1317 // Return null for arrays and primatives 1318 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1319 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); 1320 if (Klass::cast(k)->oop_is_instance()) { 1321 symbolHandle sym = symbolHandle(THREAD, instanceKlass::cast(k)->generic_signature()); 1322 if (sym.is_null()) return NULL; 1323 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 1324 return (jstring) JNIHandles::make_local(env, str()); 1325 } 1326 } 1327 return NULL; 1328JVM_END 1329 1330 1331JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls)) 1332 assert (cls != NULL, "illegal class"); 1333 JVMWrapper("JVM_GetClassAnnotations"); 1334 ResourceMark rm(THREAD); 1335 // Return null for arrays and primitives 1336 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1337 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); 1338 if (Klass::cast(k)->oop_is_instance()) { 1339 return (jbyteArray) JNIHandles::make_local(env, 1340 instanceKlass::cast(k)->class_annotations()); 1341 } 1342 } 1343 return NULL; 1344JVM_END 1345 1346 1347JVM_ENTRY(jbyteArray, JVM_GetFieldAnnotations(JNIEnv *env, jobject field)) 1348 assert(field != NULL, "illegal field"); 1349 JVMWrapper("JVM_GetFieldAnnotations"); 1350 1351 // some of this code was adapted from from jni_FromReflectedField 1352 1353 // field is a handle to a java.lang.reflect.Field object 1354 oop reflected = JNIHandles::resolve_non_null(field); 1355 oop mirror = java_lang_reflect_Field::clazz(reflected); 1356 klassOop k = java_lang_Class::as_klassOop(mirror); 1357 int slot = java_lang_reflect_Field::slot(reflected); 1358 int modifiers = java_lang_reflect_Field::modifiers(reflected); 1359 1360 fieldDescriptor fd; 1361 KlassHandle kh(THREAD, k); 1362 intptr_t offset = instanceKlass::cast(kh())->offset_from_fields(slot); 1363 1364 if (modifiers & JVM_ACC_STATIC) { 1365 // for static fields we only look in the current class 1366 if (!instanceKlass::cast(kh())->find_local_field_from_offset(offset, 1367 true, &fd)) { 1368 assert(false, "cannot find static field"); 1369 return NULL; // robustness 1370 } 1371 } else { 1372 // for instance fields we start with the current class and work 1373 // our way up through the superclass chain 1374 if (!instanceKlass::cast(kh())->find_field_from_offset(offset, false, 1375 &fd)) { 1376 assert(false, "cannot find instance field"); 1377 return NULL; // robustness 1378 } 1379 } 1380 1381 return (jbyteArray) JNIHandles::make_local(env, fd.annotations()); 1382JVM_END 1383 1384 1385static methodOop jvm_get_method_common(jobject method, TRAPS) { 1386 // some of this code was adapted from from jni_FromReflectedMethod 1387 1388 oop reflected = JNIHandles::resolve_non_null(method); 1389 oop mirror = NULL; 1390 int slot = 0; 1391 1392 if (reflected->klass() == SystemDictionary::reflect_constructor_klass()) { 1393 mirror = java_lang_reflect_Constructor::clazz(reflected); 1394 slot = java_lang_reflect_Constructor::slot(reflected); 1395 } else { 1396 assert(reflected->klass() == SystemDictionary::reflect_method_klass(), 1397 "wrong type"); 1398 mirror = java_lang_reflect_Method::clazz(reflected); 1399 slot = java_lang_reflect_Method::slot(reflected); 1400 } 1401 klassOop k = java_lang_Class::as_klassOop(mirror); 1402 1403 KlassHandle kh(THREAD, k); 1404 methodOop m = instanceKlass::cast(kh())->method_with_idnum(slot); 1405 if (m == NULL) { 1406 assert(false, "cannot find method"); 1407 return NULL; // robustness 1408 } 1409 1410 return m; 1411} 1412 1413 1414JVM_ENTRY(jbyteArray, JVM_GetMethodAnnotations(JNIEnv *env, jobject method)) 1415 JVMWrapper("JVM_GetMethodAnnotations"); 1416 1417 // method is a handle to a java.lang.reflect.Method object 1418 methodOop m = jvm_get_method_common(method, CHECK_NULL); 1419 return (jbyteArray) JNIHandles::make_local(env, m->annotations()); 1420JVM_END 1421 1422 1423JVM_ENTRY(jbyteArray, JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)) 1424 JVMWrapper("JVM_GetMethodDefaultAnnotationValue"); 1425 1426 // method is a handle to a java.lang.reflect.Method object 1427 methodOop m = jvm_get_method_common(method, CHECK_NULL); 1428 return (jbyteArray) JNIHandles::make_local(env, m->annotation_default()); 1429JVM_END 1430 1431 1432JVM_ENTRY(jbyteArray, JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)) 1433 JVMWrapper("JVM_GetMethodParameterAnnotations"); 1434 1435 // method is a handle to a java.lang.reflect.Method object 1436 methodOop m = jvm_get_method_common(method, CHECK_NULL); 1437 return (jbyteArray) JNIHandles::make_local(env, m->parameter_annotations()); 1438JVM_END 1439 1440 1441// New (JDK 1.4) reflection implementation ///////////////////////////////////// 1442 1443JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1444{ 1445 JVMWrapper("JVM_GetClassDeclaredFields"); 1446 JvmtiVMObjectAllocEventCollector oam; 1447 1448 // Exclude primitive types and array types 1449 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1450 Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) { 1451 // Return empty array 1452 oop res = oopFactory::new_objArray(SystemDictionary::reflect_field_klass(), 0, CHECK_NULL); 1453 return (jobjectArray) JNIHandles::make_local(env, res); 1454 } 1455 1456 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); 1457 constantPoolHandle cp(THREAD, k->constants()); 1458 1459 // Ensure class is linked 1460 k->link_class(CHECK_NULL); 1461 1462 typeArrayHandle fields(THREAD, k->fields()); 1463 int fields_len = fields->length(); 1464 1465 // 4496456 We need to filter out java.lang.Throwable.backtrace 1466 bool skip_backtrace = false; 1467 1468 // Allocate result 1469 int num_fields; 1470 1471 if (publicOnly) { 1472 num_fields = 0; 1473 for (int i = 0, j = 0; i < fields_len; i += instanceKlass::next_offset, j++) { 1474 int mods = fields->ushort_at(i + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS; 1475 if (mods & JVM_ACC_PUBLIC) ++num_fields; 1476 } 1477 } else { 1478 num_fields = fields_len / instanceKlass::next_offset; 1479 1480 if (k() == SystemDictionary::throwable_klass()) { 1481 num_fields--; 1482 skip_backtrace = true; 1483 } 1484 } 1485 1486 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_field_klass(), num_fields, CHECK_NULL); 1487 objArrayHandle result (THREAD, r); 1488 1489 int out_idx = 0; 1490 fieldDescriptor fd; 1491 for (int i = 0; i < fields_len; i += instanceKlass::next_offset) { 1492 if (skip_backtrace) { 1493 // 4496456 skip java.lang.Throwable.backtrace 1494 int offset = k->offset_from_fields(i); 1495 if (offset == java_lang_Throwable::get_backtrace_offset()) continue; 1496 } 1497 1498 int mods = fields->ushort_at(i + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS; 1499 if (!publicOnly || (mods & JVM_ACC_PUBLIC)) { 1500 fd.initialize(k(), i); 1501 oop field = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL); 1502 result->obj_at_put(out_idx, field); 1503 ++out_idx; 1504 } 1505 } 1506 assert(out_idx == num_fields, "just checking"); 1507 return (jobjectArray) JNIHandles::make_local(env, result()); 1508} 1509JVM_END 1510 1511JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1512{ 1513 JVMWrapper("JVM_GetClassDeclaredMethods"); 1514 JvmtiVMObjectAllocEventCollector oam; 1515 1516 // Exclude primitive types and array types 1517 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) 1518 || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) { 1519 // Return empty array 1520 oop res = oopFactory::new_objArray(SystemDictionary::reflect_method_klass(), 0, CHECK_NULL); 1521 return (jobjectArray) JNIHandles::make_local(env, res); 1522 } 1523 1524 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); 1525 1526 // Ensure class is linked 1527 k->link_class(CHECK_NULL); 1528 1529 objArrayHandle methods (THREAD, k->methods()); 1530 int methods_length = methods->length(); 1531 int num_methods = 0; 1532 1533 int i; 1534 for (i = 0; i < methods_length; i++) { 1535 methodHandle method(THREAD, (methodOop) methods->obj_at(i)); 1536 if (!method->is_initializer()) { 1537 if (!publicOnly || method->is_public()) { 1538 ++num_methods; 1539 } 1540 } 1541 } 1542 1543 // Allocate result 1544 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_method_klass(), num_methods, CHECK_NULL); 1545 objArrayHandle result (THREAD, r); 1546 1547 int out_idx = 0; 1548 for (i = 0; i < methods_length; i++) { 1549 methodHandle method(THREAD, (methodOop) methods->obj_at(i)); 1550 if (!method->is_initializer()) { 1551 if (!publicOnly || method->is_public()) { 1552 oop m = Reflection::new_method(method, UseNewReflection, false, CHECK_NULL); 1553 result->obj_at_put(out_idx, m); 1554 ++out_idx; 1555 } 1556 } 1557 } 1558 assert(out_idx == num_methods, "just checking"); 1559 return (jobjectArray) JNIHandles::make_local(env, result()); 1560} 1561JVM_END 1562 1563JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1564{ 1565 JVMWrapper("JVM_GetClassDeclaredConstructors"); 1566 JvmtiVMObjectAllocEventCollector oam; 1567 1568 // Exclude primitive types and array types 1569 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) 1570 || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) { 1571 // Return empty array 1572 oop res = oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), 0 , CHECK_NULL); 1573 return (jobjectArray) JNIHandles::make_local(env, res); 1574 } 1575 1576 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); 1577 1578 // Ensure class is linked 1579 k->link_class(CHECK_NULL); 1580 1581 objArrayHandle methods (THREAD, k->methods()); 1582 int methods_length = methods->length(); 1583 int num_constructors = 0; 1584 1585 int i; 1586 for (i = 0; i < methods_length; i++) { 1587 methodHandle method(THREAD, (methodOop) methods->obj_at(i)); 1588 if (method->is_initializer() && !method->is_static()) { 1589 if (!publicOnly || method->is_public()) { 1590 ++num_constructors; 1591 } 1592 } 1593 } 1594 1595 // Allocate result 1596 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), num_constructors, CHECK_NULL); 1597 objArrayHandle result(THREAD, r); 1598 1599 int out_idx = 0; 1600 for (i = 0; i < methods_length; i++) { 1601 methodHandle method(THREAD, (methodOop) methods->obj_at(i)); 1602 if (method->is_initializer() && !method->is_static()) { 1603 if (!publicOnly || method->is_public()) { 1604 oop m = Reflection::new_constructor(method, CHECK_NULL); 1605 result->obj_at_put(out_idx, m); 1606 ++out_idx; 1607 } 1608 } 1609 } 1610 assert(out_idx == num_constructors, "just checking"); 1611 return (jobjectArray) JNIHandles::make_local(env, result()); 1612} 1613JVM_END 1614 1615JVM_ENTRY(jint, JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)) 1616{ 1617 JVMWrapper("JVM_GetClassAccessFlags"); 1618 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1619 // Primitive type 1620 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; 1621 } 1622 1623 Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); 1624 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS; 1625} 1626JVM_END 1627 1628 1629// Constant pool access ////////////////////////////////////////////////////////// 1630 1631JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls)) 1632{ 1633 JVMWrapper("JVM_GetClassConstantPool"); 1634 JvmtiVMObjectAllocEventCollector oam; 1635 1636 // Return null for primitives and arrays 1637 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1638 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1639 if (Klass::cast(k)->oop_is_instance()) { 1640 instanceKlassHandle k_h(THREAD, k); 1641 Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL); 1642 sun_reflect_ConstantPool::set_cp_oop(jcp(), k_h->constants()); 1643 return JNIHandles::make_local(jcp()); 1644 } 1645 } 1646 return NULL; 1647} 1648JVM_END 1649 1650 1651JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)) 1652{ 1653 JVMWrapper("JVM_ConstantPoolGetSize"); 1654 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1655 return cp->length(); 1656} 1657JVM_END 1658 1659 1660static void bounds_check(constantPoolHandle cp, jint index, TRAPS) { 1661 if (!cp->is_within_bounds(index)) { 1662 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds"); 1663 } 1664} 1665 1666 1667JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1668{ 1669 JVMWrapper("JVM_ConstantPoolGetClassAt"); 1670 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1671 bounds_check(cp, index, CHECK_NULL); 1672 constantTag tag = cp->tag_at(index); 1673 if (!tag.is_klass() && !tag.is_unresolved_klass()) { 1674 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1675 } 1676 klassOop k = cp->klass_at(index, CHECK_NULL); 1677 return (jclass) JNIHandles::make_local(k->klass_part()->java_mirror()); 1678} 1679JVM_END 1680 1681 1682JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1683{ 1684 JVMWrapper("JVM_ConstantPoolGetClassAtIfLoaded"); 1685 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1686 bounds_check(cp, index, CHECK_NULL); 1687 constantTag tag = cp->tag_at(index); 1688 if (!tag.is_klass() && !tag.is_unresolved_klass()) { 1689 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1690 } 1691 klassOop k = constantPoolOopDesc::klass_at_if_loaded(cp, index); 1692 if (k == NULL) return NULL; 1693 return (jclass) JNIHandles::make_local(k->klass_part()->java_mirror()); 1694} 1695JVM_END 1696 1697static jobject get_method_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) { 1698 constantTag tag = cp->tag_at(index); 1699 if (!tag.is_method() && !tag.is_interface_method()) { 1700 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1701 } 1702 int klass_ref = cp->uncached_klass_ref_index_at(index); 1703 klassOop k_o; 1704 if (force_resolution) { 1705 k_o = cp->klass_at(klass_ref, CHECK_NULL); 1706 } else { 1707 k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref); 1708 if (k_o == NULL) return NULL; 1709 } 1710 instanceKlassHandle k(THREAD, k_o); 1711 symbolOop name = cp->uncached_name_ref_at(index); 1712 symbolOop sig = cp->uncached_signature_ref_at(index); 1713 methodHandle m (THREAD, k->find_method(name, sig)); 1714 if (m.is_null()) { 1715 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class"); 1716 } 1717 oop method; 1718 if (!m->is_initializer() || m->is_static()) { 1719 method = Reflection::new_method(m, true, true, CHECK_NULL); 1720 } else { 1721 method = Reflection::new_constructor(m, CHECK_NULL); 1722 } 1723 return JNIHandles::make_local(method); 1724} 1725 1726JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1727{ 1728 JVMWrapper("JVM_ConstantPoolGetMethodAt"); 1729 JvmtiVMObjectAllocEventCollector oam; 1730 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1731 bounds_check(cp, index, CHECK_NULL); 1732 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL); 1733 return res; 1734} 1735JVM_END 1736 1737JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1738{ 1739 JVMWrapper("JVM_ConstantPoolGetMethodAtIfLoaded"); 1740 JvmtiVMObjectAllocEventCollector oam; 1741 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1742 bounds_check(cp, index, CHECK_NULL); 1743 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL); 1744 return res; 1745} 1746JVM_END 1747 1748static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) { 1749 constantTag tag = cp->tag_at(index); 1750 if (!tag.is_field()) { 1751 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1752 } 1753 int klass_ref = cp->uncached_klass_ref_index_at(index); 1754 klassOop k_o; 1755 if (force_resolution) { 1756 k_o = cp->klass_at(klass_ref, CHECK_NULL); 1757 } else { 1758 k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref); 1759 if (k_o == NULL) return NULL; 1760 } 1761 instanceKlassHandle k(THREAD, k_o); 1762 symbolOop name = cp->uncached_name_ref_at(index); 1763 symbolOop sig = cp->uncached_signature_ref_at(index); 1764 fieldDescriptor fd; 1765 klassOop target_klass = k->find_field(name, sig, &fd); 1766 if (target_klass == NULL) { 1767 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class"); 1768 } 1769 oop field = Reflection::new_field(&fd, true, CHECK_NULL); 1770 return JNIHandles::make_local(field); 1771} 1772 1773JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1774{ 1775 JVMWrapper("JVM_ConstantPoolGetFieldAt"); 1776 JvmtiVMObjectAllocEventCollector oam; 1777 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1778 bounds_check(cp, index, CHECK_NULL); 1779 jobject res = get_field_at_helper(cp, index, true, CHECK_NULL); 1780 return res; 1781} 1782JVM_END 1783 1784JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1785{ 1786 JVMWrapper("JVM_ConstantPoolGetFieldAtIfLoaded"); 1787 JvmtiVMObjectAllocEventCollector oam; 1788 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1789 bounds_check(cp, index, CHECK_NULL); 1790 jobject res = get_field_at_helper(cp, index, false, CHECK_NULL); 1791 return res; 1792} 1793JVM_END 1794 1795JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1796{ 1797 JVMWrapper("JVM_ConstantPoolGetMemberRefInfoAt"); 1798 JvmtiVMObjectAllocEventCollector oam; 1799 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1800 bounds_check(cp, index, CHECK_NULL); 1801 constantTag tag = cp->tag_at(index); 1802 if (!tag.is_field_or_method()) { 1803 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1804 } 1805 int klass_ref = cp->uncached_klass_ref_index_at(index); 1806 symbolHandle klass_name (THREAD, cp->klass_name_at(klass_ref)); 1807 symbolHandle member_name(THREAD, cp->uncached_name_ref_at(index)); 1808 symbolHandle member_sig (THREAD, cp->uncached_signature_ref_at(index)); 1809 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::string_klass(), 3, CHECK_NULL); 1810 objArrayHandle dest(THREAD, dest_o); 1811 Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL); 1812 dest->obj_at_put(0, str()); 1813 str = java_lang_String::create_from_symbol(member_name, CHECK_NULL); 1814 dest->obj_at_put(1, str()); 1815 str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL); 1816 dest->obj_at_put(2, str()); 1817 return (jobjectArray) JNIHandles::make_local(dest()); 1818} 1819JVM_END 1820 1821JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1822{ 1823 JVMWrapper("JVM_ConstantPoolGetIntAt"); 1824 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1825 bounds_check(cp, index, CHECK_0); 1826 constantTag tag = cp->tag_at(index); 1827 if (!tag.is_int()) { 1828 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1829 } 1830 return cp->int_at(index); 1831} 1832JVM_END 1833 1834JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1835{ 1836 JVMWrapper("JVM_ConstantPoolGetLongAt"); 1837 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1838 bounds_check(cp, index, CHECK_(0L)); 1839 constantTag tag = cp->tag_at(index); 1840 if (!tag.is_long()) { 1841 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1842 } 1843 return cp->long_at(index); 1844} 1845JVM_END 1846 1847JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1848{ 1849 JVMWrapper("JVM_ConstantPoolGetFloatAt"); 1850 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1851 bounds_check(cp, index, CHECK_(0.0f)); 1852 constantTag tag = cp->tag_at(index); 1853 if (!tag.is_float()) { 1854 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1855 } 1856 return cp->float_at(index); 1857} 1858JVM_END 1859 1860JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1861{ 1862 JVMWrapper("JVM_ConstantPoolGetDoubleAt"); 1863 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1864 bounds_check(cp, index, CHECK_(0.0)); 1865 constantTag tag = cp->tag_at(index); 1866 if (!tag.is_double()) { 1867 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1868 } 1869 return cp->double_at(index); 1870} 1871JVM_END 1872 1873JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1874{ 1875 JVMWrapper("JVM_ConstantPoolGetStringAt"); 1876 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1877 bounds_check(cp, index, CHECK_NULL); 1878 constantTag tag = cp->tag_at(index); 1879 if (!tag.is_string() && !tag.is_unresolved_string()) { 1880 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1881 } 1882 oop str = cp->string_at(index, CHECK_NULL); 1883 return (jstring) JNIHandles::make_local(str); 1884} 1885JVM_END 1886 1887JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)) 1888{ 1889 JVMWrapper("JVM_ConstantPoolGetUTF8At"); 1890 JvmtiVMObjectAllocEventCollector oam; 1891 constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); 1892 bounds_check(cp, index, CHECK_NULL); 1893 constantTag tag = cp->tag_at(index); 1894 if (!tag.is_symbol()) { 1895 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 1896 } 1897 symbolOop sym_o = cp->symbol_at(index); 1898 symbolHandle sym(THREAD, sym_o); 1899 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 1900 return (jstring) JNIHandles::make_local(str()); 1901} 1902JVM_END 1903 1904 1905// Assertion support. ////////////////////////////////////////////////////////// 1906 1907JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)) 1908 JVMWrapper("JVM_DesiredAssertionStatus"); 1909 assert(cls != NULL, "bad class"); 1910 1911 oop r = JNIHandles::resolve(cls); 1912 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed"); 1913 if (java_lang_Class::is_primitive(r)) return false; 1914 1915 klassOop k = java_lang_Class::as_klassOop(r); 1916 assert(Klass::cast(k)->oop_is_instance(), "must be an instance klass"); 1917 if (! Klass::cast(k)->oop_is_instance()) return false; 1918 1919 ResourceMark rm(THREAD); 1920 const char* name = Klass::cast(k)->name()->as_C_string(); 1921 bool system_class = Klass::cast(k)->class_loader() == NULL; 1922 return JavaAssertions::enabled(name, system_class); 1923 1924JVM_END 1925 1926 1927// Return a new AssertionStatusDirectives object with the fields filled in with 1928// command-line assertion arguments (i.e., -ea, -da). 1929JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)) 1930 JVMWrapper("JVM_AssertionStatusDirectives"); 1931 JvmtiVMObjectAllocEventCollector oam; 1932 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL); 1933 return JNIHandles::make_local(env, asd); 1934JVM_END 1935 1936// Verification //////////////////////////////////////////////////////////////////////////////// 1937 1938// Reflection for the verifier ///////////////////////////////////////////////////////////////// 1939 1940// RedefineClasses support: bug 6214132 caused verification to fail. 1941// All functions from this section should call the jvmtiThreadSate function: 1942// klassOop class_to_verify_considering_redefinition(klassOop klass). 1943// The function returns a klassOop of the _scratch_class if the verifier 1944// was invoked in the middle of the class redefinition. 1945// Otherwise it returns its argument value which is the _the_class klassOop. 1946// Please, refer to the description in the jvmtiThreadSate.hpp. 1947 1948JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls)) 1949 JVMWrapper("JVM_GetClassNameUTF"); 1950 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1951 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 1952 return Klass::cast(k)->name()->as_utf8(); 1953JVM_END 1954 1955 1956JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)) 1957 JVMWrapper("JVM_GetClassCPTypes"); 1958 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1959 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 1960 // types will have length zero if this is not an instanceKlass 1961 // (length is determined by call to JVM_GetClassCPEntriesCount) 1962 if (Klass::cast(k)->oop_is_instance()) { 1963 constantPoolOop cp = instanceKlass::cast(k)->constants(); 1964 for (int index = cp->length() - 1; index >= 0; index--) { 1965 constantTag tag = cp->tag_at(index); 1966 types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : 1967 (tag.is_unresolved_string()) ? JVM_CONSTANT_String : tag.value(); 1968 } 1969 } 1970JVM_END 1971 1972 1973JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)) 1974 JVMWrapper("JVM_GetClassCPEntriesCount"); 1975 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1976 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 1977 if (!Klass::cast(k)->oop_is_instance()) 1978 return 0; 1979 return instanceKlass::cast(k)->constants()->length(); 1980JVM_END 1981 1982 1983JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)) 1984 JVMWrapper("JVM_GetClassFieldsCount"); 1985 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1986 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 1987 if (!Klass::cast(k)->oop_is_instance()) 1988 return 0; 1989 return instanceKlass::cast(k)->fields()->length() / instanceKlass::next_offset; 1990JVM_END 1991 1992 1993JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)) 1994 JVMWrapper("JVM_GetClassMethodsCount"); 1995 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 1996 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 1997 if (!Klass::cast(k)->oop_is_instance()) 1998 return 0; 1999 return instanceKlass::cast(k)->methods()->length(); 2000JVM_END 2001 2002 2003// The following methods, used for the verifier, are never called with 2004// array klasses, so a direct cast to instanceKlass is safe. 2005// Typically, these methods are called in a loop with bounds determined 2006// by the results of JVM_GetClass{Fields,Methods}Count, which return 2007// zero for arrays. 2008JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)) 2009 JVMWrapper("JVM_GetMethodIxExceptionIndexes"); 2010 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2011 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2012 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2013 int length = methodOop(method)->checked_exceptions_length(); 2014 if (length > 0) { 2015 CheckedExceptionElement* table= methodOop(method)->checked_exceptions_start(); 2016 for (int i = 0; i < length; i++) { 2017 exceptions[i] = table[i].class_cp_index; 2018 } 2019 } 2020JVM_END 2021 2022 2023JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)) 2024 JVMWrapper("JVM_GetMethodIxExceptionsCount"); 2025 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2026 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2027 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2028 return methodOop(method)->checked_exceptions_length(); 2029JVM_END 2030 2031 2032JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)) 2033 JVMWrapper("JVM_GetMethodIxByteCode"); 2034 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2035 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2036 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2037 memcpy(code, methodOop(method)->code_base(), methodOop(method)->code_size()); 2038JVM_END 2039 2040 2041JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)) 2042 JVMWrapper("JVM_GetMethodIxByteCodeLength"); 2043 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2044 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2045 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2046 return methodOop(method)->code_size(); 2047JVM_END 2048 2049 2050JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)) 2051 JVMWrapper("JVM_GetMethodIxExceptionTableEntry"); 2052 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2053 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2054 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2055 typeArrayOop extable = methodOop(method)->exception_table(); 2056 entry->start_pc = extable->int_at(entry_index * 4); 2057 entry->end_pc = extable->int_at(entry_index * 4 + 1); 2058 entry->handler_pc = extable->int_at(entry_index * 4 + 2); 2059 entry->catchType = extable->int_at(entry_index * 4 + 3); 2060JVM_END 2061 2062 2063JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)) 2064 JVMWrapper("JVM_GetMethodIxExceptionTableLength"); 2065 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2066 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2067 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2068 return methodOop(method)->exception_table()->length() / 4; 2069JVM_END 2070 2071 2072JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)) 2073 JVMWrapper("JVM_GetMethodIxModifiers"); 2074 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2075 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2076 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2077 return methodOop(method)->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; 2078JVM_END 2079 2080 2081JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)) 2082 JVMWrapper("JVM_GetFieldIxModifiers"); 2083 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2084 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2085 typeArrayOop fields = instanceKlass::cast(k)->fields(); 2086 return fields->ushort_at(field_index * instanceKlass::next_offset + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS; 2087JVM_END 2088 2089 2090JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)) 2091 JVMWrapper("JVM_GetMethodIxLocalsCount"); 2092 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2093 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2094 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2095 return methodOop(method)->max_locals(); 2096JVM_END 2097 2098 2099JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)) 2100 JVMWrapper("JVM_GetMethodIxArgsSize"); 2101 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2102 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2103 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2104 return methodOop(method)->size_of_parameters(); 2105JVM_END 2106 2107 2108JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)) 2109 JVMWrapper("JVM_GetMethodIxMaxStack"); 2110 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2111 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2112 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2113 return methodOop(method)->max_stack(); 2114JVM_END 2115 2116 2117JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)) 2118 JVMWrapper("JVM_IsConstructorIx"); 2119 ResourceMark rm(THREAD); 2120 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2121 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2122 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2123 return methodOop(method)->name() == vmSymbols::object_initializer_name(); 2124JVM_END 2125 2126 2127JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)) 2128 JVMWrapper("JVM_GetMethodIxIxUTF"); 2129 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2130 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2131 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2132 return methodOop(method)->name()->as_utf8(); 2133JVM_END 2134 2135 2136JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)) 2137 JVMWrapper("JVM_GetMethodIxSignatureUTF"); 2138 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2139 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2140 oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); 2141 return methodOop(method)->signature()->as_utf8(); 2142JVM_END 2143 2144/** 2145 * All of these JVM_GetCP-xxx methods are used by the old verifier to 2146 * read entries in the constant pool. Since the old verifier always 2147 * works on a copy of the code, it will not see any rewriting that 2148 * may possibly occur in the middle of verification. So it is important 2149 * that nothing it calls tries to use the cpCache instead of the raw 2150 * constant pool, so we must use cp->uncached_x methods when appropriate. 2151 */ 2152JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2153 JVMWrapper("JVM_GetCPFieldNameUTF"); 2154 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2155 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2156 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2157 switch (cp->tag_at(cp_index).value()) { 2158 case JVM_CONSTANT_Fieldref: 2159 return cp->uncached_name_ref_at(cp_index)->as_utf8(); 2160 default: 2161 fatal("JVM_GetCPFieldNameUTF: illegal constant"); 2162 } 2163 ShouldNotReachHere(); 2164 return NULL; 2165JVM_END 2166 2167 2168JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2169 JVMWrapper("JVM_GetCPMethodNameUTF"); 2170 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2171 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2172 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2173 switch (cp->tag_at(cp_index).value()) { 2174 case JVM_CONSTANT_InterfaceMethodref: 2175 case JVM_CONSTANT_Methodref: 2176 return cp->uncached_name_ref_at(cp_index)->as_utf8(); 2177 default: 2178 fatal("JVM_GetCPMethodNameUTF: illegal constant"); 2179 } 2180 ShouldNotReachHere(); 2181 return NULL; 2182JVM_END 2183 2184 2185JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) 2186 JVMWrapper("JVM_GetCPMethodSignatureUTF"); 2187 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2188 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2189 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2190 switch (cp->tag_at(cp_index).value()) { 2191 case JVM_CONSTANT_InterfaceMethodref: 2192 case JVM_CONSTANT_Methodref: 2193 return cp->uncached_signature_ref_at(cp_index)->as_utf8(); 2194 default: 2195 fatal("JVM_GetCPMethodSignatureUTF: illegal constant"); 2196 } 2197 ShouldNotReachHere(); 2198 return NULL; 2199JVM_END 2200 2201 2202JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) 2203 JVMWrapper("JVM_GetCPFieldSignatureUTF"); 2204 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2205 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2206 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2207 switch (cp->tag_at(cp_index).value()) { 2208 case JVM_CONSTANT_Fieldref: 2209 return cp->uncached_signature_ref_at(cp_index)->as_utf8(); 2210 default: 2211 fatal("JVM_GetCPFieldSignatureUTF: illegal constant"); 2212 } 2213 ShouldNotReachHere(); 2214 return NULL; 2215JVM_END 2216 2217 2218JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2219 JVMWrapper("JVM_GetCPClassNameUTF"); 2220 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2221 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2222 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2223 symbolOop classname = cp->klass_name_at(cp_index); 2224 return classname->as_utf8(); 2225JVM_END 2226 2227 2228JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2229 JVMWrapper("JVM_GetCPFieldClassNameUTF"); 2230 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2231 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2232 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2233 switch (cp->tag_at(cp_index).value()) { 2234 case JVM_CONSTANT_Fieldref: { 2235 int class_index = cp->uncached_klass_ref_index_at(cp_index); 2236 symbolOop classname = cp->klass_name_at(class_index); 2237 return classname->as_utf8(); 2238 } 2239 default: 2240 fatal("JVM_GetCPFieldClassNameUTF: illegal constant"); 2241 } 2242 ShouldNotReachHere(); 2243 return NULL; 2244JVM_END 2245 2246 2247JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2248 JVMWrapper("JVM_GetCPMethodClassNameUTF"); 2249 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2250 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2251 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2252 switch (cp->tag_at(cp_index).value()) { 2253 case JVM_CONSTANT_Methodref: 2254 case JVM_CONSTANT_InterfaceMethodref: { 2255 int class_index = cp->uncached_klass_ref_index_at(cp_index); 2256 symbolOop classname = cp->klass_name_at(class_index); 2257 return classname->as_utf8(); 2258 } 2259 default: 2260 fatal("JVM_GetCPMethodClassNameUTF: illegal constant"); 2261 } 2262 ShouldNotReachHere(); 2263 return NULL; 2264JVM_END 2265 2266 2267JVM_QUICK_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) 2268 JVMWrapper("JVM_GetCPFieldModifiers"); 2269 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2270 klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls)); 2271 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2272 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread); 2273 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2274 constantPoolOop cp_called = instanceKlass::cast(k_called)->constants(); 2275 switch (cp->tag_at(cp_index).value()) { 2276 case JVM_CONSTANT_Fieldref: { 2277 symbolOop name = cp->uncached_name_ref_at(cp_index); 2278 symbolOop signature = cp->uncached_signature_ref_at(cp_index); 2279 typeArrayOop fields = instanceKlass::cast(k_called)->fields(); 2280 int fields_count = fields->length(); 2281 for (int i = 0; i < fields_count; i += instanceKlass::next_offset) { 2282 if (cp_called->symbol_at(fields->ushort_at(i + instanceKlass::name_index_offset)) == name && 2283 cp_called->symbol_at(fields->ushort_at(i + instanceKlass::signature_index_offset)) == signature) { 2284 return fields->ushort_at(i + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS; 2285 } 2286 } 2287 return -1; 2288 } 2289 default: 2290 fatal("JVM_GetCPFieldModifiers: illegal constant"); 2291 } 2292 ShouldNotReachHere(); 2293 return 0; 2294JVM_END 2295 2296 2297JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) 2298 JVMWrapper("JVM_GetCPMethodModifiers"); 2299 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); 2300 klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls)); 2301 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2302 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread); 2303 constantPoolOop cp = instanceKlass::cast(k)->constants(); 2304 switch (cp->tag_at(cp_index).value()) { 2305 case JVM_CONSTANT_Methodref: 2306 case JVM_CONSTANT_InterfaceMethodref: { 2307 symbolOop name = cp->uncached_name_ref_at(cp_index); 2308 symbolOop signature = cp->uncached_signature_ref_at(cp_index); 2309 objArrayOop methods = instanceKlass::cast(k_called)->methods(); 2310 int methods_count = methods->length(); 2311 for (int i = 0; i < methods_count; i++) { 2312 methodOop method = methodOop(methods->obj_at(i)); 2313 if (method->name() == name && method->signature() == signature) { 2314 return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; 2315 } 2316 } 2317 return -1; 2318 } 2319 default: 2320 fatal("JVM_GetCPMethodModifiers: illegal constant"); 2321 } 2322 ShouldNotReachHere(); 2323 return 0; 2324JVM_END 2325 2326 2327// Misc ////////////////////////////////////////////////////////////////////////////////////////////// 2328 2329JVM_LEAF(void, JVM_ReleaseUTF(const char *utf)) 2330 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything 2331JVM_END 2332 2333 2334JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)) 2335 JVMWrapper("JVM_IsSameClassPackage"); 2336 oop class1_mirror = JNIHandles::resolve_non_null(class1); 2337 oop class2_mirror = JNIHandles::resolve_non_null(class2); 2338 klassOop klass1 = java_lang_Class::as_klassOop(class1_mirror); 2339 klassOop klass2 = java_lang_Class::as_klassOop(class2_mirror); 2340 return (jboolean) Reflection::is_same_class_package(klass1, klass2); 2341JVM_END 2342 2343 2344// IO functions //////////////////////////////////////////////////////////////////////////////////////// 2345 2346JVM_LEAF(jint, JVM_Open(const char *fname, jint flags, jint mode)) 2347 JVMWrapper2("JVM_Open (%s)", fname); 2348 2349 //%note jvm_r6 2350 int result = hpi::open(fname, flags, mode); 2351 if (result >= 0) { 2352 return result; 2353 } else { 2354 switch(errno) { 2355 case EEXIST: 2356 return JVM_EEXIST; 2357 default: 2358 return -1; 2359 } 2360 } 2361JVM_END 2362 2363 2364JVM_LEAF(jint, JVM_Close(jint fd)) 2365 JVMWrapper2("JVM_Close (0x%x)", fd); 2366 //%note jvm_r6 2367 return hpi::close(fd); 2368JVM_END 2369 2370 2371JVM_LEAF(jint, JVM_Read(jint fd, char *buf, jint nbytes)) 2372 JVMWrapper2("JVM_Read (0x%x)", fd); 2373 2374 //%note jvm_r6 2375 return (jint)hpi::read(fd, buf, nbytes); 2376JVM_END 2377 2378 2379JVM_LEAF(jint, JVM_Write(jint fd, char *buf, jint nbytes)) 2380 JVMWrapper2("JVM_Write (0x%x)", fd); 2381 2382 //%note jvm_r6 2383 return (jint)hpi::write(fd, buf, nbytes); 2384JVM_END 2385 2386 2387JVM_LEAF(jint, JVM_Available(jint fd, jlong *pbytes)) 2388 JVMWrapper2("JVM_Available (0x%x)", fd); 2389 //%note jvm_r6 2390 return hpi::available(fd, pbytes); 2391JVM_END 2392 2393 2394JVM_LEAF(jlong, JVM_Lseek(jint fd, jlong offset, jint whence)) 2395 JVMWrapper4("JVM_Lseek (0x%x, %Ld, %d)", fd, offset, whence); 2396 //%note jvm_r6 2397 return hpi::lseek(fd, offset, whence); 2398JVM_END 2399 2400 2401JVM_LEAF(jint, JVM_SetLength(jint fd, jlong length)) 2402 JVMWrapper3("JVM_SetLength (0x%x, %Ld)", fd, length); 2403 return hpi::ftruncate(fd, length); 2404JVM_END 2405 2406 2407JVM_LEAF(jint, JVM_Sync(jint fd)) 2408 JVMWrapper2("JVM_Sync (0x%x)", fd); 2409 //%note jvm_r6 2410 return hpi::fsync(fd); 2411JVM_END 2412 2413 2414// Printing support ////////////////////////////////////////////////// 2415extern "C" { 2416 2417int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) { 2418 // see bug 4399518, 4417214 2419 if ((intptr_t)count <= 0) return -1; 2420 return vsnprintf(str, count, fmt, args); 2421} 2422 2423 2424int jio_snprintf(char *str, size_t count, const char *fmt, ...) { 2425 va_list args; 2426 int len; 2427 va_start(args, fmt); 2428 len = jio_vsnprintf(str, count, fmt, args); 2429 va_end(args); 2430 return len; 2431} 2432 2433 2434int jio_fprintf(FILE* f, const char *fmt, ...) { 2435 int len; 2436 va_list args; 2437 va_start(args, fmt); 2438 len = jio_vfprintf(f, fmt, args); 2439 va_end(args); 2440 return len; 2441} 2442 2443 2444int jio_vfprintf(FILE* f, const char *fmt, va_list args) { 2445 if (Arguments::vfprintf_hook() != NULL) { 2446 return Arguments::vfprintf_hook()(f, fmt, args); 2447 } else { 2448 return vfprintf(f, fmt, args); 2449 } 2450} 2451 2452 2453int jio_printf(const char *fmt, ...) { 2454 int len; 2455 va_list args; 2456 va_start(args, fmt); 2457 len = jio_vfprintf(defaultStream::output_stream(), fmt, args); 2458 va_end(args); 2459 return len; 2460} 2461 2462 2463// HotSpot specific jio method 2464void jio_print(const char* s) { 2465 // Try to make this function as atomic as possible. 2466 if (Arguments::vfprintf_hook() != NULL) { 2467 jio_fprintf(defaultStream::output_stream(), "%s", s); 2468 } else { 2469 ::write(defaultStream::output_fd(), s, (int)strlen(s)); 2470 } 2471} 2472 2473} // Extern C 2474 2475// java.lang.Thread ////////////////////////////////////////////////////////////////////////////// 2476 2477// In most of the JVM Thread support functions we need to be sure to lock the Threads_lock 2478// to prevent the target thread from exiting after we have a pointer to the C++ Thread or 2479// OSThread objects. The exception to this rule is when the target object is the thread 2480// doing the operation, in which case we know that the thread won't exit until the 2481// operation is done (all exits being voluntary). There are a few cases where it is 2482// rather silly to do operations on yourself, like resuming yourself or asking whether 2483// you are alive. While these can still happen, they are not subject to deadlocks if 2484// the lock is held while the operation occurs (this is not the case for suspend, for 2485// instance), and are very unlikely. Because IsAlive needs to be fast and its 2486// implementation is local to this file, we always lock Threads_lock for that one. 2487 2488static void thread_entry(JavaThread* thread, TRAPS) { 2489 HandleMark hm(THREAD); 2490 Handle obj(THREAD, thread->threadObj()); 2491 JavaValue result(T_VOID); 2492 JavaCalls::call_virtual(&result, 2493 obj, 2494 KlassHandle(THREAD, SystemDictionary::thread_klass()), 2495 vmSymbolHandles::run_method_name(), 2496 vmSymbolHandles::void_method_signature(), 2497 THREAD); 2498} 2499 2500 2501JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread)) 2502 JVMWrapper("JVM_StartThread"); 2503 JavaThread *native_thread = NULL; 2504 2505 // We cannot hold the Threads_lock when we throw an exception, 2506 // due to rank ordering issues. Example: we might need to grab the 2507 // Heap_lock while we construct the exception. 2508 bool throw_illegal_thread_state = false; 2509 2510 // We must release the Threads_lock before we can post a jvmti event 2511 // in Thread::start. 2512 { 2513 // Ensure that the C++ Thread and OSThread structures aren't freed before 2514 // we operate. 2515 MutexLocker mu(Threads_lock); 2516 2517 // Check to see if we're running a thread that's already exited or was 2518 // stopped (is_stillborn) or is still active (thread is not NULL). 2519 if (java_lang_Thread::is_stillborn(JNIHandles::resolve_non_null(jthread)) || 2520 java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) { 2521 throw_illegal_thread_state = true; 2522 } else { 2523 jlong size = 2524 java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread)); 2525 // Allocate the C++ Thread structure and create the native thread. The 2526 // stack size retrieved from java is signed, but the constructor takes 2527 // size_t (an unsigned type), so avoid passing negative values which would 2528 // result in really large stacks. 2529 size_t sz = size > 0 ? (size_t) size : 0; 2530 native_thread = new JavaThread(&thread_entry, sz); 2531 2532 // At this point it may be possible that no osthread was created for the 2533 // JavaThread due to lack of memory. Check for this situation and throw 2534 // an exception if necessary. Eventually we may want to change this so 2535 // that we only grab the lock if the thread was created successfully - 2536 // then we can also do this check and throw the exception in the 2537 // JavaThread constructor. 2538 if (native_thread->osthread() != NULL) { 2539 // Note: the current thread is not being used within "prepare". 2540 native_thread->prepare(jthread); 2541 } 2542 } 2543 } 2544 2545 if (throw_illegal_thread_state) { 2546 THROW(vmSymbols::java_lang_IllegalThreadStateException()); 2547 } 2548 2549 assert(native_thread != NULL, "Starting null thread?"); 2550 2551 if (native_thread->osthread() == NULL) { 2552 // No one should hold a reference to the 'native_thread'. 2553 delete native_thread; 2554 if (JvmtiExport::should_post_resource_exhausted()) { 2555 JvmtiExport::post_resource_exhausted( 2556 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS, 2557 "unable to create new native thread"); 2558 } 2559 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), 2560 "unable to create new native thread"); 2561 } 2562 2563 Thread::start(native_thread); 2564 2565JVM_END 2566 2567// JVM_Stop is implemented using a VM_Operation, so threads are forced to safepoints 2568// before the quasi-asynchronous exception is delivered. This is a little obtrusive, 2569// but is thought to be reliable and simple. In the case, where the receiver is the 2570// save thread as the sender, no safepoint is needed. 2571JVM_ENTRY(void, JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)) 2572 JVMWrapper("JVM_StopThread"); 2573 2574 oop java_throwable = JNIHandles::resolve(throwable); 2575 if (java_throwable == NULL) { 2576 THROW(vmSymbols::java_lang_NullPointerException()); 2577 } 2578 oop java_thread = JNIHandles::resolve_non_null(jthread); 2579 JavaThread* receiver = java_lang_Thread::thread(java_thread); 2580 Events::log("JVM_StopThread thread JavaThread " INTPTR_FORMAT " as oop " INTPTR_FORMAT " [exception " INTPTR_FORMAT "]", receiver, (address)java_thread, throwable); 2581 // First check if thread already exited 2582 if (receiver != NULL) { 2583 // Check if exception is getting thrown at self (use oop equality, since the 2584 // target object might exit) 2585 if (java_thread == thread->threadObj()) { 2586 // This is a change from JDK 1.1, but JDK 1.2 will also do it: 2587 // NOTE (from JDK 1.2): this is done solely to prevent stopped 2588 // threads from being restarted. 2589 // Fix for 4314342, 4145910, perhaps others: it now doesn't have 2590 // any effect on the "liveness" of a thread; see 2591 // JVM_IsThreadAlive, below. 2592 if (java_throwable->is_a(SystemDictionary::threaddeath_klass())) { 2593 java_lang_Thread::set_stillborn(java_thread); 2594 } 2595 THROW_OOP(java_throwable); 2596 } else { 2597 // Enques a VM_Operation to stop all threads and then deliver the exception... 2598 Thread::send_async_exception(java_thread, JNIHandles::resolve(throwable)); 2599 } 2600 } 2601JVM_END 2602 2603 2604JVM_ENTRY(jboolean, JVM_IsThreadAlive(JNIEnv* env, jobject jthread)) 2605 JVMWrapper("JVM_IsThreadAlive"); 2606 2607 oop thread_oop = JNIHandles::resolve_non_null(jthread); 2608 return java_lang_Thread::is_alive(thread_oop); 2609JVM_END 2610 2611 2612JVM_ENTRY(void, JVM_SuspendThread(JNIEnv* env, jobject jthread)) 2613 JVMWrapper("JVM_SuspendThread"); 2614 oop java_thread = JNIHandles::resolve_non_null(jthread); 2615 JavaThread* receiver = java_lang_Thread::thread(java_thread); 2616 2617 if (receiver != NULL) { 2618 // thread has run and has not exited (still on threads list) 2619 2620 { 2621 MutexLockerEx ml(receiver->SR_lock(), Mutex::_no_safepoint_check_flag); 2622 if (receiver->is_external_suspend()) { 2623 // Don't allow nested external suspend requests. We can't return 2624 // an error from this interface so just ignore the problem. 2625 return; 2626 } 2627 if (receiver->is_exiting()) { // thread is in the process of exiting 2628 return; 2629 } 2630 receiver->set_external_suspend(); 2631 } 2632 2633 // java_suspend() will catch threads in the process of exiting 2634 // and will ignore them. 2635 receiver->java_suspend(); 2636 2637 // It would be nice to have the following assertion in all the 2638 // time, but it is possible for a racing resume request to have 2639 // resumed this thread right after we suspended it. Temporarily 2640 // enable this assertion if you are chasing a different kind of 2641 // bug. 2642 // 2643 // assert(java_lang_Thread::thread(receiver->threadObj()) == NULL || 2644 // receiver->is_being_ext_suspended(), "thread is not suspended"); 2645 } 2646JVM_END 2647 2648 2649JVM_ENTRY(void, JVM_ResumeThread(JNIEnv* env, jobject jthread)) 2650 JVMWrapper("JVM_ResumeThread"); 2651 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate. 2652 // We need to *always* get the threads lock here, since this operation cannot be allowed during 2653 // a safepoint. The safepoint code relies on suspending a thread to examine its state. If other 2654 // threads randomly resumes threads, then a thread might not be suspended when the safepoint code 2655 // looks at it. 2656 MutexLocker ml(Threads_lock); 2657 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); 2658 if (thr != NULL) { 2659 // the thread has run and is not in the process of exiting 2660 thr->java_resume(); 2661 } 2662JVM_END 2663 2664 2665JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)) 2666 JVMWrapper("JVM_SetThreadPriority"); 2667 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate 2668 MutexLocker ml(Threads_lock); 2669 oop java_thread = JNIHandles::resolve_non_null(jthread); 2670 java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio); 2671 JavaThread* thr = java_lang_Thread::thread(java_thread); 2672 if (thr != NULL) { // Thread not yet started; priority pushed down when it is 2673 Thread::set_priority(thr, (ThreadPriority)prio); 2674 } 2675JVM_END 2676 2677 2678JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass)) 2679 JVMWrapper("JVM_Yield"); 2680 if (os::dont_yield()) return; 2681 // When ConvertYieldToSleep is off (default), this matches the classic VM use of yield. 2682 // Critical for similar threading behaviour 2683 if (ConvertYieldToSleep) { 2684 os::sleep(thread, MinSleepInterval, false); 2685 } else { 2686 os::yield(); 2687 } 2688JVM_END 2689 2690 2691JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)) 2692 JVMWrapper("JVM_Sleep"); 2693 2694 if (millis < 0) { 2695 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative"); 2696 } 2697 2698 if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) { 2699 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); 2700 } 2701 2702 // Save current thread state and restore it at the end of this block. 2703 // And set new thread state to SLEEPING. 2704 JavaThreadSleepState jtss(thread); 2705 2706 if (millis == 0) { 2707 // When ConvertSleepToYield is on, this matches the classic VM implementation of 2708 // JVM_Sleep. Critical for similar threading behaviour (Win32) 2709 // It appears that in certain GUI contexts, it may be beneficial to do a short sleep 2710 // for SOLARIS 2711 if (ConvertSleepToYield) { 2712 os::yield(); 2713 } else { 2714 ThreadState old_state = thread->osthread()->get_state(); 2715 thread->osthread()->set_state(SLEEPING); 2716 os::sleep(thread, MinSleepInterval, false); 2717 thread->osthread()->set_state(old_state); 2718 } 2719 } else { 2720 ThreadState old_state = thread->osthread()->get_state(); 2721 thread->osthread()->set_state(SLEEPING); 2722 if (os::sleep(thread, millis, true) == OS_INTRPT) { 2723 // An asynchronous exception (e.g., ThreadDeathException) could have been thrown on 2724 // us while we were sleeping. We do not overwrite those. 2725 if (!HAS_PENDING_EXCEPTION) { 2726 // TODO-FIXME: THROW_MSG returns which means we will not call set_state() 2727 // to properly restore the thread state. That's likely wrong. 2728 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); 2729 } 2730 } 2731 thread->osthread()->set_state(old_state); 2732 } 2733JVM_END 2734 2735JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass)) 2736 JVMWrapper("JVM_CurrentThread"); 2737 oop jthread = thread->threadObj(); 2738 assert (thread != NULL, "no current thread!"); 2739 return JNIHandles::make_local(env, jthread); 2740JVM_END 2741 2742 2743JVM_ENTRY(jint, JVM_CountStackFrames(JNIEnv* env, jobject jthread)) 2744 JVMWrapper("JVM_CountStackFrames"); 2745 2746 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate 2747 oop java_thread = JNIHandles::resolve_non_null(jthread); 2748 bool throw_illegal_thread_state = false; 2749 int count = 0; 2750 2751 { 2752 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock); 2753 // We need to re-resolve the java_thread, since a GC might have happened during the 2754 // acquire of the lock 2755 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); 2756 2757 if (thr == NULL) { 2758 // do nothing 2759 } else if(! thr->is_external_suspend() || ! thr->frame_anchor()->walkable()) { 2760 // Check whether this java thread has been suspended already. If not, throws 2761 // IllegalThreadStateException. We defer to throw that exception until 2762 // Threads_lock is released since loading exception class has to leave VM. 2763 // The correct way to test a thread is actually suspended is 2764 // wait_for_ext_suspend_completion(), but we can't call that while holding 2765 // the Threads_lock. The above tests are sufficient for our purposes 2766 // provided the walkability of the stack is stable - which it isn't 2767 // 100% but close enough for most practical purposes. 2768 throw_illegal_thread_state = true; 2769 } else { 2770 // Count all java activation, i.e., number of vframes 2771 for(vframeStream vfst(thr); !vfst.at_end(); vfst.next()) { 2772 // Native frames are not counted 2773 if (!vfst.method()->is_native()) count++; 2774 } 2775 } 2776 } 2777 2778 if (throw_illegal_thread_state) { 2779 THROW_MSG_0(vmSymbols::java_lang_IllegalThreadStateException(), 2780 "this thread is not suspended"); 2781 } 2782 return count; 2783JVM_END 2784 2785// Consider: A better way to implement JVM_Interrupt() is to acquire 2786// Threads_lock to resolve the jthread into a Thread pointer, fetch 2787// Thread->platformevent, Thread->native_thr, Thread->parker, etc., 2788// drop Threads_lock, and the perform the unpark() and thr_kill() operations 2789// outside the critical section. Threads_lock is hot so we want to minimize 2790// the hold-time. A cleaner interface would be to decompose interrupt into 2791// two steps. The 1st phase, performed under Threads_lock, would return 2792// a closure that'd be invoked after Threads_lock was dropped. 2793// This tactic is safe as PlatformEvent and Parkers are type-stable (TSM) and 2794// admit spurious wakeups. 2795 2796JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread)) 2797 JVMWrapper("JVM_Interrupt"); 2798 2799 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate 2800 oop java_thread = JNIHandles::resolve_non_null(jthread); 2801 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock); 2802 // We need to re-resolve the java_thread, since a GC might have happened during the 2803 // acquire of the lock 2804 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); 2805 if (thr != NULL) { 2806 Thread::interrupt(thr); 2807 } 2808JVM_END 2809 2810 2811JVM_QUICK_ENTRY(jboolean, JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)) 2812 JVMWrapper("JVM_IsInterrupted"); 2813 2814 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate 2815 oop java_thread = JNIHandles::resolve_non_null(jthread); 2816 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock); 2817 // We need to re-resolve the java_thread, since a GC might have happened during the 2818 // acquire of the lock 2819 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)); 2820 if (thr == NULL) { 2821 return JNI_FALSE; 2822 } else { 2823 return (jboolean) Thread::is_interrupted(thr, clear_interrupted != 0); 2824 } 2825JVM_END 2826 2827 2828// Return true iff the current thread has locked the object passed in 2829 2830JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)) 2831 JVMWrapper("JVM_HoldsLock"); 2832 assert(THREAD->is_Java_thread(), "sanity check"); 2833 if (obj == NULL) { 2834 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE); 2835 } 2836 Handle h_obj(THREAD, JNIHandles::resolve(obj)); 2837 return ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, h_obj); 2838JVM_END 2839 2840 2841JVM_ENTRY(void, JVM_DumpAllStacks(JNIEnv* env, jclass)) 2842 JVMWrapper("JVM_DumpAllStacks"); 2843 VM_PrintThreads op; 2844 VMThread::execute(&op); 2845 if (JvmtiExport::should_post_data_dump()) { 2846 JvmtiExport::post_data_dump(); 2847 } 2848JVM_END 2849 2850 2851// java.lang.SecurityManager /////////////////////////////////////////////////////////////////////// 2852 2853static bool is_trusted_frame(JavaThread* jthread, vframeStream* vfst) { 2854 assert(jthread->is_Java_thread(), "must be a Java thread"); 2855 if (jthread->privileged_stack_top() == NULL) return false; 2856 if (jthread->privileged_stack_top()->frame_id() == vfst->frame_id()) { 2857 oop loader = jthread->privileged_stack_top()->class_loader(); 2858 if (loader == NULL) return true; 2859 bool trusted = java_lang_ClassLoader::is_trusted_loader(loader); 2860 if (trusted) return true; 2861 } 2862 return false; 2863} 2864 2865JVM_ENTRY(jclass, JVM_CurrentLoadedClass(JNIEnv *env)) 2866 JVMWrapper("JVM_CurrentLoadedClass"); 2867 ResourceMark rm(THREAD); 2868 2869 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { 2870 // if a method in a class in a trusted loader is in a doPrivileged, return NULL 2871 bool trusted = is_trusted_frame(thread, &vfst); 2872 if (trusted) return NULL; 2873 2874 methodOop m = vfst.method(); 2875 if (!m->is_native()) { 2876 klassOop holder = m->method_holder(); 2877 oop loader = instanceKlass::cast(holder)->class_loader(); 2878 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { 2879 return (jclass) JNIHandles::make_local(env, Klass::cast(holder)->java_mirror()); 2880 } 2881 } 2882 } 2883 return NULL; 2884JVM_END 2885 2886 2887JVM_ENTRY(jobject, JVM_CurrentClassLoader(JNIEnv *env)) 2888 JVMWrapper("JVM_CurrentClassLoader"); 2889 ResourceMark rm(THREAD); 2890 2891 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { 2892 2893 // if a method in a class in a trusted loader is in a doPrivileged, return NULL 2894 bool trusted = is_trusted_frame(thread, &vfst); 2895 if (trusted) return NULL; 2896 2897 methodOop m = vfst.method(); 2898 if (!m->is_native()) { 2899 klassOop holder = m->method_holder(); 2900 assert(holder->is_klass(), "just checking"); 2901 oop loader = instanceKlass::cast(holder)->class_loader(); 2902 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { 2903 return JNIHandles::make_local(env, loader); 2904 } 2905 } 2906 } 2907 return NULL; 2908JVM_END 2909 2910 2911// Utility object for collecting method holders walking down the stack 2912class KlassLink: public ResourceObj { 2913 public: 2914 KlassHandle klass; 2915 KlassLink* next; 2916 2917 KlassLink(KlassHandle k) { klass = k; next = NULL; } 2918}; 2919 2920 2921JVM_ENTRY(jobjectArray, JVM_GetClassContext(JNIEnv *env)) 2922 JVMWrapper("JVM_GetClassContext"); 2923 ResourceMark rm(THREAD); 2924 JvmtiVMObjectAllocEventCollector oam; 2925 // Collect linked list of (handles to) method holders 2926 KlassLink* first = NULL; 2927 KlassLink* last = NULL; 2928 int depth = 0; 2929 2930 for(vframeStream vfst(thread); !vfst.at_end(); vfst.security_get_caller_frame(1)) { 2931 // Native frames are not returned 2932 if (!vfst.method()->is_native()) { 2933 klassOop holder = vfst.method()->method_holder(); 2934 assert(holder->is_klass(), "just checking"); 2935 depth++; 2936 KlassLink* l = new KlassLink(KlassHandle(thread, holder)); 2937 if (first == NULL) { 2938 first = last = l; 2939 } else { 2940 last->next = l; 2941 last = l; 2942 } 2943 } 2944 } 2945 2946 // Create result array of type [Ljava/lang/Class; 2947 objArrayOop result = oopFactory::new_objArray(SystemDictionary::class_klass(), depth, CHECK_NULL); 2948 // Fill in mirrors corresponding to method holders 2949 int index = 0; 2950 while (first != NULL) { 2951 result->obj_at_put(index++, Klass::cast(first->klass())->java_mirror()); 2952 first = first->next; 2953 } 2954 assert(index == depth, "just checking"); 2955 2956 return (jobjectArray) JNIHandles::make_local(env, result); 2957JVM_END 2958 2959 2960JVM_ENTRY(jint, JVM_ClassDepth(JNIEnv *env, jstring name)) 2961 JVMWrapper("JVM_ClassDepth"); 2962 ResourceMark rm(THREAD); 2963 Handle h_name (THREAD, JNIHandles::resolve_non_null(name)); 2964 Handle class_name_str = java_lang_String::internalize_classname(h_name, CHECK_0); 2965 2966 const char* str = java_lang_String::as_utf8_string(class_name_str()); 2967 symbolHandle class_name_sym = 2968 symbolHandle(THREAD, SymbolTable::probe(str, (int)strlen(str))); 2969 if (class_name_sym.is_null()) { 2970 return -1; 2971 } 2972 2973 int depth = 0; 2974 2975 for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { 2976 if (!vfst.method()->is_native()) { 2977 klassOop holder = vfst.method()->method_holder(); 2978 assert(holder->is_klass(), "just checking"); 2979 if (instanceKlass::cast(holder)->name() == class_name_sym()) { 2980 return depth; 2981 } 2982 depth++; 2983 } 2984 } 2985 return -1; 2986JVM_END 2987 2988 2989JVM_ENTRY(jint, JVM_ClassLoaderDepth(JNIEnv *env)) 2990 JVMWrapper("JVM_ClassLoaderDepth"); 2991 ResourceMark rm(THREAD); 2992 int depth = 0; 2993 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { 2994 // if a method in a class in a trusted loader is in a doPrivileged, return -1 2995 bool trusted = is_trusted_frame(thread, &vfst); 2996 if (trusted) return -1; 2997 2998 methodOop m = vfst.method(); 2999 if (!m->is_native()) { 3000 klassOop holder = m->method_holder(); 3001 assert(holder->is_klass(), "just checking"); 3002 oop loader = instanceKlass::cast(holder)->class_loader(); 3003 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { 3004 return depth; 3005 } 3006 depth++; 3007 } 3008 } 3009 return -1; 3010JVM_END 3011 3012 3013// java.lang.Package //////////////////////////////////////////////////////////////// 3014 3015 3016JVM_ENTRY(jstring, JVM_GetSystemPackage(JNIEnv *env, jstring name)) 3017 JVMWrapper("JVM_GetSystemPackage"); 3018 ResourceMark rm(THREAD); 3019 JvmtiVMObjectAllocEventCollector oam; 3020 char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); 3021 oop result = ClassLoader::get_system_package(str, CHECK_NULL); 3022 return (jstring) JNIHandles::make_local(result); 3023JVM_END 3024 3025 3026JVM_ENTRY(jobjectArray, JVM_GetSystemPackages(JNIEnv *env)) 3027 JVMWrapper("JVM_GetSystemPackages"); 3028 JvmtiVMObjectAllocEventCollector oam; 3029 objArrayOop result = ClassLoader::get_system_packages(CHECK_NULL); 3030 return (jobjectArray) JNIHandles::make_local(result); 3031JVM_END 3032 3033 3034// ObjectInputStream /////////////////////////////////////////////////////////////// 3035 3036bool force_verify_field_access(klassOop current_class, klassOop field_class, AccessFlags access, bool classloader_only) { 3037 if (current_class == NULL) { 3038 return true; 3039 } 3040 if ((current_class == field_class) || access.is_public()) { 3041 return true; 3042 } 3043 3044 if (access.is_protected()) { 3045 // See if current_class is a subclass of field_class 3046 if (Klass::cast(current_class)->is_subclass_of(field_class)) { 3047 return true; 3048 } 3049 } 3050 3051 return (!access.is_private() && instanceKlass::cast(current_class)->is_same_class_package(field_class)); 3052} 3053 3054 3055// JVM_AllocateNewObject and JVM_AllocateNewArray are unused as of 1.4 3056JVM_ENTRY(jobject, JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)) 3057 JVMWrapper("JVM_AllocateNewObject"); 3058 JvmtiVMObjectAllocEventCollector oam; 3059 // Receiver is not used 3060 oop curr_mirror = JNIHandles::resolve_non_null(currClass); 3061 oop init_mirror = JNIHandles::resolve_non_null(initClass); 3062 3063 // Cannot instantiate primitive types 3064 if (java_lang_Class::is_primitive(curr_mirror) || java_lang_Class::is_primitive(init_mirror)) { 3065 ResourceMark rm(THREAD); 3066 THROW_0(vmSymbols::java_lang_InvalidClassException()); 3067 } 3068 3069 // Arrays not allowed here, must use JVM_AllocateNewArray 3070 if (Klass::cast(java_lang_Class::as_klassOop(curr_mirror))->oop_is_javaArray() || 3071 Klass::cast(java_lang_Class::as_klassOop(init_mirror))->oop_is_javaArray()) { 3072 ResourceMark rm(THREAD); 3073 THROW_0(vmSymbols::java_lang_InvalidClassException()); 3074 } 3075 3076 instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_klassOop(curr_mirror)); 3077 instanceKlassHandle init_klass (THREAD, java_lang_Class::as_klassOop(init_mirror)); 3078 3079 assert(curr_klass->is_subclass_of(init_klass()), "just checking"); 3080 3081 // Interfaces, abstract classes, and java.lang.Class classes cannot be instantiated directly. 3082 curr_klass->check_valid_for_instantiation(false, CHECK_NULL); 3083 3084 // Make sure klass is initialized, since we are about to instantiate one of them. 3085 curr_klass->initialize(CHECK_NULL); 3086 3087 methodHandle m (THREAD, 3088 init_klass->find_method(vmSymbols::object_initializer_name(), 3089 vmSymbols::void_method_signature())); 3090 if (m.is_null()) { 3091 ResourceMark rm(THREAD); 3092 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), 3093 methodOopDesc::name_and_sig_as_C_string(Klass::cast(init_klass()), 3094 vmSymbols::object_initializer_name(), 3095 vmSymbols::void_method_signature())); 3096 } 3097 3098 if (curr_klass == init_klass && !m->is_public()) { 3099 // Calling the constructor for class 'curr_klass'. 3100 // Only allow calls to a public no-arg constructor. 3101 // This path corresponds to creating an Externalizable object. 3102 THROW_0(vmSymbols::java_lang_IllegalAccessException()); 3103 } 3104 3105 if (!force_verify_field_access(curr_klass(), init_klass(), m->access_flags(), false)) { 3106 // subclass 'curr_klass' does not have access to no-arg constructor of 'initcb' 3107 THROW_0(vmSymbols::java_lang_IllegalAccessException()); 3108 } 3109 3110 Handle obj = curr_klass->allocate_instance_handle(CHECK_NULL); 3111 // Call constructor m. This might call a constructor higher up in the hierachy 3112 JavaCalls::call_default_constructor(thread, m, obj, CHECK_NULL); 3113 3114 return JNIHandles::make_local(obj()); 3115JVM_END 3116 3117 3118JVM_ENTRY(jobject, JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)) 3119 JVMWrapper("JVM_AllocateNewArray"); 3120 JvmtiVMObjectAllocEventCollector oam; 3121 oop mirror = JNIHandles::resolve_non_null(currClass); 3122 3123 if (java_lang_Class::is_primitive(mirror)) { 3124 THROW_0(vmSymbols::java_lang_InvalidClassException()); 3125 } 3126 klassOop k = java_lang_Class::as_klassOop(mirror); 3127 oop result; 3128 3129 if (k->klass_part()->oop_is_typeArray()) { 3130 // typeArray 3131 result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL); 3132 } else if (k->klass_part()->oop_is_objArray()) { 3133 // objArray 3134 objArrayKlassHandle oak(THREAD, k); 3135 oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior) 3136 result = oak->allocate(length, CHECK_NULL); 3137 } else { 3138 THROW_0(vmSymbols::java_lang_InvalidClassException()); 3139 } 3140 return JNIHandles::make_local(env, result); 3141JVM_END 3142 3143 3144// Return the first non-null class loader up the execution stack, or null 3145// if only code from the null class loader is on the stack. 3146 3147JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env)) 3148 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { 3149 // UseNewReflection 3150 vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection 3151 klassOop holder = vfst.method()->method_holder(); 3152 oop loader = instanceKlass::cast(holder)->class_loader(); 3153 if (loader != NULL) { 3154 return JNIHandles::make_local(env, loader); 3155 } 3156 } 3157 return NULL; 3158JVM_END 3159 3160 3161// Load a class relative to the most recent class on the stack with a non-null 3162// classloader. 3163// This function has been deprecated and should not be considered part of the 3164// specified JVM interface. 3165 3166JVM_ENTRY(jclass, JVM_LoadClass0(JNIEnv *env, jobject receiver, 3167 jclass currClass, jstring currClassName)) 3168 JVMWrapper("JVM_LoadClass0"); 3169 // Receiver is not used 3170 ResourceMark rm(THREAD); 3171 3172 // Class name argument is not guaranteed to be in internal format 3173 Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName)); 3174 Handle string = java_lang_String::internalize_classname(classname, CHECK_NULL); 3175 3176 const char* str = java_lang_String::as_utf8_string(string()); 3177 3178 if (str == NULL || (int)strlen(str) > symbolOopDesc::max_length()) { 3179 // It's impossible to create this class; the name cannot fit 3180 // into the constant pool. 3181 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), str); 3182 } 3183 3184 symbolHandle name = oopFactory::new_symbol_handle(str, CHECK_NULL); 3185 Handle curr_klass (THREAD, JNIHandles::resolve(currClass)); 3186 // Find the most recent class on the stack with a non-null classloader 3187 oop loader = NULL; 3188 oop protection_domain = NULL; 3189 if (curr_klass.is_null()) { 3190 for (vframeStream vfst(thread); 3191 !vfst.at_end() && loader == NULL; 3192 vfst.next()) { 3193 if (!vfst.method()->is_native()) { 3194 klassOop holder = vfst.method()->method_holder(); 3195 loader = instanceKlass::cast(holder)->class_loader(); 3196 protection_domain = instanceKlass::cast(holder)->protection_domain(); 3197 } 3198 } 3199 } else { 3200 klassOop curr_klass_oop = java_lang_Class::as_klassOop(curr_klass()); 3201 loader = instanceKlass::cast(curr_klass_oop)->class_loader(); 3202 protection_domain = instanceKlass::cast(curr_klass_oop)->protection_domain(); 3203 } 3204 Handle h_loader(THREAD, loader); 3205 Handle h_prot (THREAD, protection_domain); 3206 return find_class_from_class_loader(env, name, true, h_loader, h_prot, 3207 false, thread); 3208JVM_END 3209 3210 3211// Array /////////////////////////////////////////////////////////////////////////////////////////// 3212 3213 3214// resolve array handle and check arguments 3215static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) { 3216 if (arr == NULL) { 3217 THROW_0(vmSymbols::java_lang_NullPointerException()); 3218 } 3219 oop a = JNIHandles::resolve_non_null(arr); 3220 if (!a->is_javaArray() || (type_array_only && !a->is_typeArray())) { 3221 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array"); 3222 } 3223 return arrayOop(a); 3224} 3225 3226 3227JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr)) 3228 JVMWrapper("JVM_GetArrayLength"); 3229 arrayOop a = check_array(env, arr, false, CHECK_0); 3230 return a->length(); 3231JVM_END 3232 3233 3234JVM_ENTRY(jobject, JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)) 3235 JVMWrapper("JVM_Array_Get"); 3236 JvmtiVMObjectAllocEventCollector oam; 3237 arrayOop a = check_array(env, arr, false, CHECK_NULL); 3238 jvalue value; 3239 BasicType type = Reflection::array_get(&value, a, index, CHECK_NULL); 3240 oop box = Reflection::box(&value, type, CHECK_NULL); 3241 return JNIHandles::make_local(env, box); 3242JVM_END 3243 3244 3245JVM_ENTRY(jvalue, JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)) 3246 JVMWrapper("JVM_GetPrimitiveArrayElement"); 3247 jvalue value; 3248 value.i = 0; // to initialize value before getting used in CHECK 3249 arrayOop a = check_array(env, arr, true, CHECK_(value)); 3250 assert(a->is_typeArray(), "just checking"); 3251 BasicType type = Reflection::array_get(&value, a, index, CHECK_(value)); 3252 BasicType wide_type = (BasicType) wCode; 3253 if (type != wide_type) { 3254 Reflection::widen(&value, type, wide_type, CHECK_(value)); 3255 } 3256 return value; 3257JVM_END 3258 3259 3260JVM_ENTRY(void, JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)) 3261 JVMWrapper("JVM_SetArrayElement"); 3262 arrayOop a = check_array(env, arr, false, CHECK); 3263 oop box = JNIHandles::resolve(val); 3264 jvalue value; 3265 value.i = 0; // to initialize value before getting used in CHECK 3266 BasicType value_type; 3267 if (a->is_objArray()) { 3268 // Make sure we do no unbox e.g. java/lang/Integer instances when storing into an object array 3269 value_type = Reflection::unbox_for_regular_object(box, &value); 3270 } else { 3271 value_type = Reflection::unbox_for_primitive(box, &value, CHECK); 3272 } 3273 Reflection::array_set(&value, a, index, value_type, CHECK); 3274JVM_END 3275 3276 3277JVM_ENTRY(void, JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)) 3278 JVMWrapper("JVM_SetPrimitiveArrayElement"); 3279 arrayOop a = check_array(env, arr, true, CHECK); 3280 assert(a->is_typeArray(), "just checking"); 3281 BasicType value_type = (BasicType) vCode; 3282 Reflection::array_set(&v, a, index, value_type, CHECK); 3283JVM_END 3284 3285 3286JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)) 3287 JVMWrapper("JVM_NewArray"); 3288 JvmtiVMObjectAllocEventCollector oam; 3289 oop element_mirror = JNIHandles::resolve(eltClass); 3290 oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL); 3291 return JNIHandles::make_local(env, result); 3292JVM_END 3293 3294 3295JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)) 3296 JVMWrapper("JVM_NewMultiArray"); 3297 JvmtiVMObjectAllocEventCollector oam; 3298 arrayOop dim_array = check_array(env, dim, true, CHECK_NULL); 3299 oop element_mirror = JNIHandles::resolve(eltClass); 3300 assert(dim_array->is_typeArray(), "just checking"); 3301 oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL); 3302 return JNIHandles::make_local(env, result); 3303JVM_END 3304 3305 3306// Networking library support //////////////////////////////////////////////////////////////////// 3307 3308JVM_LEAF(jint, JVM_InitializeSocketLibrary()) 3309 JVMWrapper("JVM_InitializeSocketLibrary"); 3310 return hpi::initialize_socket_library(); 3311JVM_END 3312 3313 3314JVM_LEAF(jint, JVM_Socket(jint domain, jint type, jint protocol)) 3315 JVMWrapper("JVM_Socket"); 3316 return hpi::socket(domain, type, protocol); 3317JVM_END 3318 3319 3320JVM_LEAF(jint, JVM_SocketClose(jint fd)) 3321 JVMWrapper2("JVM_SocketClose (0x%x)", fd); 3322 //%note jvm_r6 3323 return hpi::socket_close(fd); 3324JVM_END 3325 3326 3327JVM_LEAF(jint, JVM_SocketShutdown(jint fd, jint howto)) 3328 JVMWrapper2("JVM_SocketShutdown (0x%x)", fd); 3329 //%note jvm_r6 3330 return hpi::socket_shutdown(fd, howto); 3331JVM_END 3332 3333 3334JVM_LEAF(jint, JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)) 3335 JVMWrapper2("JVM_Recv (0x%x)", fd); 3336 //%note jvm_r6 3337 return hpi::recv(fd, buf, nBytes, flags); 3338JVM_END 3339 3340 3341JVM_LEAF(jint, JVM_Send(jint fd, char *buf, jint nBytes, jint flags)) 3342 JVMWrapper2("JVM_Send (0x%x)", fd); 3343 //%note jvm_r6 3344 return hpi::send(fd, buf, nBytes, flags); 3345JVM_END 3346 3347 3348JVM_LEAF(jint, JVM_Timeout(int fd, long timeout)) 3349 JVMWrapper2("JVM_Timeout (0x%x)", fd); 3350 //%note jvm_r6 3351 return hpi::timeout(fd, timeout); 3352JVM_END 3353 3354 3355JVM_LEAF(jint, JVM_Listen(jint fd, jint count)) 3356 JVMWrapper2("JVM_Listen (0x%x)", fd); 3357 //%note jvm_r6 3358 return hpi::listen(fd, count); 3359JVM_END 3360 3361 3362JVM_LEAF(jint, JVM_Connect(jint fd, struct sockaddr *him, jint len)) 3363 JVMWrapper2("JVM_Connect (0x%x)", fd); 3364 //%note jvm_r6 3365 return hpi::connect(fd, him, len); 3366JVM_END 3367 3368 3369JVM_LEAF(jint, JVM_Bind(jint fd, struct sockaddr *him, jint len)) 3370 JVMWrapper2("JVM_Bind (0x%x)", fd); 3371 //%note jvm_r6 3372 return hpi::bind(fd, him, len); 3373JVM_END 3374 3375 3376JVM_LEAF(jint, JVM_Accept(jint fd, struct sockaddr *him, jint *len)) 3377 JVMWrapper2("JVM_Accept (0x%x)", fd); 3378 //%note jvm_r6 3379 return hpi::accept(fd, him, (int *)len); 3380JVM_END 3381 3382 3383JVM_LEAF(jint, JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)) 3384 JVMWrapper2("JVM_RecvFrom (0x%x)", fd); 3385 //%note jvm_r6 3386 return hpi::recvfrom(fd, buf, nBytes, flags, from, fromlen); 3387JVM_END 3388 3389 3390JVM_LEAF(jint, JVM_GetSockName(jint fd, struct sockaddr *him, int *len)) 3391 JVMWrapper2("JVM_GetSockName (0x%x)", fd); 3392 //%note jvm_r6 3393 return hpi::get_sock_name(fd, him, len); 3394JVM_END 3395 3396 3397JVM_LEAF(jint, JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)) 3398 JVMWrapper2("JVM_SendTo (0x%x)", fd); 3399 //%note jvm_r6 3400 return hpi::sendto(fd, buf, len, flags, to, tolen); 3401JVM_END 3402 3403 3404JVM_LEAF(jint, JVM_SocketAvailable(jint fd, jint *pbytes)) 3405 JVMWrapper2("JVM_SocketAvailable (0x%x)", fd); 3406 //%note jvm_r6 3407 return hpi::socket_available(fd, pbytes); 3408JVM_END 3409 3410 3411JVM_LEAF(jint, JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)) 3412 JVMWrapper2("JVM_GetSockOpt (0x%x)", fd); 3413 //%note jvm_r6 3414 return hpi::get_sock_opt(fd, level, optname, optval, optlen); 3415JVM_END 3416 3417 3418JVM_LEAF(jint, JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)) 3419 JVMWrapper2("JVM_GetSockOpt (0x%x)", fd); 3420 //%note jvm_r6 3421 return hpi::set_sock_opt(fd, level, optname, optval, optlen); 3422JVM_END 3423 3424JVM_LEAF(int, JVM_GetHostName(char* name, int namelen)) 3425 JVMWrapper("JVM_GetHostName"); 3426 return hpi::get_host_name(name, namelen); 3427JVM_END 3428 3429#ifdef _WINDOWS 3430 3431JVM_LEAF(struct hostent*, JVM_GetHostByAddr(const char* name, int len, int type)) 3432 JVMWrapper("JVM_GetHostByAddr"); 3433 return hpi::get_host_by_addr(name, len, type); 3434JVM_END 3435 3436 3437JVM_LEAF(struct hostent*, JVM_GetHostByName(char* name)) 3438 JVMWrapper("JVM_GetHostByName"); 3439 return hpi::get_host_by_name(name); 3440JVM_END 3441 3442 3443JVM_LEAF(struct protoent*, JVM_GetProtoByName(char* name)) 3444 JVMWrapper("JVM_GetProtoByName"); 3445 return hpi::get_proto_by_name(name); 3446JVM_END 3447 3448#endif 3449 3450// Library support /////////////////////////////////////////////////////////////////////////// 3451 3452JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name)) 3453 //%note jvm_ct 3454 JVMWrapper2("JVM_LoadLibrary (%s)", name); 3455 char ebuf[1024]; 3456 void *load_result; 3457 { 3458 ThreadToNativeFromVM ttnfvm(thread); 3459 load_result = hpi::dll_load(name, ebuf, sizeof ebuf); 3460 } 3461 if (load_result == NULL) { 3462 char msg[1024]; 3463 jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf); 3464 // Since 'ebuf' may contain a string encoded using 3465 // platform encoding scheme, we need to pass 3466 // Exceptions::unsafe_to_utf8 to the new_exception method 3467 // as the last argument. See bug 6367357. 3468 Handle h_exception = 3469 Exceptions::new_exception(thread, 3470 vmSymbols::java_lang_UnsatisfiedLinkError(), 3471 msg, Exceptions::unsafe_to_utf8); 3472 3473 THROW_HANDLE_0(h_exception); 3474 } 3475 return load_result; 3476JVM_END 3477 3478 3479JVM_LEAF(void, JVM_UnloadLibrary(void* handle)) 3480 JVMWrapper("JVM_UnloadLibrary"); 3481 hpi::dll_unload(handle); 3482JVM_END 3483 3484 3485JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name)) 3486 JVMWrapper2("JVM_FindLibraryEntry (%s)", name); 3487 return hpi::dll_lookup(handle, name); 3488JVM_END 3489 3490// Floating point support //////////////////////////////////////////////////////////////////// 3491 3492JVM_LEAF(jboolean, JVM_IsNaN(jdouble a)) 3493 JVMWrapper("JVM_IsNaN"); 3494 return g_isnan(a); 3495JVM_END 3496 3497 3498 3499// JNI version /////////////////////////////////////////////////////////////////////////////// 3500 3501JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version)) 3502 JVMWrapper2("JVM_IsSupportedJNIVersion (%d)", version); 3503 return Threads::is_supported_jni_version_including_1_1(version); 3504JVM_END 3505 3506 3507// String support /////////////////////////////////////////////////////////////////////////// 3508 3509JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str)) 3510 JVMWrapper("JVM_InternString"); 3511 JvmtiVMObjectAllocEventCollector oam; 3512 if (str == NULL) return NULL; 3513 oop string = JNIHandles::resolve_non_null(str); 3514 oop result = StringTable::intern(string, CHECK_NULL); 3515 return (jstring) JNIHandles::make_local(env, result); 3516JVM_END 3517 3518 3519// Raw monitor support ////////////////////////////////////////////////////////////////////// 3520 3521// The lock routine below calls lock_without_safepoint_check in order to get a raw lock 3522// without interfering with the safepoint mechanism. The routines are not JVM_LEAF because 3523// they might be called by non-java threads. The JVM_LEAF installs a NoHandleMark check 3524// that only works with java threads. 3525 3526 3527JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void) { 3528 VM_Exit::block_if_vm_exited(); 3529 JVMWrapper("JVM_RawMonitorCreate"); 3530 return new Mutex(Mutex::native, "JVM_RawMonitorCreate"); 3531} 3532 3533 3534JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon) { 3535 VM_Exit::block_if_vm_exited(); 3536 JVMWrapper("JVM_RawMonitorDestroy"); 3537 delete ((Mutex*) mon); 3538} 3539 3540 3541JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon) { 3542 VM_Exit::block_if_vm_exited(); 3543 JVMWrapper("JVM_RawMonitorEnter"); 3544 ((Mutex*) mon)->jvm_raw_lock(); 3545 return 0; 3546} 3547 3548 3549JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon) { 3550 VM_Exit::block_if_vm_exited(); 3551 JVMWrapper("JVM_RawMonitorExit"); 3552 ((Mutex*) mon)->jvm_raw_unlock(); 3553} 3554 3555 3556// Support for Serialization 3557 3558typedef jfloat (JNICALL *IntBitsToFloatFn )(JNIEnv* env, jclass cb, jint value); 3559typedef jdouble (JNICALL *LongBitsToDoubleFn)(JNIEnv* env, jclass cb, jlong value); 3560typedef jint (JNICALL *FloatToIntBitsFn )(JNIEnv* env, jclass cb, jfloat value); 3561typedef jlong (JNICALL *DoubleToLongBitsFn)(JNIEnv* env, jclass cb, jdouble value); 3562 3563static IntBitsToFloatFn int_bits_to_float_fn = NULL; 3564static LongBitsToDoubleFn long_bits_to_double_fn = NULL; 3565static FloatToIntBitsFn float_to_int_bits_fn = NULL; 3566static DoubleToLongBitsFn double_to_long_bits_fn = NULL; 3567 3568 3569void initialize_converter_functions() { 3570 if (JDK_Version::is_gte_jdk14x_version()) { 3571 // These functions only exist for compatibility with 1.3.1 and earlier 3572 return; 3573 } 3574 3575 // called from universe_post_init() 3576 assert( 3577 int_bits_to_float_fn == NULL && 3578 long_bits_to_double_fn == NULL && 3579 float_to_int_bits_fn == NULL && 3580 double_to_long_bits_fn == NULL , 3581 "initialization done twice" 3582 ); 3583 // initialize 3584 int_bits_to_float_fn = CAST_TO_FN_PTR(IntBitsToFloatFn , NativeLookup::base_library_lookup("java/lang/Float" , "intBitsToFloat" , "(I)F")); 3585 long_bits_to_double_fn = CAST_TO_FN_PTR(LongBitsToDoubleFn, NativeLookup::base_library_lookup("java/lang/Double", "longBitsToDouble", "(J)D")); 3586 float_to_int_bits_fn = CAST_TO_FN_PTR(FloatToIntBitsFn , NativeLookup::base_library_lookup("java/lang/Float" , "floatToIntBits" , "(F)I")); 3587 double_to_long_bits_fn = CAST_TO_FN_PTR(DoubleToLongBitsFn, NativeLookup::base_library_lookup("java/lang/Double", "doubleToLongBits", "(D)J")); 3588 // verify 3589 assert( 3590 int_bits_to_float_fn != NULL && 3591 long_bits_to_double_fn != NULL && 3592 float_to_int_bits_fn != NULL && 3593 double_to_long_bits_fn != NULL , 3594 "initialization failed" 3595 ); 3596} 3597 3598 3599// Serialization 3600JVM_ENTRY(void, JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, 3601 jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)) 3602 assert(!JDK_Version::is_gte_jdk14x_version(), "should only be used in 1.3.1 and earlier"); 3603 3604 typeArrayOop tcodes = typeArrayOop(JNIHandles::resolve(typecodes)); 3605 typeArrayOop dbuf = typeArrayOop(JNIHandles::resolve(data)); 3606 typeArrayOop fids = typeArrayOop(JNIHandles::resolve(fieldIDs)); 3607 oop o = JNIHandles::resolve(obj); 3608 3609 if (o == NULL || fids == NULL || dbuf == NULL || tcodes == NULL) { 3610 THROW(vmSymbols::java_lang_NullPointerException()); 3611 } 3612 3613 jsize nfids = fids->length(); 3614 if (nfids == 0) return; 3615 3616 if (tcodes->length() < nfids) { 3617 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); 3618 } 3619 3620 jsize off = 0; 3621 /* loop through fields, setting values */ 3622 for (jsize i = 0; i < nfids; i++) { 3623 jfieldID fid = (jfieldID)(intptr_t) fids->long_at(i); 3624 int field_offset; 3625 if (fid != NULL) { 3626 // NULL is a legal value for fid, but retrieving the field offset 3627 // trigger assertion in that case 3628 field_offset = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid); 3629 } 3630 3631 switch (tcodes->char_at(i)) { 3632 case 'Z': 3633 if (fid != NULL) { 3634 jboolean val = (dbuf->byte_at(off) != 0) ? JNI_TRUE : JNI_FALSE; 3635 o->bool_field_put(field_offset, val); 3636 } 3637 off++; 3638 break; 3639 3640 case 'B': 3641 if (fid != NULL) { 3642 o->byte_field_put(field_offset, dbuf->byte_at(off)); 3643 } 3644 off++; 3645 break; 3646 3647 case 'C': 3648 if (fid != NULL) { 3649 jchar val = ((dbuf->byte_at(off + 0) & 0xFF) << 8) 3650 + ((dbuf->byte_at(off + 1) & 0xFF) << 0); 3651 o->char_field_put(field_offset, val); 3652 } 3653 off += 2; 3654 break; 3655 3656 case 'S': 3657 if (fid != NULL) { 3658 jshort val = ((dbuf->byte_at(off + 0) & 0xFF) << 8) 3659 + ((dbuf->byte_at(off + 1) & 0xFF) << 0); 3660 o->short_field_put(field_offset, val); 3661 } 3662 off += 2; 3663 break; 3664 3665 case 'I': 3666 if (fid != NULL) { 3667 jint ival = ((dbuf->byte_at(off + 0) & 0xFF) << 24) 3668 + ((dbuf->byte_at(off + 1) & 0xFF) << 16) 3669 + ((dbuf->byte_at(off + 2) & 0xFF) << 8) 3670 + ((dbuf->byte_at(off + 3) & 0xFF) << 0); 3671 o->int_field_put(field_offset, ival); 3672 } 3673 off += 4; 3674 break; 3675 3676 case 'F': 3677 if (fid != NULL) { 3678 jint ival = ((dbuf->byte_at(off + 0) & 0xFF) << 24) 3679 + ((dbuf->byte_at(off + 1) & 0xFF) << 16) 3680 + ((dbuf->byte_at(off + 2) & 0xFF) << 8) 3681 + ((dbuf->byte_at(off + 3) & 0xFF) << 0); 3682 jfloat fval = (*int_bits_to_float_fn)(env, NULL, ival); 3683 o->float_field_put(field_offset, fval); 3684 } 3685 off += 4; 3686 break; 3687 3688 case 'J': 3689 if (fid != NULL) { 3690 jlong lval = (((jlong) dbuf->byte_at(off + 0) & 0xFF) << 56) 3691 + (((jlong) dbuf->byte_at(off + 1) & 0xFF) << 48) 3692 + (((jlong) dbuf->byte_at(off + 2) & 0xFF) << 40) 3693 + (((jlong) dbuf->byte_at(off + 3) & 0xFF) << 32) 3694 + (((jlong) dbuf->byte_at(off + 4) & 0xFF) << 24) 3695 + (((jlong) dbuf->byte_at(off + 5) & 0xFF) << 16) 3696 + (((jlong) dbuf->byte_at(off + 6) & 0xFF) << 8) 3697 + (((jlong) dbuf->byte_at(off + 7) & 0xFF) << 0); 3698 o->long_field_put(field_offset, lval); 3699 } 3700 off += 8; 3701 break; 3702 3703 case 'D': 3704 if (fid != NULL) { 3705 jlong lval = (((jlong) dbuf->byte_at(off + 0) & 0xFF) << 56) 3706 + (((jlong) dbuf->byte_at(off + 1) & 0xFF) << 48) 3707 + (((jlong) dbuf->byte_at(off + 2) & 0xFF) << 40) 3708 + (((jlong) dbuf->byte_at(off + 3) & 0xFF) << 32) 3709 + (((jlong) dbuf->byte_at(off + 4) & 0xFF) << 24) 3710 + (((jlong) dbuf->byte_at(off + 5) & 0xFF) << 16) 3711 + (((jlong) dbuf->byte_at(off + 6) & 0xFF) << 8) 3712 + (((jlong) dbuf->byte_at(off + 7) & 0xFF) << 0); 3713 jdouble dval = (*long_bits_to_double_fn)(env, NULL, lval); 3714 o->double_field_put(field_offset, dval); 3715 } 3716 off += 8; 3717 break; 3718 3719 default: 3720 // Illegal typecode 3721 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "illegal typecode"); 3722 } 3723 } 3724JVM_END 3725 3726 3727JVM_ENTRY(void, JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, 3728 jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)) 3729 assert(!JDK_Version::is_gte_jdk14x_version(), "should only be used in 1.3.1 and earlier"); 3730 3731 typeArrayOop tcodes = typeArrayOop(JNIHandles::resolve(typecodes)); 3732 typeArrayOop dbuf = typeArrayOop(JNIHandles::resolve(data)); 3733 typeArrayOop fids = typeArrayOop(JNIHandles::resolve(fieldIDs)); 3734 oop o = JNIHandles::resolve(obj); 3735 3736 if (o == NULL || fids == NULL || dbuf == NULL || tcodes == NULL) { 3737 THROW(vmSymbols::java_lang_NullPointerException()); 3738 } 3739 3740 jsize nfids = fids->length(); 3741 if (nfids == 0) return; 3742 3743 if (tcodes->length() < nfids) { 3744 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); 3745 } 3746 3747 /* loop through fields, fetching values */ 3748 jsize off = 0; 3749 for (jsize i = 0; i < nfids; i++) { 3750 jfieldID fid = (jfieldID)(intptr_t) fids->long_at(i); 3751 if (fid == NULL) { 3752 THROW(vmSymbols::java_lang_NullPointerException()); 3753 } 3754 int field_offset = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid); 3755 3756 switch (tcodes->char_at(i)) { 3757 case 'Z': 3758 { 3759 jboolean val = o->bool_field(field_offset); 3760 dbuf->byte_at_put(off++, (val != 0) ? 1 : 0); 3761 } 3762 break; 3763 3764 case 'B': 3765 dbuf->byte_at_put(off++, o->byte_field(field_offset)); 3766 break; 3767 3768 case 'C': 3769 { 3770 jchar val = o->char_field(field_offset); 3771 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); 3772 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); 3773 } 3774 break; 3775 3776 case 'S': 3777 { 3778 jshort val = o->short_field(field_offset); 3779 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); 3780 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); 3781 } 3782 break; 3783 3784 case 'I': 3785 { 3786 jint val = o->int_field(field_offset); 3787 dbuf->byte_at_put(off++, (val >> 24) & 0xFF); 3788 dbuf->byte_at_put(off++, (val >> 16) & 0xFF); 3789 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); 3790 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); 3791 } 3792 break; 3793 3794 case 'F': 3795 { 3796 jfloat fval = o->float_field(field_offset); 3797 jint ival = (*float_to_int_bits_fn)(env, NULL, fval); 3798 dbuf->byte_at_put(off++, (ival >> 24) & 0xFF); 3799 dbuf->byte_at_put(off++, (ival >> 16) & 0xFF); 3800 dbuf->byte_at_put(off++, (ival >> 8) & 0xFF); 3801 dbuf->byte_at_put(off++, (ival >> 0) & 0xFF); 3802 } 3803 break; 3804 3805 case 'J': 3806 { 3807 jlong val = o->long_field(field_offset); 3808 dbuf->byte_at_put(off++, (val >> 56) & 0xFF); 3809 dbuf->byte_at_put(off++, (val >> 48) & 0xFF); 3810 dbuf->byte_at_put(off++, (val >> 40) & 0xFF); 3811 dbuf->byte_at_put(off++, (val >> 32) & 0xFF); 3812 dbuf->byte_at_put(off++, (val >> 24) & 0xFF); 3813 dbuf->byte_at_put(off++, (val >> 16) & 0xFF); 3814 dbuf->byte_at_put(off++, (val >> 8) & 0xFF); 3815 dbuf->byte_at_put(off++, (val >> 0) & 0xFF); 3816 } 3817 break; 3818 3819 case 'D': 3820 { 3821 jdouble dval = o->double_field(field_offset); 3822 jlong lval = (*double_to_long_bits_fn)(env, NULL, dval); 3823 dbuf->byte_at_put(off++, (lval >> 56) & 0xFF); 3824 dbuf->byte_at_put(off++, (lval >> 48) & 0xFF); 3825 dbuf->byte_at_put(off++, (lval >> 40) & 0xFF); 3826 dbuf->byte_at_put(off++, (lval >> 32) & 0xFF); 3827 dbuf->byte_at_put(off++, (lval >> 24) & 0xFF); 3828 dbuf->byte_at_put(off++, (lval >> 16) & 0xFF); 3829 dbuf->byte_at_put(off++, (lval >> 8) & 0xFF); 3830 dbuf->byte_at_put(off++, (lval >> 0) & 0xFF); 3831 } 3832 break; 3833 3834 default: 3835 // Illegal typecode 3836 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "illegal typecode"); 3837 } 3838 } 3839JVM_END 3840 3841 3842// Shared JNI/JVM entry points ////////////////////////////////////////////////////////////// 3843 3844jclass find_class_from_class_loader(JNIEnv* env, symbolHandle name, jboolean init, Handle loader, Handle protection_domain, jboolean throwError, TRAPS) { 3845 // Security Note: 3846 // The Java level wrapper will perform the necessary security check allowing 3847 // us to pass the NULL as the initiating class loader. 3848 klassOop klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL); 3849 KlassHandle klass_handle(THREAD, klass); 3850 // Check if we should initialize the class 3851 if (init && klass_handle->oop_is_instance()) { 3852 klass_handle->initialize(CHECK_NULL); 3853 } 3854 return (jclass) JNIHandles::make_local(env, klass_handle->java_mirror()); 3855} 3856 3857 3858// Internal SQE debugging support /////////////////////////////////////////////////////////// 3859 3860#ifndef PRODUCT 3861 3862extern "C" { 3863 JNIEXPORT jboolean JNICALL JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get); 3864 JNIEXPORT jboolean JNICALL JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get); 3865 JNIEXPORT void JNICALL JVM_VMBreakPoint(JNIEnv *env, jobject obj); 3866} 3867 3868JVM_LEAF(jboolean, JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)) 3869 JVMWrapper("JVM_AccessBoolVMFlag"); 3870 return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, INTERNAL); 3871JVM_END 3872 3873JVM_LEAF(jboolean, JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)) 3874 JVMWrapper("JVM_AccessVMIntFlag"); 3875 intx v; 3876 jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, INTERNAL); 3877 *value = (jint)v; 3878 return result; 3879JVM_END 3880 3881 3882JVM_ENTRY(void, JVM_VMBreakPoint(JNIEnv *env, jobject obj)) 3883 JVMWrapper("JVM_VMBreakPoint"); 3884 oop the_obj = JNIHandles::resolve(obj); 3885 BREAKPOINT; 3886JVM_END 3887 3888 3889#endif 3890 3891 3892//--------------------------------------------------------------------------- 3893// 3894// Support for old native code-based reflection (pre-JDK 1.4) 3895// Disabled by default in the product build. 3896// 3897// See reflection.hpp for information on SUPPORT_OLD_REFLECTION 3898// 3899//--------------------------------------------------------------------------- 3900 3901#ifdef SUPPORT_OLD_REFLECTION 3902 3903JVM_ENTRY(jobjectArray, JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)) 3904 JVMWrapper("JVM_GetClassFields"); 3905 JvmtiVMObjectAllocEventCollector oam; 3906 oop mirror = JNIHandles::resolve_non_null(cls); 3907 objArrayOop result = Reflection::reflect_fields(mirror, which, CHECK_NULL); 3908 return (jobjectArray) JNIHandles::make_local(env, result); 3909JVM_END 3910 3911 3912JVM_ENTRY(jobjectArray, JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)) 3913 JVMWrapper("JVM_GetClassMethods"); 3914 JvmtiVMObjectAllocEventCollector oam; 3915 oop mirror = JNIHandles::resolve_non_null(cls); 3916 objArrayOop result = Reflection::reflect_methods(mirror, which, CHECK_NULL); 3917 //%note jvm_r4 3918 return (jobjectArray) JNIHandles::make_local(env, result); 3919JVM_END 3920 3921 3922JVM_ENTRY(jobjectArray, JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)) 3923 JVMWrapper("JVM_GetClassConstructors"); 3924 JvmtiVMObjectAllocEventCollector oam; 3925 oop mirror = JNIHandles::resolve_non_null(cls); 3926 objArrayOop result = Reflection::reflect_constructors(mirror, which, CHECK_NULL); 3927 //%note jvm_r4 3928 return (jobjectArray) JNIHandles::make_local(env, result); 3929JVM_END 3930 3931 3932JVM_ENTRY(jobject, JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)) 3933 JVMWrapper("JVM_GetClassField"); 3934 JvmtiVMObjectAllocEventCollector oam; 3935 if (name == NULL) return NULL; 3936 Handle str (THREAD, JNIHandles::resolve_non_null(name)); 3937 3938 const char* cstr = java_lang_String::as_utf8_string(str()); 3939 symbolHandle field_name = 3940 symbolHandle(THREAD, SymbolTable::probe(cstr, (int)strlen(cstr))); 3941 if (field_name.is_null()) { 3942 THROW_0(vmSymbols::java_lang_NoSuchFieldException()); 3943 } 3944 3945 oop mirror = JNIHandles::resolve_non_null(cls); 3946 oop result = Reflection::reflect_field(mirror, field_name(), which, CHECK_NULL); 3947 if (result == NULL) { 3948 THROW_0(vmSymbols::java_lang_NoSuchFieldException()); 3949 } 3950 return JNIHandles::make_local(env, result); 3951JVM_END 3952 3953 3954JVM_ENTRY(jobject, JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)) 3955 JVMWrapper("JVM_GetClassMethod"); 3956 JvmtiVMObjectAllocEventCollector oam; 3957 if (name == NULL) { 3958 THROW_0(vmSymbols::java_lang_NullPointerException()); 3959 } 3960 Handle str (THREAD, JNIHandles::resolve_non_null(name)); 3961 3962 const char* cstr = java_lang_String::as_utf8_string(str()); 3963 symbolHandle method_name = 3964 symbolHandle(THREAD, SymbolTable::probe(cstr, (int)strlen(cstr))); 3965 if (method_name.is_null()) { 3966 THROW_0(vmSymbols::java_lang_NoSuchMethodException()); 3967 } 3968 3969 oop mirror = JNIHandles::resolve_non_null(cls); 3970 objArrayHandle tarray (THREAD, objArrayOop(JNIHandles::resolve(types))); 3971 oop result = Reflection::reflect_method(mirror, method_name, tarray, 3972 which, CHECK_NULL); 3973 if (result == NULL) { 3974 THROW_0(vmSymbols::java_lang_NoSuchMethodException()); 3975 } 3976 return JNIHandles::make_local(env, result); 3977JVM_END 3978 3979 3980JVM_ENTRY(jobject, JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)) 3981 JVMWrapper("JVM_GetClassConstructor"); 3982 JvmtiVMObjectAllocEventCollector oam; 3983 oop mirror = JNIHandles::resolve_non_null(cls); 3984 objArrayHandle tarray (THREAD, objArrayOop(JNIHandles::resolve(types))); 3985 oop result = Reflection::reflect_constructor(mirror, tarray, which, CHECK_NULL); 3986 if (result == NULL) { 3987 THROW_0(vmSymbols::java_lang_NoSuchMethodException()); 3988 } 3989 return (jobject) JNIHandles::make_local(env, result); 3990JVM_END 3991 3992 3993// Instantiation /////////////////////////////////////////////////////////////////////////////// 3994 3995JVM_ENTRY(jobject, JVM_NewInstance(JNIEnv *env, jclass cls)) 3996 JVMWrapper("JVM_NewInstance"); 3997 Handle mirror(THREAD, JNIHandles::resolve_non_null(cls)); 3998 3999 methodOop resolved_constructor = java_lang_Class::resolved_constructor(mirror()); 4000 if (resolved_constructor == NULL) { 4001 klassOop k = java_lang_Class::as_klassOop(mirror()); 4002 // The java.lang.Class object caches a resolved constructor if all the checks 4003 // below were done successfully and a constructor was found. 4004 4005 // Do class based checks 4006 if (java_lang_Class::is_primitive(mirror())) { 4007 const char* msg = ""; 4008 if (mirror == Universe::bool_mirror()) msg = "java/lang/Boolean"; 4009 else if (mirror == Universe::char_mirror()) msg = "java/lang/Character"; 4010 else if (mirror == Universe::float_mirror()) msg = "java/lang/Float"; 4011 else if (mirror == Universe::double_mirror()) msg = "java/lang/Double"; 4012 else if (mirror == Universe::byte_mirror()) msg = "java/lang/Byte"; 4013 else if (mirror == Universe::short_mirror()) msg = "java/lang/Short"; 4014 else if (mirror == Universe::int_mirror()) msg = "java/lang/Integer"; 4015 else if (mirror == Universe::long_mirror()) msg = "java/lang/Long"; 4016 THROW_MSG_0(vmSymbols::java_lang_NullPointerException(), msg); 4017 } 4018 4019 // Check whether we are allowed to instantiate this class 4020 Klass::cast(k)->check_valid_for_instantiation(false, CHECK_NULL); // Array classes get caught here 4021 instanceKlassHandle klass(THREAD, k); 4022 // Make sure class is initialized (also so all methods are rewritten) 4023 klass->initialize(CHECK_NULL); 4024 4025 // Lookup default constructor 4026 resolved_constructor = klass->find_method(vmSymbols::object_initializer_name(), vmSymbols::void_method_signature()); 4027 if (resolved_constructor == NULL) { 4028 ResourceMark rm(THREAD); 4029 THROW_MSG_0(vmSymbols::java_lang_InstantiationException(), klass->external_name()); 4030 } 4031 4032 // Cache result in java.lang.Class object. Does not have to be MT safe. 4033 java_lang_Class::set_resolved_constructor(mirror(), resolved_constructor); 4034 } 4035 4036 assert(resolved_constructor != NULL, "sanity check"); 4037 methodHandle constructor = methodHandle(THREAD, resolved_constructor); 4038 4039 // We have an initialized instanceKlass with a default constructor 4040 instanceKlassHandle klass(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); 4041 assert(klass->is_initialized() || klass->is_being_initialized(), "sanity check"); 4042 4043 // Do security check 4044 klassOop caller_klass = NULL; 4045 if (UsePrivilegedStack) { 4046 caller_klass = thread->security_get_caller_class(2); 4047 4048 if (!Reflection::verify_class_access(caller_klass, klass(), false) || 4049 !Reflection::verify_field_access(caller_klass, 4050 klass(), 4051 klass(), 4052 constructor->access_flags(), 4053 false, 4054 true)) { 4055 ResourceMark rm(THREAD); 4056 THROW_MSG_0(vmSymbols::java_lang_IllegalAccessException(), klass->external_name()); 4057 } 4058 } 4059 4060 // Allocate object and call constructor 4061 Handle receiver = klass->allocate_instance_handle(CHECK_NULL); 4062 JavaCalls::call_default_constructor(thread, constructor, receiver, CHECK_NULL); 4063 4064 jobject res = JNIHandles::make_local(env, receiver()); 4065 if (JvmtiExport::should_post_vm_object_alloc()) { 4066 JvmtiExport::post_vm_object_alloc(JavaThread::current(), receiver()); 4067 } 4068 return res; 4069JVM_END 4070 4071 4072// Field //////////////////////////////////////////////////////////////////////////////////////////// 4073 4074JVM_ENTRY(jobject, JVM_GetField(JNIEnv *env, jobject field, jobject obj)) 4075 JVMWrapper("JVM_GetField"); 4076 JvmtiVMObjectAllocEventCollector oam; 4077 Handle field_mirror(thread, JNIHandles::resolve(field)); 4078 Handle receiver (thread, JNIHandles::resolve(obj)); 4079 fieldDescriptor fd; 4080 Reflection::resolve_field(field_mirror, receiver, &fd, false, CHECK_NULL); 4081 jvalue value; 4082 BasicType type = Reflection::field_get(&value, &fd, receiver); 4083 oop box = Reflection::box(&value, type, CHECK_NULL); 4084 return JNIHandles::make_local(env, box); 4085JVM_END 4086 4087 4088JVM_ENTRY(jvalue, JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)) 4089 JVMWrapper("JVM_GetPrimitiveField"); 4090 Handle field_mirror(thread, JNIHandles::resolve(field)); 4091 Handle receiver (thread, JNIHandles::resolve(obj)); 4092 fieldDescriptor fd; 4093 jvalue value; 4094 value.j = 0; 4095 Reflection::resolve_field(field_mirror, receiver, &fd, false, CHECK_(value)); 4096 BasicType type = Reflection::field_get(&value, &fd, receiver); 4097 BasicType wide_type = (BasicType) wCode; 4098 if (type != wide_type) { 4099 Reflection::widen(&value, type, wide_type, CHECK_(value)); 4100 } 4101 return value; 4102JVM_END // should really be JVM_END, but that doesn't work for union types! 4103 4104 4105JVM_ENTRY(void, JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)) 4106 JVMWrapper("JVM_SetField"); 4107 Handle field_mirror(thread, JNIHandles::resolve(field)); 4108 Handle receiver (thread, JNIHandles::resolve(obj)); 4109 oop box = JNIHandles::resolve(val); 4110 fieldDescriptor fd; 4111 Reflection::resolve_field(field_mirror, receiver, &fd, true, CHECK); 4112 BasicType field_type = fd.field_type(); 4113 jvalue value; 4114 BasicType value_type; 4115 if (field_type == T_OBJECT || field_type == T_ARRAY) { 4116 // Make sure we do no unbox e.g. java/lang/Integer instances when storing into an object array 4117 value_type = Reflection::unbox_for_regular_object(box, &value); 4118 Reflection::field_set(&value, &fd, receiver, field_type, CHECK); 4119 } else { 4120 value_type = Reflection::unbox_for_primitive(box, &value, CHECK); 4121 Reflection::field_set(&value, &fd, receiver, value_type, CHECK); 4122 } 4123JVM_END 4124 4125 4126JVM_ENTRY(void, JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)) 4127 JVMWrapper("JVM_SetPrimitiveField"); 4128 Handle field_mirror(thread, JNIHandles::resolve(field)); 4129 Handle receiver (thread, JNIHandles::resolve(obj)); 4130 fieldDescriptor fd; 4131 Reflection::resolve_field(field_mirror, receiver, &fd, true, CHECK); 4132 BasicType value_type = (BasicType) vCode; 4133 Reflection::field_set(&v, &fd, receiver, value_type, CHECK); 4134JVM_END 4135 4136 4137// Method /////////////////////////////////////////////////////////////////////////////////////////// 4138 4139JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)) 4140 JVMWrapper("JVM_InvokeMethod"); 4141 Handle method_handle; 4142 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) { 4143 method_handle = Handle(THREAD, JNIHandles::resolve(method)); 4144 Handle receiver(THREAD, JNIHandles::resolve(obj)); 4145 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0))); 4146 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL); 4147 jobject res = JNIHandles::make_local(env, result); 4148 if (JvmtiExport::should_post_vm_object_alloc()) { 4149 oop ret_type = java_lang_reflect_Method::return_type(method_handle()); 4150 assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!"); 4151 if (java_lang_Class::is_primitive(ret_type)) { 4152 // Only for primitive type vm allocates memory for java object. 4153 // See box() method. 4154 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result); 4155 } 4156 } 4157 return res; 4158 } else { 4159 THROW_0(vmSymbols::java_lang_StackOverflowError()); 4160 } 4161JVM_END 4162 4163 4164JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)) 4165 JVMWrapper("JVM_NewInstanceFromConstructor"); 4166 oop constructor_mirror = JNIHandles::resolve(c); 4167 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0))); 4168 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL); 4169 jobject res = JNIHandles::make_local(env, result); 4170 if (JvmtiExport::should_post_vm_object_alloc()) { 4171 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result); 4172 } 4173 return res; 4174JVM_END 4175 4176#endif /* SUPPORT_OLD_REFLECTION */ 4177 4178// Atomic /////////////////////////////////////////////////////////////////////////////////////////// 4179 4180JVM_LEAF(jboolean, JVM_SupportsCX8()) 4181 JVMWrapper("JVM_SupportsCX8"); 4182 return VM_Version::supports_cx8(); 4183JVM_END 4184 4185 4186JVM_ENTRY(jboolean, JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)) 4187 JVMWrapper("JVM_CX8Field"); 4188 jlong res; 4189 oop o = JNIHandles::resolve(obj); 4190 intptr_t fldOffs = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid); 4191 volatile jlong* addr = (volatile jlong*)((address)o + fldOffs); 4192 4193 assert(VM_Version::supports_cx8(), "cx8 not supported"); 4194 res = Atomic::cmpxchg(newVal, addr, oldVal); 4195 4196 return res == oldVal; 4197JVM_END 4198 4199// DTrace /////////////////////////////////////////////////////////////////// 4200 4201JVM_ENTRY(jint, JVM_DTraceGetVersion(JNIEnv* env)) 4202 JVMWrapper("JVM_DTraceGetVersion"); 4203 return (jint)JVM_TRACING_DTRACE_VERSION; 4204JVM_END 4205 4206JVM_ENTRY(jlong,JVM_DTraceActivate( 4207 JNIEnv* env, jint version, jstring module_name, jint providers_count, 4208 JVM_DTraceProvider* providers)) 4209 JVMWrapper("JVM_DTraceActivate"); 4210 return DTraceJSDT::activate( 4211 version, module_name, providers_count, providers, CHECK_0); 4212JVM_END 4213 4214JVM_ENTRY(jboolean,JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method)) 4215 JVMWrapper("JVM_DTraceIsProbeEnabled"); 4216 return DTraceJSDT::is_probe_enabled(method); 4217JVM_END 4218 4219JVM_ENTRY(void,JVM_DTraceDispose(JNIEnv* env, jlong handle)) 4220 JVMWrapper("JVM_DTraceDispose"); 4221 DTraceJSDT::dispose(handle); 4222JVM_END 4223 4224JVM_ENTRY(jboolean,JVM_DTraceIsSupported(JNIEnv* env)) 4225 JVMWrapper("JVM_DTraceIsSupported"); 4226 return DTraceJSDT::is_supported(); 4227JVM_END 4228 4229// Returns an array of all live Thread objects (VM internal JavaThreads, 4230// jvmti agent threads, and JNI attaching threads are skipped) 4231// See CR 6404306 regarding JNI attaching threads 4232JVM_ENTRY(jobjectArray, JVM_GetAllThreads(JNIEnv *env, jclass dummy)) 4233 ResourceMark rm(THREAD); 4234 ThreadsListEnumerator tle(THREAD, false, false); 4235 JvmtiVMObjectAllocEventCollector oam; 4236 4237 int num_threads = tle.num_threads(); 4238 objArrayOop r = oopFactory::new_objArray(SystemDictionary::thread_klass(), num_threads, CHECK_NULL); 4239 objArrayHandle threads_ah(THREAD, r); 4240 4241 for (int i = 0; i < num_threads; i++) { 4242 Handle h = tle.get_threadObj(i); 4243 threads_ah->obj_at_put(i, h()); 4244 } 4245 4246 return (jobjectArray) JNIHandles::make_local(env, threads_ah()); 4247JVM_END 4248 4249 4250// Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods 4251// Return StackTraceElement[][], each element is the stack trace of a thread in 4252// the corresponding entry in the given threads array 4253JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)) 4254 JVMWrapper("JVM_DumpThreads"); 4255 JvmtiVMObjectAllocEventCollector oam; 4256 4257 // Check if threads is null 4258 if (threads == NULL) { 4259 THROW_(vmSymbols::java_lang_NullPointerException(), 0); 4260 } 4261 4262 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(threads)); 4263 objArrayHandle ah(THREAD, a); 4264 int num_threads = ah->length(); 4265 // check if threads is non-empty array 4266 if (num_threads == 0) { 4267 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0); 4268 } 4269 4270 // check if threads is not an array of objects of Thread class 4271 klassOop k = objArrayKlass::cast(ah->klass())->element_klass(); 4272 if (k != SystemDictionary::thread_klass()) { 4273 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0); 4274 } 4275 4276 ResourceMark rm(THREAD); 4277 4278 GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads); 4279 for (int i = 0; i < num_threads; i++) { 4280 oop thread_obj = ah->obj_at(i); 4281 instanceHandle h(THREAD, (instanceOop) thread_obj); 4282 thread_handle_array->append(h); 4283 } 4284 4285 Handle stacktraces = ThreadService::dump_stack_traces(thread_handle_array, num_threads, CHECK_NULL); 4286 return (jobjectArray)JNIHandles::make_local(env, stacktraces()); 4287 4288JVM_END 4289 4290// JVM monitoring and management support 4291JVM_ENTRY_NO_ENV(void*, JVM_GetManagement(jint version)) 4292 return Management::get_jmm_interface(version); 4293JVM_END 4294 4295// com.sun.tools.attach.VirtualMachine agent properties support 4296// 4297// Initialize the agent properties with the properties maintained in the VM 4298JVM_ENTRY(jobject, JVM_InitAgentProperties(JNIEnv *env, jobject properties)) 4299 JVMWrapper("JVM_InitAgentProperties"); 4300 ResourceMark rm; 4301 4302 Handle props(THREAD, JNIHandles::resolve_non_null(properties)); 4303 4304 PUTPROP(props, "sun.java.command", Arguments::java_command()); 4305 PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags()); 4306 PUTPROP(props, "sun.jvm.args", Arguments::jvm_args()); 4307 return properties; 4308JVM_END 4309 4310JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)) 4311{ 4312 JVMWrapper("JVM_GetEnclosingMethodInfo"); 4313 JvmtiVMObjectAllocEventCollector oam; 4314 4315 if (ofClass == NULL) { 4316 return NULL; 4317 } 4318 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass)); 4319 // Special handling for primitive objects 4320 if (java_lang_Class::is_primitive(mirror())) { 4321 return NULL; 4322 } 4323 klassOop k = java_lang_Class::as_klassOop(mirror()); 4324 if (!Klass::cast(k)->oop_is_instance()) { 4325 return NULL; 4326 } 4327 instanceKlassHandle ik_h(THREAD, k); 4328 int encl_method_class_idx = ik_h->enclosing_method_class_index(); 4329 if (encl_method_class_idx == 0) { 4330 return NULL; 4331 } 4332 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::object_klass(), 3, CHECK_NULL); 4333 objArrayHandle dest(THREAD, dest_o); 4334 klassOop enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL); 4335 dest->obj_at_put(0, Klass::cast(enc_k)->java_mirror()); 4336 int encl_method_method_idx = ik_h->enclosing_method_method_index(); 4337 if (encl_method_method_idx != 0) { 4338 symbolOop sym_o = ik_h->constants()->symbol_at( 4339 extract_low_short_from_int( 4340 ik_h->constants()->name_and_type_at(encl_method_method_idx))); 4341 symbolHandle sym(THREAD, sym_o); 4342 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 4343 dest->obj_at_put(1, str()); 4344 sym_o = ik_h->constants()->symbol_at( 4345 extract_high_short_from_int( 4346 ik_h->constants()->name_and_type_at(encl_method_method_idx))); 4347 sym = symbolHandle(THREAD, sym_o); 4348 str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 4349 dest->obj_at_put(2, str()); 4350 } 4351 return (jobjectArray) JNIHandles::make_local(dest()); 4352} 4353JVM_END 4354 4355JVM_ENTRY(jintArray, JVM_GetThreadStateValues(JNIEnv* env, 4356 jint javaThreadState)) 4357{ 4358 // If new thread states are added in future JDK and VM versions, 4359 // this should check if the JDK version is compatible with thread 4360 // states supported by the VM. Return NULL if not compatible. 4361 // 4362 // This function must map the VM java_lang_Thread::ThreadStatus 4363 // to the Java thread state that the JDK supports. 4364 // 4365 4366 typeArrayHandle values_h; 4367 switch (javaThreadState) { 4368 case JAVA_THREAD_STATE_NEW : { 4369 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); 4370 values_h = typeArrayHandle(THREAD, r); 4371 values_h->int_at_put(0, java_lang_Thread::NEW); 4372 break; 4373 } 4374 case JAVA_THREAD_STATE_RUNNABLE : { 4375 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); 4376 values_h = typeArrayHandle(THREAD, r); 4377 values_h->int_at_put(0, java_lang_Thread::RUNNABLE); 4378 break; 4379 } 4380 case JAVA_THREAD_STATE_BLOCKED : { 4381 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); 4382 values_h = typeArrayHandle(THREAD, r); 4383 values_h->int_at_put(0, java_lang_Thread::BLOCKED_ON_MONITOR_ENTER); 4384 break; 4385 } 4386 case JAVA_THREAD_STATE_WAITING : { 4387 typeArrayOop r = oopFactory::new_typeArray(T_INT, 2, CHECK_NULL); 4388 values_h = typeArrayHandle(THREAD, r); 4389 values_h->int_at_put(0, java_lang_Thread::IN_OBJECT_WAIT); 4390 values_h->int_at_put(1, java_lang_Thread::PARKED); 4391 break; 4392 } 4393 case JAVA_THREAD_STATE_TIMED_WAITING : { 4394 typeArrayOop r = oopFactory::new_typeArray(T_INT, 3, CHECK_NULL); 4395 values_h = typeArrayHandle(THREAD, r); 4396 values_h->int_at_put(0, java_lang_Thread::SLEEPING); 4397 values_h->int_at_put(1, java_lang_Thread::IN_OBJECT_WAIT_TIMED); 4398 values_h->int_at_put(2, java_lang_Thread::PARKED_TIMED); 4399 break; 4400 } 4401 case JAVA_THREAD_STATE_TERMINATED : { 4402 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL); 4403 values_h = typeArrayHandle(THREAD, r); 4404 values_h->int_at_put(0, java_lang_Thread::TERMINATED); 4405 break; 4406 } 4407 default: 4408 // Unknown state - probably incompatible JDK version 4409 return NULL; 4410 } 4411 4412 return (jintArray) JNIHandles::make_local(env, values_h()); 4413} 4414JVM_END 4415 4416 4417JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env, 4418 jint javaThreadState, 4419 jintArray values)) 4420{ 4421 // If new thread states are added in future JDK and VM versions, 4422 // this should check if the JDK version is compatible with thread 4423 // states supported by the VM. Return NULL if not compatible. 4424 // 4425 // This function must map the VM java_lang_Thread::ThreadStatus 4426 // to the Java thread state that the JDK supports. 4427 // 4428 4429 ResourceMark rm; 4430 4431 // Check if threads is null 4432 if (values == NULL) { 4433 THROW_(vmSymbols::java_lang_NullPointerException(), 0); 4434 } 4435 4436 typeArrayOop v = typeArrayOop(JNIHandles::resolve_non_null(values)); 4437 typeArrayHandle values_h(THREAD, v); 4438 4439 objArrayHandle names_h; 4440 switch (javaThreadState) { 4441 case JAVA_THREAD_STATE_NEW : { 4442 assert(values_h->length() == 1 && 4443 values_h->int_at(0) == java_lang_Thread::NEW, 4444 "Invalid threadStatus value"); 4445 4446 objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(), 4447 1, /* only 1 substate */ 4448 CHECK_NULL); 4449 names_h = objArrayHandle(THREAD, r); 4450 Handle name = java_lang_String::create_from_str("NEW", CHECK_NULL); 4451 names_h->obj_at_put(0, name()); 4452 break; 4453 } 4454 case JAVA_THREAD_STATE_RUNNABLE : { 4455 assert(values_h->length() == 1 && 4456 values_h->int_at(0) == java_lang_Thread::RUNNABLE, 4457 "Invalid threadStatus value"); 4458 4459 objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(), 4460 1, /* only 1 substate */ 4461 CHECK_NULL); 4462 names_h = objArrayHandle(THREAD, r); 4463 Handle name = java_lang_String::create_from_str("RUNNABLE", CHECK_NULL); 4464 names_h->obj_at_put(0, name()); 4465 break; 4466 } 4467 case JAVA_THREAD_STATE_BLOCKED : { 4468 assert(values_h->length() == 1 && 4469 values_h->int_at(0) == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER, 4470 "Invalid threadStatus value"); 4471 4472 objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(), 4473 1, /* only 1 substate */ 4474 CHECK_NULL); 4475 names_h = objArrayHandle(THREAD, r); 4476 Handle name = java_lang_String::create_from_str("BLOCKED", CHECK_NULL); 4477 names_h->obj_at_put(0, name()); 4478 break; 4479 } 4480 case JAVA_THREAD_STATE_WAITING : { 4481 assert(values_h->length() == 2 && 4482 values_h->int_at(0) == java_lang_Thread::IN_OBJECT_WAIT && 4483 values_h->int_at(1) == java_lang_Thread::PARKED, 4484 "Invalid threadStatus value"); 4485 objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(), 4486 2, /* number of substates */ 4487 CHECK_NULL); 4488 names_h = objArrayHandle(THREAD, r); 4489 Handle name0 = java_lang_String::create_from_str("WAITING.OBJECT_WAIT", 4490 CHECK_NULL); 4491 Handle name1 = java_lang_String::create_from_str("WAITING.PARKED", 4492 CHECK_NULL); 4493 names_h->obj_at_put(0, name0()); 4494 names_h->obj_at_put(1, name1()); 4495 break; 4496 } 4497 case JAVA_THREAD_STATE_TIMED_WAITING : { 4498 assert(values_h->length() == 3 && 4499 values_h->int_at(0) == java_lang_Thread::SLEEPING && 4500 values_h->int_at(1) == java_lang_Thread::IN_OBJECT_WAIT_TIMED && 4501 values_h->int_at(2) == java_lang_Thread::PARKED_TIMED, 4502 "Invalid threadStatus value"); 4503 objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(), 4504 3, /* number of substates */ 4505 CHECK_NULL); 4506 names_h = objArrayHandle(THREAD, r); 4507 Handle name0 = java_lang_String::create_from_str("TIMED_WAITING.SLEEPING", 4508 CHECK_NULL); 4509 Handle name1 = java_lang_String::create_from_str("TIMED_WAITING.OBJECT_WAIT", 4510 CHECK_NULL); 4511 Handle name2 = java_lang_String::create_from_str("TIMED_WAITING.PARKED", 4512 CHECK_NULL); 4513 names_h->obj_at_put(0, name0()); 4514 names_h->obj_at_put(1, name1()); 4515 names_h->obj_at_put(2, name2()); 4516 break; 4517 } 4518 case JAVA_THREAD_STATE_TERMINATED : { 4519 assert(values_h->length() == 1 && 4520 values_h->int_at(0) == java_lang_Thread::TERMINATED, 4521 "Invalid threadStatus value"); 4522 objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(), 4523 1, /* only 1 substate */ 4524 CHECK_NULL); 4525 names_h = objArrayHandle(THREAD, r); 4526 Handle name = java_lang_String::create_from_str("TERMINATED", CHECK_NULL); 4527 names_h->obj_at_put(0, name()); 4528 break; 4529 } 4530 default: 4531 // Unknown state - probably incompatible JDK version 4532 return NULL; 4533 } 4534 return (jobjectArray) JNIHandles::make_local(env, names_h()); 4535} 4536JVM_END 4537 4538JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)) 4539{ 4540 memset(info, 0, sizeof(info_size)); 4541 4542 info->jvm_version = Abstract_VM_Version::jvm_version(); 4543 info->update_version = 0; /* 0 in HotSpot Express VM */ 4544 info->special_update_version = 0; /* 0 in HotSpot Express VM */ 4545 4546 // when we add a new capability in the jvm_version_info struct, we should also 4547 // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat 4548 // counter defined in runtimeService.cpp. 4549 info->is_attachable = AttachListener::is_attach_supported(); 4550#ifdef KERNEL 4551 info->is_kernel_jvm = 1; // true; 4552#else // KERNEL 4553 info->is_kernel_jvm = 0; // false; 4554#endif // KERNEL 4555} 4556JVM_END 4557 4558