hotspot/src/share/vm/prims/jvm.cpp
changeset 37438 873c4aea8d1b
parent 37248 11a660dbbb8e
child 37441 016084ef6634
equal deleted inserted replaced
37437:f824aabc7af8 37438:873c4aea8d1b
   532 // java.lang.StackWalker //////////////////////////////////////////////////////
   532 // java.lang.StackWalker //////////////////////////////////////////////////////
   533 
   533 
   534 
   534 
   535 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jlong mode,
   535 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jlong mode,
   536                                      jint skip_frames, jint frame_count, jint start_index,
   536                                      jint skip_frames, jint frame_count, jint start_index,
   537                                      jobjectArray classes,
       
   538                                      jobjectArray frames))
   537                                      jobjectArray frames))
   539   JVMWrapper("JVM_CallStackWalk");
   538   JVMWrapper("JVM_CallStackWalk");
   540   JavaThread* jt = (JavaThread*) THREAD;
   539   JavaThread* jt = (JavaThread*) THREAD;
   541   if (!jt->is_Java_thread() || !jt->has_last_Java_frame()) {
   540   if (!jt->is_Java_thread() || !jt->has_last_Java_frame()) {
   542     THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", NULL);
   541     THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", NULL);
   543   }
   542   }
   544 
   543 
   545   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
   544   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
   546   objArrayOop ca = objArrayOop(JNIHandles::resolve_non_null(classes));
   545 
   547   objArrayHandle classes_array_h(THREAD, ca);
   546   // frames array is a Class<?>[] array when only getting caller reference,
   548 
   547   // and a StackFrameInfo[] array (or derivative) otherwise. It should never
   549   // frames array is null when only getting caller reference
   548   // be null.
   550   objArrayOop fa = objArrayOop(JNIHandles::resolve(frames));
   549   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
   551   objArrayHandle frames_array_h(THREAD, fa);
   550   objArrayHandle frames_array_h(THREAD, fa);
   552 
   551 
   553   int limit = start_index + frame_count;
   552   int limit = start_index + frame_count;
   554   if (classes_array_h->length() < limit) {
   553   if (frames_array_h->length() < limit) {
   555     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", NULL);
   554     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", NULL);
   556   }
   555   }
   557 
   556 
   558   Handle result = StackWalk::walk(stackStream_h, mode, skip_frames, frame_count,
   557   Handle result = StackWalk::walk(stackStream_h, mode, skip_frames, frame_count,
   559                                   start_index, classes_array_h,
   558                                   start_index, frames_array_h, CHECK_NULL);
   560                                   frames_array_h, CHECK_NULL);
       
   561   return JNIHandles::make_local(env, result());
   559   return JNIHandles::make_local(env, result());
   562 JVM_END
   560 JVM_END
   563 
   561 
   564 
   562 
   565 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jlong mode, jlong anchor,
   563 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jlong mode, jlong anchor,
   566                                   jint frame_count, jint start_index,
   564                                   jint frame_count, jint start_index,
   567                                   jobjectArray classes,
       
   568                                   jobjectArray frames))
   565                                   jobjectArray frames))
   569   JVMWrapper("JVM_MoreStackWalk");
   566   JVMWrapper("JVM_MoreStackWalk");
   570   JavaThread* jt = (JavaThread*) THREAD;
   567   JavaThread* jt = (JavaThread*) THREAD;
   571   objArrayOop ca = objArrayOop(JNIHandles::resolve_non_null(classes));
   568 
   572   objArrayHandle classes_array_h(THREAD, ca);
   569   // frames array is a Class<?>[] array when only getting caller reference,
   573 
   570   // and a StackFrameInfo[] array (or derivative) otherwise. It should never
   574   // frames array is null when only getting caller reference
   571   // be null.
   575   objArrayOop fa = objArrayOop(JNIHandles::resolve(frames));
   572   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
   576   objArrayHandle frames_array_h(THREAD, fa);
   573   objArrayHandle frames_array_h(THREAD, fa);
   577 
   574 
   578   int limit = start_index+frame_count;
   575   int limit = start_index+frame_count;
   579   if (classes_array_h->length() < limit) {
   576   if (frames_array_h->length() < limit) {
   580     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");
   577     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");
   581   }
   578   }
   582 
   579 
   583   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
   580   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
   584   return StackWalk::moreFrames(stackStream_h, mode, anchor, frame_count,
   581   return StackWalk::moreFrames(stackStream_h, mode, anchor, frame_count,
   585                                start_index, classes_array_h,
   582                                start_index, frames_array_h, THREAD);
   586                                frames_array_h, THREAD);
   583 JVM_END
   587 JVM_END
   584 
   588 
   585 JVM_ENTRY(void, JVM_ToStackTraceElement(JNIEnv *env, jobject frame, jobject stack))
   589 JVM_ENTRY(void, JVM_FillStackFrames(JNIEnv *env, jclass stackStream,
   586   JVMWrapper("JVM_ToStackTraceElement");
   590                                     jint start_index,
   587   Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(frame));
   591                                     jobjectArray frames,
   588   Handle stack_trace_element(THREAD, JNIHandles::resolve_non_null(stack));
   592                                     jint from_index, jint to_index))
   589   java_lang_StackFrameInfo::to_stack_trace_element(stack_frame_info, stack_trace_element, THREAD);
   593   JVMWrapper("JVM_FillStackFrames");
       
   594   if (TraceStackWalk) {
       
   595     tty->print("JVM_FillStackFrames() start_index=%d from_index=%d to_index=%d\n",
       
   596                start_index, from_index, to_index);
       
   597   }
       
   598 
       
   599   JavaThread* jt = (JavaThread*) THREAD;
       
   600 
       
   601   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
       
   602   objArrayHandle frames_array_h(THREAD, fa);
       
   603 
       
   604   if (frames_array_h->length() < to_index) {
       
   605     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array length not matched");
       
   606   }
       
   607 
       
   608   for (int i = from_index; i < to_index; i++) {
       
   609     Handle stackFrame(THREAD, frames_array_h->obj_at(i));
       
   610     java_lang_StackFrameInfo::fill_methodInfo(stackFrame, CHECK);
       
   611   }
       
   612 JVM_END
       
   613 
       
   614 JVM_ENTRY(void, JVM_SetMethodInfo(JNIEnv *env, jobject frame))
       
   615   JVMWrapper("JVM_SetMethodInfo");
       
   616   Handle stackFrame(THREAD, JNIHandles::resolve(frame));
       
   617   java_lang_StackFrameInfo::fill_methodInfo(stackFrame, THREAD);
       
   618 JVM_END
   590 JVM_END
   619 
   591 
   620 // java.lang.Object ///////////////////////////////////////////////
   592 // java.lang.Object ///////////////////////////////////////////////
   621 
   593 
   622 
   594