Fix async stack walking and cleanup

pron · pron · commit 4f9b66164450 · 2022-01-31T18:49:15.000Z
diff --git a/src/hotspot/cpu/aarch64/continuation_aarch64.inline.hpp b/src/hotspot/cpu/aarch64/continuation_aarch64.inline.hpp
@@ -54,18 +54,16 @@ static void patch_callee_link_relative(const frame& f, intptr_t* fp) {
 }
 
 template<typename FKind, typename RegisterMapT>
-inline void ContinuationHelper::update_register_map(RegisterMapT* map, const frame& f) {
+inline void ContinuationHelper::update_register_map(const frame& f, RegisterMapT* map) {
   frame::update_map_with_saved_link(map, link_address<FKind>(f));
 }
 
 template<typename RegisterMapT>
-inline void ContinuationHelper::update_register_map_with_callee(RegisterMapT* map, const frame& f) {
+inline void ContinuationHelper::update_register_map_with_callee(const frame& f, RegisterMapT* map) {
   frame::update_map_with_saved_link(map, Frame::callee_link_address(f));
 }
 
 inline void ContinuationHelper::push_pd(const frame& f) {
-  log_develop_trace(jvmcont)("ContinuationHelper::push_pd: " INTPTR_FORMAT, p2i(f.fp()));
-  // os::print_location(tty, (intptr_t)f.fp());
   *(intptr_t**)(f.sp() - frame::sender_sp_offset) = f.fp();
 }
 
diff --git a/src/hotspot/cpu/x86/continuation_x86.inline.hpp b/src/hotspot/cpu/x86/continuation_x86.inline.hpp
@@ -53,18 +53,16 @@ static void patch_callee_link_relative(const frame& f, intptr_t* fp) {
 }
 
 template<typename FKind, typename RegisterMapT>
-inline void ContinuationHelper::update_register_map(RegisterMapT* map, const frame& f) {
+inline void ContinuationHelper::update_register_map(const frame& f, RegisterMapT* map) {
   frame::update_map_with_saved_link(map, link_address<FKind>(f));
 }
 
 template<typename RegisterMapT>
-inline void ContinuationHelper::update_register_map_with_callee(RegisterMapT* map, const frame& f) {
+inline void ContinuationHelper::update_register_map_with_callee(const frame& f, RegisterMapT* map) {
   frame::update_map_with_saved_link(map, Frame::callee_link_address(f));
 }
 
 inline void ContinuationHelper::push_pd(const frame& f) {
-  log_develop_trace(jvmcont)("ContinuationHelper::push_pd: " INTPTR_FORMAT, p2i(f.fp()));
-  // os::print_location(tty, (intptr_t)f.fp());
   *(intptr_t**)(f.sp() - frame::sender_sp_offset) = f.fp();
 }
 
diff --git a/src/hotspot/share/code/codeCache.cpp b/src/hotspot/share/code/codeCache.cpp
@@ -656,11 +656,15 @@ CodeBlob* CodeCache::find_blob_unsafe(void* start) {
 
 CodeBlob* CodeCache::patch_nop(NativePostCallNop* nop, void* pc, int& slot) {
   CodeBlob* cb = CodeCache::find_blob(pc);
-  int oopmap_slot = cb->oop_maps()->find_slot_for_offset((intptr_t) pc - (intptr_t) cb->code_begin());
   intptr_t cbaddr = (intptr_t) cb;
   intptr_t offset = ((intptr_t) pc) - cbaddr;
 
-  if (((oopmap_slot & 0xff) == oopmap_slot) && ((offset & 0xffffff) == offset)) {
+  int oopmap_slot = cb->oop_maps()->find_slot_for_offset((intptr_t) pc - (intptr_t) cb->code_begin());
+  if (oopmap_slot < 0) { // this can happen at asynchronous (non-safepoint) stackwalks
+    slot = -1;
+    log_debug(codecache)("failed to find oopmap for cb: " INTPTR_FORMAT " offset: %d", cbaddr, (int) offset);
+    // tty->print_cr("deopt: %d", cb->as_compiled_method()->is_deopt_pc((address)pc)); os::print_location(tty, (intptr_t)pc);
+  } else if (((oopmap_slot & 0xff) == oopmap_slot) && ((offset & 0xffffff) == offset)) {
     jint value = (oopmap_slot << 24) | (jint) offset;
     nop->patch(value);
     slot = oopmap_slot;
diff --git a/src/hotspot/share/compiler/oopMap.cpp b/src/hotspot/share/compiler/oopMap.cpp
@@ -746,8 +746,8 @@ int ImmutableOopMapSet::find_slot_for_offset(int pc_offset) const {
   for (int i = 0; i < _count; ++i) {
     if (pairs[i].pc_offset() >= pc_offset) {
       ImmutableOopMapPair* last = &pairs[i];
-      assert(last->pc_offset() == pc_offset, "oopmap not found");
-      return i;
+      return last->pc_offset() == pc_offset ? i
+                                            : -1; // this can happen at asynchronous (non-safepoint) stackwalks
     }
   }
 
diff --git a/src/hotspot/share/jfr/recorder/stacktrace/jfrStackTrace.cpp b/src/hotspot/share/jfr/recorder/stacktrace/jfrStackTrace.cpp
@@ -166,6 +166,7 @@ inline void JfrVframeStream::seek_stable_frame() {
 
 JfrVframeStream::JfrVframeStream(JavaThread* jt, const frame& fr, bool async_mode) : vframeStreamCommon(RegisterMap(jt, false, false, true)),
 _continuation(jt->last_continuation()->cont_oop()), _continuation_scope(NULL), _continuation_scope_end_condition(false), _async_mode(async_mode) {
+  _reg_map.set_async(async_mode);
   _stop_at_java_call_stub = false;
   _frame = fr;
   seek_stable_frame();
diff --git a/src/hotspot/share/prims/forte.cpp b/src/hotspot/share/prims/forte.cpp
@@ -94,7 +94,7 @@ vframeStreamForte::vframeStreamForte(JavaThread *jt,
                                      frame fr,
                                      bool stop_at_java_call_stub)
     : vframeStreamCommon(RegisterMap(jt, false, false, false)) {
-
+  _reg_map.set_async(true);
   _stop_at_java_call_stub = stop_at_java_call_stub;
   _frame = fr;
 
diff --git a/src/hotspot/share/runtime/continuation.cpp b/src/hotspot/share/runtime/continuation.cpp
@@ -321,19 +321,18 @@ class ContinuationHelper {
   static const int align_wiggle; // size, in words, of maximum shift in frame position due to alignment
 
   static oop get_continuation(JavaThread* thread);
-
+  static inline frame last_frame(JavaThread* thread);
   static bool stack_overflow_check(JavaThread* thread, int size, address sp);
+
+  static inline void clear_anchor(JavaThread* thread);
   static void set_anchor(JavaThread* thread, intptr_t* sp);
   static void set_anchor_pd(JavaFrameAnchor* anchor, intptr_t* sp);
-  static inline void clear_anchor(JavaThread* thread);
   static void set_anchor_to_entry(JavaThread* thread, ContinuationEntry* cont);
   static void set_anchor_to_entry_pd(JavaFrameAnchor* anchor, ContinuationEntry* cont);
 
-  static void update_map_for_chunk_frame(RegisterMap* map);
-  template<typename FKind, typename RegisterMapT> static void update_register_map(RegisterMapT* map, const frame& f); // TODO invert parameter order
-  template<typename RegisterMapT> static void update_register_map_with_callee(RegisterMapT* map, const frame& f); // TODO invert parameter order
+  template<typename FKind, typename RegisterMapT> static void update_register_map(const frame& f, RegisterMapT* map);
+  template<typename RegisterMapT> static void update_register_map_with_callee(const frame& f, RegisterMapT* map);
 
-  static inline frame last_frame(JavaThread* thread);
   static inline void push_pd(const frame& f);
 
   static inline void maybe_flush_stack_processing(JavaThread* thread, ContinuationEntry* entry);
@@ -362,6 +361,10 @@ bool ContinuationHelper::stack_overflow_check(JavaThread* thread, int size, addr
   return true;
 }
 
+inline void ContinuationHelper::clear_anchor(JavaThread* thread) {
+  thread->frame_anchor()->clear();
+}
+
 void ContinuationHelper::set_anchor(JavaThread* thread, intptr_t* sp) {
   address pc = *(address*)(sp - frame::sender_sp_ret_address_offset());
   assert (pc != nullptr, "");
@@ -372,15 +375,9 @@ void ContinuationHelper::set_anchor(JavaThread* thread, intptr_t* sp) {
   set_anchor_pd(anchor, sp);
 
   assert (thread->has_last_Java_frame(), "");
-  log_develop_trace(jvmcont)("set_anchor: [" JLONG_FORMAT "] [%d]", java_tid(thread), thread->osthread()->thread_id());
-  print_vframe(thread->last_frame());
   assert(thread->last_frame().cb() != nullptr, "");
 }
 
-inline void ContinuationHelper::clear_anchor(JavaThread* thread) {
-  thread->frame_anchor()->clear();
-}
-
 void ContinuationHelper::set_anchor_to_entry(JavaThread* thread, ContinuationEntry* cont) {
   JavaFrameAnchor* anchor = thread->frame_anchor();
   anchor->set_last_Java_sp(cont->entry_sp());
@@ -389,8 +386,6 @@ void ContinuationHelper::set_anchor_to_entry(JavaThread* thread, ContinuationEnt
 
   assert (thread->has_last_Java_frame(), "");
   assert(thread->last_frame().cb() != nullptr, "");
-  log_develop_trace(jvmcont)("set_anchor: [" JLONG_FORMAT "] [%d]", java_tid(thread), thread->osthread()->thread_id());
-  print_vframe(thread->last_frame());
 }
 
 inline void ContinuationHelper::maybe_flush_stack_processing(JavaThread* thread, ContinuationEntry* entry) {
@@ -446,7 +441,7 @@ class ContMirror {
   JavaThread* thread() const         { return _thread; }
   oop mirror()                       { return _cont; }
   stackChunkOop tail() const         { return _tail; }
-  void set_tail(stackChunkOop chunk) { _tail = chunk; }  
+  void set_tail(stackChunkOop chunk) { _tail = chunk; }
   inline void set_empty() { _tail = nullptr; }
 
   oop parent() { return jdk_internal_vm_Continuation::parent(_cont); }
@@ -1145,9 +1140,9 @@ class Freeze {
   intptr_t *_top_address;
 
   int _size; // total size of all frames plus metadata in words. keeps track of offset where a frame should be written and how many bytes we need to allocate.
-  int _frames;
   int _align_size;
 
+  NOT_PRODUCT(int _frames;)
   DEBUG_ONLY(intptr_t* _last_write;)
 
   inline void set_top_frame_metadata_pd(const frame& hf);
@@ -1186,13 +1181,10 @@ class Freeze {
 
   void init_rest() { // we want to postpone some initialization after chunk handling
     _size = 0;
-    _frames = 0;
     _align_size = 0;
+    NOT_PRODUCT(_frames = 0;)
   }
 
-  int nr_bytes() const  { return _size << LogBytesPerWord; }
-  int nr_frames() const { return _frames; }
-
   template <bool aligned = true>
   void copy_to_chunk(intptr_t* from, intptr_t* to, int size) {
     stackChunkOop chunk = _cont.tail();
@@ -1201,8 +1193,10 @@ class Freeze {
 
   #ifdef ASSERT
     if (_last_write != nullptr) {
-      assert (_last_write == to + size, "Missed a spot: _last_write: " INTPTR_FORMAT " to+size: " INTPTR_FORMAT " stack_size: %d _last_write offset: " PTR_FORMAT " to+size: " PTR_FORMAT,
-        p2i(_last_write), p2i(to + size), chunk->stack_size(), _last_write - chunk->start_address(), to + size - chunk->start_address());
+      assert (_last_write == to + size, "Missed a spot: _last_write: " INTPTR_FORMAT " to+size: " INTPTR_FORMAT
+                                        " stack_size: %d _last_write offset: " PTR_FORMAT " to+size: " PTR_FORMAT,
+          p2i(_last_write), p2i(to + size),
+          chunk->stack_size(), _last_write - chunk->start_address(), to + size - chunk->start_address());
       _last_write = to;
     }
   #endif
@@ -1316,7 +1310,6 @@ class Freeze {
         chunk->set_max_size(chunk->max_size() + size - argsize);
 
         intptr_t* const bottom_sp = bottom - argsize;
-        log_develop_trace(jvmcont)("patching bottom sp: " INTPTR_FORMAT, p2i(bottom_sp));
         assert (bottom_sp == _bottom_address, "");
         assert (*(address*)(bottom_sp - frame::sender_sp_ret_address_offset()) == StubRoutines::cont_returnBarrier(), "");
         patch_chunk_pd(bottom_sp, chunk->sp_address());
@@ -1375,7 +1368,6 @@ class Freeze {
     assert (chunk->is_stackChunk(), "");
     assert (!chunk->requires_barriers(), "");
     assert (chunk == _cont.tail(), "");
-    // assert (chunk == jdk_internal_vm_Continuation::tail(_cont.mirror()), "");
     // assert (!chunk->is_gc_mode(), "allocated: %d empty: %d", allocated, empty);
     assert (sp <= chunk->stack_size(), "sp: %d chunk size: %d size: %d argsize: %d allocated: %d", sp, chunk->stack_size(), size, argsize, allocated);
 
@@ -1394,7 +1386,6 @@ class Freeze {
 
     // patch pc
     intptr_t* chunk_bottom_sp = chunk_top + size - argsize;
-    log_develop_trace(jvmcont)("freeze_fast patching return address at: " INTPTR_FORMAT " to: " INTPTR_FORMAT, p2i(chunk_bottom_sp - frame::sender_sp_ret_address_offset()), p2i(chunk->pc()));
     assert (empty || *(address*)(chunk_bottom_sp - frame::sender_sp_ret_address_offset()) == StubRoutines::cont_returnBarrier(), "");
     *(address*)(chunk_bottom_sp - frame::sender_sp_ret_address_offset()) = chunk->pc();
 
@@ -1432,7 +1423,6 @@ class Freeze {
   #endif
 
     log_develop_trace(jvmcont)("freeze_slow  #" INTPTR_FORMAT, _cont.hash());
-
     assert (_thread->thread_state() == _thread_in_vm || _thread->thread_state() == _thread_blocked, "");
 
     init_rest();
@@ -1535,7 +1525,7 @@ class Freeze {
     // log_develop_trace(jvmcont)("recurse_freeze_java_frame fsize: %d frame_bottom: " INTPTR_FORMAT " _bottom_address: " INTPTR_FORMAT, fsize, p2i(FKind::frame_bottom(f)), p2i(_bottom_address));
 
     assert (fsize > 0 && argsize >= 0, "");
-    _frames++;
+    NOT_PRODUCT(_frames++;)
     _size += fsize;
 
     if (FKind::frame_bottom(f) >= _bottom_address - 1) { // sometimes there's a space between enterSpecial and the next frame
@@ -1576,7 +1566,7 @@ class Freeze {
   #endif
 
     assert (FKind::interpreted || argsize == _cont.argsize(), "argsize: %d _cont.argsize(): %d", argsize, _cont.argsize());
-    log_develop_trace(jvmcont)("bottom: " INTPTR_FORMAT " count %d size: %d argsize: %d", p2i(_bottom_address), nr_frames(), nr_bytes(), argsize);
+    log_develop_trace(jvmcont)("bottom: " INTPTR_FORMAT " count %d size: %d argsize: %d", p2i(_bottom_address), _frames, _size << LogBytesPerWord, argsize);
 
   #ifdef ASSERT
     bool empty = _cont.is_empty();
@@ -1848,12 +1838,12 @@ class Freeze {
       f.cb()->name(), _size, fsize, p2i(vsp), p2i(vsp+fsize));
 
     // we're inlining recurse_freeze_java_frame and freeze here because we need to use a full RegisterMap to test lock ownership
-    _frames++;
+    NOT_PRODUCT(_frames++;)
     _size += fsize;
 
     RegisterMap map(_cont.thread(), true, false, false);
     map.set_include_argument_oops(false);
-    ContinuationHelper::update_register_map<StubF>(&map, f);
+    ContinuationHelper::update_register_map<StubF>(f, &map);
     f.oop_map()->update_register_map(&f, &map); // we have callee-save registers in this case
     frame senderf = sender<StubF>(f);
     assert (senderf.unextended_sp() < _bottom_address - 1, "");
@@ -2793,7 +2783,7 @@ class Thaw {
 
     if (f.is_deoptimized_frame()) {
       maybe_set_fastpath(f.sp());
-    } else if (_thread->is_interp_only_mode() 
+    } else if (_thread->is_interp_only_mode()
                 || (_cont.is_preempted() && f.cb()->as_compiled_method()->is_marked_for_deoptimization())) {
       // The caller of the safepoint stub when the continuation is preempted is not at a call instruction, and so
       // cannot rely on nmethod patching for deopt.
@@ -2860,7 +2850,7 @@ class Thaw {
       RegisterMap map(nullptr, true, false, false); // map.clear();
       map.set_include_argument_oops(false);
       f.oop_map()->update_register_map(&f, &map);
-      ContinuationHelper::update_register_map_with_callee(&map, caller);
+      ContinuationHelper::update_register_map_with_callee(caller, &map);
       InstanceStackChunkKlass::fix_thawed_frame(_cont.tail(), caller, &map);
     }
 
@@ -3024,7 +3014,7 @@ void do_deopt_after_thaw(JavaThread* thread) {
   int i = 0;
   StackFrameStream fst(thread, true, false);
   fst.register_map()->set_include_argument_oops(false);
-  ContinuationHelper::update_register_map_with_callee(fst.register_map(), *fst.current());
+  ContinuationHelper::update_register_map_with_callee(*fst.current(), fst.register_map());
   for (; !fst.is_done(); fst.next()) {
     if (fst.current()->cb()->is_compiled()) {
       CompiledMethod* cm = fst.current()->cb()->as_compiled_method();
@@ -3045,7 +3035,7 @@ bool do_verify_after_thaw(JavaThread* thread, int mode, bool barriers, stackChun
   int i = 0;
   StackFrameStream fst(thread, true, false);
   fst.register_map()->set_include_argument_oops(false);
-  ContinuationHelper::update_register_map_with_callee(fst.register_map(), *fst.current());
+  ContinuationHelper::update_register_map_with_callee(*fst.current(), fst.register_map());
   for (; !fst.is_done() && !Continuation::is_continuation_enterSpecial(*fst.current()); fst.next()) {
     if (fst.current()->cb()->is_compiled() && fst.current()->cb()->as_compiled_method()->is_marked_for_deoptimization()) {
       tty->print_cr(">>> do_verify_after_thaw deopt");
diff --git a/src/hotspot/share/runtime/frame.cpp b/src/hotspot/share/runtime/frame.cpp
@@ -62,11 +62,12 @@
 RegisterMap::RegisterMap(JavaThread *thread, bool update_map, bool process_frames, bool walk_cont) {
   _thread         = thread;
   _update_map     = update_map;
-  _walk_cont      = walk_cont;
-  DEBUG_ONLY(_skip_missing = false;)
   _process_frames = process_frames;
+  _walk_cont      = walk_cont;
   clear();
-  debug_only(_update_for_id = NULL;)
+  DEBUG_ONLY (_update_for_id = NULL;)
+  NOT_PRODUCT(_skip_missing = false;)
+  NOT_PRODUCT(_async = false;)
 
   if (walk_cont && thread != NULL && thread->last_continuation() != NULL) {
     _chunk = stackChunkHandle(Thread::current(), NULL, true);
@@ -80,11 +81,12 @@ RegisterMap::RegisterMap(JavaThread *thread, bool update_map, bool process_frame
 RegisterMap::RegisterMap(oop continuation, bool update_map) {
   _thread         = NULL;
   _update_map     = update_map;
-  _walk_cont      = true;
-  DEBUG_ONLY(_skip_missing = false;)
   _process_frames = false;
+  _walk_cont      = true;
   clear();
-  debug_only(_update_for_id = NULL;)
+  DEBUG_ONLY (_update_for_id = NULL;)
+  NOT_PRODUCT(_skip_missing = false;)
+  NOT_PRODUCT(_async = false;)
 
   _chunk = stackChunkHandle(Thread::current(), NULL, true);
 
@@ -99,10 +101,11 @@ RegisterMap::RegisterMap(const RegisterMap* map) {
   _thread                = map->thread();
   _update_map            = map->update_map();
   _process_frames        = map->process_frames();
+  _walk_cont             = map->_walk_cont;
   _include_argument_oops = map->include_argument_oops();
-  debug_only(_update_for_id = map->_update_for_id;)
-  _walk_cont     = map->_walk_cont;
-  DEBUG_ONLY(_skip_missing = map->_skip_missing;)
+  DEBUG_ONLY (_update_for_id = map->_update_for_id;)
+  NOT_PRODUCT(_skip_missing = map->_skip_missing;)
+  NOT_PRODUCT(_async = map->_async;)
 
   // only the original RegisterMap's handle lives long enough for StackWalker; this is bound to cause trouble with nested continuations.
   _chunk = map->_chunk; // stackChunkHandle(Thread::current(), map->_chunk(), map->_chunk.not_null()); //
diff --git a/src/hotspot/share/runtime/registerMap.hpp b/src/hotspot/share/runtime/registerMap.hpp
@@ -82,7 +82,8 @@ class RegisterMap : public StackObj {
   bool        _process_frames;          // Should frames be processed by stack watermark barriers?
   bool        _walk_cont;               // whether to walk frames on a continuation stack
 
-  NOT_PRODUCT(bool  _skip_missing;)
+  NOT_PRODUCT(bool  _skip_missing;) // ignore missing registers
+  NOT_PRODUCT(bool  _async;)        // walking frames asynchronously, at arbitrary points
 
 #ifdef ASSERT
   void check_location_valid();
@@ -157,8 +158,11 @@ class RegisterMap : public StackObj {
   void print_on(outputStream* st) const;
   void print() const;
 
+  void set_async(bool value)        { NOT_PRODUCT(_async = value;) }
+  void set_skip_missing(bool value) { NOT_PRODUCT(_skip_missing = value;) }
+
 #ifndef PRODUCT
-  void set_skip_missing(bool value) { _skip_missing = value; }
+  bool is_async() const             { return _async; }
   bool should_skip_missing() const  { return _skip_missing; }
 
   VMReg find_register_spilled_here(void* p, intptr_t* sp);

Original file line number	Diff line number	Diff line change
`@@ -54,18 +54,16 @@ static void patch_callee_link_relative(const frame& f, intptr_t* fp) {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`template<typename FKind, typename RegisterMapT>`
`57`		`-inline void ContinuationHelper::update_register_map(RegisterMapT* map, const frame& f) {`
	`57`	`+inline void ContinuationHelper::update_register_map(const frame& f, RegisterMapT* map) {`
`58`	`58`	`frame::update_map_with_saved_link(map, link_address<FKind>(f));`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`template<typename RegisterMapT>`
`62`		`-inline void ContinuationHelper::update_register_map_with_callee(RegisterMapT* map, const frame& f) {`
	`62`	`+inline void ContinuationHelper::update_register_map_with_callee(const frame& f, RegisterMapT* map) {`
`63`	`63`	`frame::update_map_with_saved_link(map, Frame::callee_link_address(f));`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`inline void ContinuationHelper::push_pd(const frame& f) {`
`67`		`- log_develop_trace(jvmcont)("ContinuationHelper::push_pd: " INTPTR_FORMAT, p2i(f.fp()));`
`68`		`- // os::print_location(tty, (intptr_t)f.fp());`
`69`	`67`	`(intptr_t*)(f.sp() - frame::sender_sp_offset) = f.fp();`
`70`	`68`	`}`
`71`	`69`
Original file line number	Diff line number	Diff line change
`@@ -53,18 +53,16 @@ static void patch_callee_link_relative(const frame& f, intptr_t* fp) {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`template<typename FKind, typename RegisterMapT>`
`56`		`-inline void ContinuationHelper::update_register_map(RegisterMapT* map, const frame& f) {`
	`56`	`+inline void ContinuationHelper::update_register_map(const frame& f, RegisterMapT* map) {`
`57`	`57`	`frame::update_map_with_saved_link(map, link_address<FKind>(f));`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`template<typename RegisterMapT>`
`61`		`-inline void ContinuationHelper::update_register_map_with_callee(RegisterMapT* map, const frame& f) {`
	`61`	`+inline void ContinuationHelper::update_register_map_with_callee(const frame& f, RegisterMapT* map) {`
`62`	`62`	`frame::update_map_with_saved_link(map, Frame::callee_link_address(f));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`inline void ContinuationHelper::push_pd(const frame& f) {`
`66`		`- log_develop_trace(jvmcont)("ContinuationHelper::push_pd: " INTPTR_FORMAT, p2i(f.fp()));`
`67`		`- // os::print_location(tty, (intptr_t)f.fp());`
`68`	`66`	`(intptr_t*)(f.sp() - frame::sender_sp_offset) = f.fp();`
`69`	`67`	`}`
`70`	`68`
Original file line number	Diff line number	Diff line change
`@@ -746,8 +746,8 @@ int ImmutableOopMapSet::find_slot_for_offset(int pc_offset) const {`
`746`	`746`	`for (int i = 0; i < _count; ++i) {`
`747`	`747`	`if (pairs[i].pc_offset() >= pc_offset) {`
`748`	`748`	`ImmutableOopMapPair* last = &pairs[i];`
`749`		`- assert(last->pc_offset() == pc_offset, "oopmap not found");`
`750`		`- return i;`
	`749`	`+ return last->pc_offset() == pc_offset ? i`
	`750`	`+ : -1; // this can happen at asynchronous (non-safepoint) stackwalks`
`751`	`751`	`}`
`752`	`752`	`}`
`753`	`753`