src/hotspot/share/prims/stackwalk.cpp

@@ -49,24 +49,24 @@
  BaseFrameStream::BaseFrameStream(JavaThread* thread, Handle continuation)
    : _thread(thread), _continuation(continuation), _anchor(0L) {
      assert(thread != nullptr, "");
  }
  
- void BaseFrameStream::setup_magic_on_entry(objArrayHandle frames_array) {
+ void BaseFrameStream::setup_magic_on_entry(refArrayHandle frames_array) {
    frames_array->obj_at_put(magic_pos, _thread->threadObj());
    _anchor = address_value();
    assert(check_magic(frames_array), "invalid magic");
  }
  
- bool BaseFrameStream::check_magic(objArrayHandle frames_array) {
+ bool BaseFrameStream::check_magic(refArrayHandle frames_array) {
    oop   m1 = frames_array->obj_at(magic_pos);
    jlong m2 = _anchor;
    if (m1 == _thread->threadObj() && m2 == address_value())  return true;
    return false;
  }
  
- bool BaseFrameStream::cleanup_magic_on_exit(objArrayHandle frames_array) {
+ bool BaseFrameStream::cleanup_magic_on_exit(refArrayHandle frames_array) {
    bool ok = check_magic(frames_array);
    frames_array->obj_at_put(magic_pos, nullptr);
    _anchor = 0L;
    return ok;
  }

@@ -130,11 +130,11 @@
  //  magic          Magic value used for each stack walking
  //  frames_array   User-supplied buffers.  The 0th element is reserved
  //                 for this BaseFrameStream to use
  //
  BaseFrameStream* BaseFrameStream::from_current(JavaThread* thread, jlong magic,
-                                                objArrayHandle frames_array)
+                                                refArrayHandle frames_array)
  {
    oop m1 = frames_array->obj_at(magic_pos);
    if (m1 != thread->threadObj()) return nullptr;
    if (magic == 0L)                    return nullptr;
    BaseFrameStream* stream = (BaseFrameStream*) (intptr_t) magic;

@@ -161,11 +161,11 @@
  //
  // Returns the number of frames whose information was transferred into the buffers.
  //
  int StackWalk::fill_in_frames(jint mode, BaseFrameStream& stream,
                                int buffer_size, int start_index,
-                               objArrayHandle  frames_array,
+                               refArrayHandle frames_array,
                                int& end_index, TRAPS) {
    log_debug(stackwalk)("fill_in_frames limit=%d start=%d frames length=%d",
                         buffer_size, start_index, frames_array->length());
    assert(buffer_size > 0, "invalid buffer_size");
    assert(buffer_size <= frames_array->length(), "oob");

@@ -209,19 +209,19 @@
  
    return frames_decoded;
  }
  
  // Fill in the LiveStackFrameInfo at the given index in frames_array
- void LiveFrameStream::fill_frame(int index, objArrayHandle  frames_array,
+ void LiveFrameStream::fill_frame(int index, refArrayHandle frames_array,
                                   const methodHandle& method, TRAPS) {
    HandleMark hm(THREAD);
    Handle stackFrame(THREAD, frames_array->obj_at(index));
    fill_live_stackframe(stackFrame, method, CHECK);
  }
  
  // Fill in the StackFrameInfo at the given index in frames_array
- void JavaFrameStream::fill_frame(int index, objArrayHandle  frames_array,
+ void JavaFrameStream::fill_frame(int index, refArrayHandle frames_array,
                                   const methodHandle& method, TRAPS) {
    if (_need_method_info) {
      HandleMark hm(THREAD);
      Handle stackFrame(THREAD, frames_array->obj_at(index));
      fill_stackframe(stackFrame, method, CHECK);

@@ -383,11 +383,11 @@
  //                  otherwise. It should never be null.
  //
  // Returns Object returned from AbstractStackWalker::doStackWalk call.
  //
  oop StackWalk::walk(Handle stackStream, jint mode, int skip_frames, Handle cont_scope, Handle cont,
-                     int buffer_size, int start_index, objArrayHandle frames_array,
+                     int buffer_size, int start_index, refArrayHandle frames_array,
                      TRAPS) {
    ResourceMark rm(THREAD);
    HandleMark hm(THREAD); // needed to store a continuation in the RegisterMap
  
    JavaThread* jt = THREAD;

@@ -424,11 +424,11 @@
    }
  }
  
  oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
                                 jint mode, int skip_frames, int buffer_size,
-                                int start_index, objArrayHandle frames_array, TRAPS) {
+                                int start_index, refArrayHandle frames_array, TRAPS) {
    methodHandle m_doStackWalk(THREAD, Universe::do_stack_walk_method());
  
    {
      Klass* stackWalker_klass = vmClasses::StackWalker_klass();
      Klass* abstractStackWalker_klass = vmClasses::AbstractStackWalker_klass();

@@ -504,11 +504,11 @@
  //
  // Returns the number of frames filled in the buffer.
  //
  jint StackWalk::fetchNextBatch(Handle stackStream, jint mode, jlong magic,
                                 int last_batch_count, int buffer_size, int start_index,
-                                objArrayHandle frames_array,
+                                refArrayHandle frames_array,
                                 TRAPS)
  {
    JavaThread* jt = THREAD;
    BaseFrameStream* existing_stream = BaseFrameStream::from_current(jt, magic, frames_array);
    if (existing_stream == nullptr) {

@@ -561,11 +561,11 @@
      }
    }
    return 0;
  }
  
- void StackWalk::setContinuation(Handle stackStream, jlong magic, objArrayHandle frames_array, Handle cont, TRAPS) {
+ void StackWalk::setContinuation(Handle stackStream, jlong magic, refArrayHandle frames_array, Handle cont, TRAPS) {
    JavaThread* jt = JavaThread::cast(THREAD);
  
    if (frames_array.is_null()) {
      THROW_MSG(vmSymbols::java_lang_NullPointerException(), "frames_array is null");
    }