Change representation of frames pointing into chunks

Author: pron

src/hotspot/cpu/x86/continuation_x86.inline.hpp

@@ -900,9 +900,8 @@ static frame chunk_top_frame_pd(oop chunk, intptr_t* sp, RegisterMap* map) {
   intptr_t** fp_address = (intptr_t**)(sp - 2);
   intptr_t* fp = *fp_address;
   if (map->update_map()) {
-    frame::update_map_with_saved_link(map, fp_address);
+    frame::update_map_with_saved_link(map, (intptr_t**)(intptr_t)(-2 * BytesPerWord)); // for chunk frames, we store offset
   }
-
   return frame(sp, sp, fp, pc, ContinuationCodeBlobLookup::find_blob(pc), NULL, true);
 }
 

src/hotspot/cpu/x86/frame_x86.hpp

@@ -116,7 +116,10 @@
   // uses sp() to mean "raw" sp and unextended_sp() to mean the caller's
   // original sp we use that convention.
 
-  intptr_t* _unextended_sp;
+  union {
+    intptr_t* _unextended_sp;
+    size_t _frame_index; // used by frames in continuation chunks
+  };
   void adjust_unextended_sp() NOT_DEBUG_RETURN;
 
   intptr_t* ptr_at_addr(int offset) const {

src/hotspot/cpu/x86/frame_x86.inline.hpp

@@ -225,6 +225,10 @@ inline intptr_t* frame::link() const              { return (intptr_t*) *(intptr_
 
 inline intptr_t* frame::unextended_sp() const     { return _unextended_sp; }
 
+inline size_t frame::frame_index() const          { return _frame_index; }
+
+inline void frame::set_frame_index(size_t index)  { _frame_index = index; }
+
 inline intptr_t* frame::real_fp() const {
   if (_cb != NULL) {
     // use the frame size if valid

src/hotspot/share/runtime/continuation.cpp

@@ -690,7 +690,8 @@ class ContMirror {
   static bool is_in_chunk(oop chunk, void* p);
   static bool is_usable_in_chunk(oop chunk, void* p);
   static inline void reset_chunk_counters(oop chunk);
-  oop find_chunk(void* p) const;
+  oop find_chunk(size_t sp_offset, size_t* chunk_offset) const;
+  oop find_chunk_by_address(void* p) const;
 
   template<op_mode mode> const hframe last_frame();
   template<op_mode mode> void set_last_frame(const hframe& f);
@@ -1237,7 +1238,7 @@ inline void ContMirror::reset_chunk_counters(oop chunk) {
   jdk_internal_misc_StackChunk::set_numOops(chunk, -1);
 }
 
-oop ContMirror::find_chunk(void* p) const {
+oop ContMirror::find_chunk_by_address(void* p) const {
   for (oop chunk = tail(); chunk != (oop)NULL; chunk = jdk_internal_misc_StackChunk::parent(chunk)) {
     if (is_in_chunk(chunk, p)) {
       assert (is_usable_in_chunk(chunk, p), "");
@@ -1247,6 +1248,23 @@ oop ContMirror::find_chunk(void* p) const {
   return (oop)NULL;
 }
 
+oop ContMirror::find_chunk(size_t sp_offset, size_t* chunk_offset) const {
+  size_t offset = 0;
+  for (oop chunk = tail(); chunk != (oop)NULL; chunk = jdk_internal_misc_StackChunk::parent(chunk)) {
+    if (is_empty_chunk(chunk)) continue;
+    const size_t end = jdk_internal_misc_StackChunk::size(chunk) - jdk_internal_misc_StackChunk::argsize(chunk);
+    const int chunk_sp = jdk_internal_misc_StackChunk::sp(chunk);
+    size_t offset_in_chunk = sp_offset - offset;
+    if (chunk_sp + offset_in_chunk < end) {
+      // tty->print_cr(">>> find_chunk chunk %p sp_offset: %ld offset: %ld, chunk_sp: %d offset_in_chunk: %ld end: %ld", (oopDesc*)chunk, sp_offset, offset, chunk_sp, offset_in_chunk, end);
+      if (chunk_offset != NULL) *chunk_offset = offset;
+      return chunk;
+    }
+    offset += end - chunk_sp;
+  }
+  return (oop)NULL;
+}
+
 template<typename Event> void ContMirror::post_jfr_event(Event* e, JavaThread* jt) {
   if (e->should_commit()) {
     log_develop_trace(jvmcont)("JFR event: frames: %d iframes: %d size: %d refs: %d", _e_num_frames, _e_num_interpreted_frames, _e_size, _e_num_refs);
@@ -4905,10 +4923,12 @@ bool Continuation::is_scope_bottom(oop cont_scope, const frame& f, const Registe
 
 static frame chunk_top_frame_pd(oop chunk, intptr_t* sp, RegisterMap* map);
 
-static frame chunk_top_frame(oop chunk, RegisterMap* map) {
+static frame chunk_top_frame(oop chunk, RegisterMap* map, size_t offset, size_t index) {
   intptr_t* sp = (intptr_t*)InstanceStackChunkKlass::start_of_stack(chunk) + jdk_internal_misc_StackChunk::sp(chunk);
-  // tty->print_cr(">>> chunk_top_frame usp: %p", sp);
-  return chunk_top_frame_pd(chunk, sp, map);
+  frame f = chunk_top_frame_pd(chunk, sp, map);
+  f.set_offset_sp(offset);
+  f.set_frame_index(index);
+  return f;
 }
 
 static frame continuation_body_top_frame(ContMirror& cont, RegisterMap* map) {
@@ -4929,7 +4949,7 @@ static frame continuation_top_frame(oop contOop, RegisterMap* map) {
   for (oop chunk = cont.tail(); chunk != (oop)NULL; chunk = jdk_internal_misc_StackChunk::parent(chunk)) {
     if (!ContMirror::is_empty_chunk(chunk)) {
       map->set_in_cont(true, true);
-      return chunk_top_frame(chunk, map);
+      return chunk_top_frame(chunk, map, 0, 0);
     }
   }
 
@@ -5000,29 +5020,45 @@ static frame sender_for_frame(const frame& f, RegisterMap* map) {
   assert (map->in_cont(), "");
   ContMirror cont(map);
 
-  oop chunk = cont.find_chunk(f.unextended_sp());
+  assert (!f.is_empty(), "");
+
   bool from_chunk = false;
-  if (chunk != (oop)NULL) {
+  if (map->in_chunk()) {
     from_chunk = true;
-    // we add to the pointer instead of subtracting from the bounds
-    if (ContMirror::is_in_chunk(chunk, f.unextended_sp() + f.cb()->frame_size() + jdk_internal_misc_StackChunk::argsize(chunk) + frame_metadata)) {
-      map->set_in_cont(false, false); // to prevent infinite recursion
-      frame sender = f.sender(map);
-      map->set_in_cont(true, true);
-      // tty->print_cr(">>> sender_for_frame usp: %p", sender.unextended_sp());
+    
+    size_t frame_index = f.frame_index();
+    size_t chunk_offset;
+    oop chunk = cont.find_chunk(f.offset_sp(), &chunk_offset);
+    assert (!ContMirror::is_empty_chunk(chunk), "");
+    assert (chunk != (oop)NULL, "");
+    intptr_t* chunk_sp = (intptr_t*)InstanceStackChunkKlass::start_of_stack(chunk) + jdk_internal_misc_StackChunk::sp(chunk);
+    intptr_t* sp = chunk_sp + (f.offset_sp() - chunk_offset);
+
+    frame f = sp_to_frame(sp);
+    if (ContMirror::is_in_chunk(chunk, sp + f.cb()->frame_size() + jdk_internal_misc_StackChunk::argsize(chunk) + frame_metadata)) {
+      frame sender = sp_to_frame(sp + f.cb()->frame_size());
+
       assert (ContMirror::is_usable_in_chunk(chunk, sender.unextended_sp()), "");
+      sender.set_offset_sp(chunk_offset + (sender.sp() - chunk_sp));
+      sender.set_frame_index(frame_index + 1);
+      if (map->update_map()) {
+        frame::update_map_with_saved_link(map, (intptr_t**)(intptr_t)(-2 * BytesPerWord)); // for chunk frames, we store offset TODO PD
+      }
       return sender;
     }
+    const size_t end = jdk_internal_misc_StackChunk::size(chunk) - jdk_internal_misc_StackChunk::argsize(chunk);
+    chunk_offset += end - jdk_internal_misc_StackChunk::sp(chunk);
     chunk = jdk_internal_misc_StackChunk::parent(chunk);
     if (chunk != (oop)NULL) {
       assert (!ContMirror::is_empty_chunk(chunk), "");
-      return chunk_top_frame(chunk, map);
+      return chunk_top_frame(chunk, map, chunk_offset, frame_index + 1);
     }
     assert (map->in_cont(), "");
     if (map->in_chunk()) map->set_in_cont(true, false);
-    assert (!map->in_chunk(), "");
   }
 
+  assert (!map->in_chunk(), "");
+
   hframe sender = from_chunk ? cont.last_frame<mode_slow>()
                              : cont.from_frame(f).sender<mode_slow>(cont);
 
@@ -5158,27 +5194,27 @@ address Continuation::oop_address(objArrayOop ref_stack, int ref_sp, int index)
 bool Continuation::is_in_usable_stack(address addr, const RegisterMap* map) {
   ContMirror cont(map);
 
-  oop chunk = cont.find_chunk(addr);
+  oop chunk = cont.find_chunk_by_address(addr);
   assert (((intptr_t**)addr == Frame::map_link_address(map)) || (map->in_chunk() == (chunk != (oop)NULL)), "map->in_chunk(): %d", map->in_chunk());
   return (chunk != (oop)NULL) ? ContMirror::is_usable_in_chunk(chunk, addr)
                               : (cont.is_in_stack(addr) || cont.is_in_ref_stack(addr) 
                                  || (intptr_t**)addr == java_lang_Continuation::raw_fp_address(cont.mirror())); // TODO PD
 }
 
-// address Continuation::usp_offset_to_location(const frame& fr, const RegisterMap* map, const int usp_offset_in_bytes) {
-//   return usp_offset_to_location(fr, map, usp_offset_in_bytes, find_oop_in_compiled_frame(fr, map, usp_offset_in_bytes) >= 0);
-// }
-
 // if oop, it is narrow iff UseCompressedOops
 address Continuation::usp_offset_to_location(const frame& fr, const RegisterMap* map, const int usp_offset_in_bytes, bool is_oop) {
   assert (fr.is_compiled_frame(), "");
   ContMirror cont(map);
 
   assert(map->in_cont(), "");
 
-  assert (map->in_chunk() == (cont.find_chunk(fr.unextended_sp()) != (oop)NULL), "");
-  if (cont.find_chunk(fr.unextended_sp()) != (oop)NULL) {
-    return (address)fr.unextended_sp() + usp_offset_in_bytes;
+  if (map->in_chunk()) {
+    size_t chunk_offset;
+    oop chunk = cont.find_chunk(fr.offset_sp(), &chunk_offset);
+    assert (chunk != (oop)NULL, "");
+    size_t offset_in_chunk = jdk_internal_misc_StackChunk::sp(chunk) + (fr.offset_sp() - chunk_offset);
+    intptr_t* sp = (intptr_t*)InstanceStackChunkKlass::start_of_stack(chunk) + offset_in_chunk;
+    return (address)sp + usp_offset_in_bytes;
   }
 
   assert(!map->in_chunk(), "fr.unextended_sp: " INTPTR_FORMAT, p2i(fr.unextended_sp()));
@@ -5200,8 +5236,8 @@ int Continuation::usp_offset_to_index(const frame& fr, const RegisterMap* map, c
   assert (fr.is_compiled_frame() || is_stub(fr.cb()), "");
   ContMirror cont(map);
 
-  assert (map->in_chunk() == (cont.find_chunk(fr.unextended_sp()) != (oop)NULL), "");
-  if (cont.find_chunk(fr.unextended_sp()) != (oop)NULL) {
+  if (map->in_chunk()) {
+    assert (cont.find_chunk(fr.offset_sp(), NULL) != (oop)NULL, "");
     return usp_offset_in_bytes;
   }
 
@@ -5226,22 +5262,6 @@ int Continuation::usp_offset_to_index(const frame& fr, const RegisterMap* map, c
   return index;
 }
 
-// address Continuation::reg_to_location(const frame& fr, const RegisterMap* map, VMReg reg) {
-//   return reg_to_location(fr, map, reg, find_oop_in_compiled_frame(fr, map, reg) >= 0);
-// }
-
-// address Continuation::reg_to_location(const frame& fr, const RegisterMap* map, VMReg reg, bool is_oop) {
-//   assert (map != NULL, "");
-//   oop cont;
-//   assert (map->in_cont(), "");
-//   if (map->in_cont()) {
-//     cont = map->cont();
-//   } else {
-//     cont = get_continutation_for_frame(map->thread(), fr);
-//   }
-//   return reg_to_location(cont, fr, map, reg, is_oop);
-// }
-
 address Continuation::reg_to_location(const frame& fr, const RegisterMap* map, VMReg reg, bool is_oop) {
   assert (map != NULL, "");
   assert (fr.is_compiled_frame(), "");
@@ -5255,9 +5275,15 @@ address Continuation::reg_to_location(const frame& fr, const RegisterMap* map, V
 
   ContMirror cont(map);
 
-  assert (map->in_chunk() == (cont.find_chunk(fr.unextended_sp()) != (oop)NULL), "");
-  if (cont.find_chunk(fr.unextended_sp()) != (oop)NULL) {
-    return map->location(reg);
+  if (map->in_chunk()) {
+    intptr_t usp_offset_in_bytes = (intptr_t)map->location(reg); // see usp_offset_to_index for the chunk case
+    
+    size_t chunk_offset;
+    oop chunk = cont.find_chunk(fr.offset_sp(), &chunk_offset);
+    assert (chunk != (oop)NULL, "");
+    size_t offset_in_chunk = jdk_internal_misc_StackChunk::sp(chunk) + (fr.offset_sp() - chunk_offset);
+    intptr_t* sp = (intptr_t*)InstanceStackChunkKlass::start_of_stack(chunk) + offset_in_chunk;
+    return (address)sp + usp_offset_in_bytes;
   }
 
   hframe hf = cont.from_frame(fr);

src/hotspot/share/runtime/frame.hpp

@@ -54,10 +54,11 @@ class frame {
   // Instance variables:
   union {
     intptr_t* _sp; // stack pointer (from Thread::last_Java_sp)
+    size_t _offset_sp; // used by frames in continuation chunks
     struct {
       int _sp;
       int _ref_sp;
-    } _cont_sp;
+    } _cont_sp; // used by frames in continuation arrays
   };
   address   _pc; // program counter (the next instruction after the call)
   mutable CodeBlob* _cb; // CodeBlob that "owns" pc
@@ -104,10 +105,11 @@ class frame {
 
   intptr_t* sp() const           { return _sp; }
   void set_sp( intptr_t* newsp ) { _sp = newsp; }
+  void set_offset_sp( size_t newsp ) { _offset_sp = newsp; }
 
-  int cont_sp()     const { return _cont_sp._sp; }
-  int cont_ref_sp() const { return _cont_sp._ref_sp; }
-  int cont_unextended_sp() const;
+  int cont_sp()      const { return _cont_sp._sp; }
+  int cont_ref_sp()  const { return _cont_sp._ref_sp; }
+  size_t offset_sp() const { return _offset_sp; }
 
   CodeBlob* cb() const           { return _cb; }
   inline CodeBlob* get_cb() const;
@@ -230,6 +232,9 @@ class frame {
   // The frame's original SP, before any extension by an interpreted callee;
   // used for packing debug info into vframeArray objects and vframeArray lookup.
   intptr_t* unextended_sp() const;
+  
+  size_t frame_index() const;
+  void set_frame_index(size_t index);
 
   // returns the stack pointer of the calling frame
   intptr_t* sender_sp() const;