src/hotspot/share/oops/stackChunkOop.inline.hpp

*** 150,13 ***
  }
  inline void stackChunkOopDesc::set_flag(uint8_t flag, bool value) {
    uint32_t flags = this->flags();
    set_flags((uint8_t)(value ? flags |= flag : flags &= ~flag));
  }
- inline void stackChunkOopDesc::clear_flags() {
-   set_flags(0);
- }
  
  inline bool stackChunkOopDesc::has_mixed_frames() const { return is_flag(FLAG_HAS_INTERPRETED_FRAMES); }
  inline void stackChunkOopDesc::set_has_mixed_frames(bool value) {
    assert((flags() & ~(FLAG_HAS_INTERPRETED_FRAMES | FLAG_PREEMPTED)) == 0, "other flags should not be set");
    set_flag(FLAG_HAS_INTERPRETED_FRAMES, value);
--- 150,10 ---

*** 166,10 ***
--- 163,22 ---
  inline void stackChunkOopDesc::set_preempted(bool value) {
    assert(preempted() != value, "");
    set_flag(FLAG_PREEMPTED, value);
  }
  
+ inline bool stackChunkOopDesc::at_klass_init() const { return jdk_internal_vm_StackChunk::atKlassInit(as_oop()); }
+ inline void stackChunkOopDesc::set_at_klass_init(bool value) {
+   assert(at_klass_init() != value, "");
+   jdk_internal_vm_StackChunk::set_atKlassInit(this, value);
+ }
+ 
+ inline bool stackChunkOopDesc::has_args_at_top() const { return jdk_internal_vm_StackChunk::hasArgsAtTop(as_oop()); }
+ inline void stackChunkOopDesc::set_has_args_at_top(bool value) {
+   assert(has_args_at_top() != value, "");
+   jdk_internal_vm_StackChunk::set_hasArgsAtTop(this, value);
+ }
+ 
  inline bool stackChunkOopDesc::has_lockstack() const         { return is_flag(FLAG_HAS_LOCKSTACK); }
  inline void stackChunkOopDesc::set_has_lockstack(bool value) { set_flag(FLAG_HAS_LOCKSTACK, value); }
  
  inline bool stackChunkOopDesc::is_gc_mode() const                  { return is_flag(FLAG_GC_MODE); }
  inline bool stackChunkOopDesc::is_gc_mode_acquire() const          { return is_flag_acquire(FLAG_GC_MODE); }

*** 209,11 ***
                       : iterate_stack<ChunkFrames::CompiledOnly>(closure);
  }
  
  template <ChunkFrames frame_kind, class StackChunkFrameClosureType>
  inline void stackChunkOopDesc::iterate_stack(StackChunkFrameClosureType* closure) {
!   const SmallRegisterMap* map = SmallRegisterMap::instance();
    assert(!map->in_cont(), "");
  
    StackChunkFrameStream<frame_kind> f(this);
    bool should_continue = true;
  
--- 218,11 ---
                       : iterate_stack<ChunkFrames::CompiledOnly>(closure);
  }
  
  template <ChunkFrames frame_kind, class StackChunkFrameClosureType>
  inline void stackChunkOopDesc::iterate_stack(StackChunkFrameClosureType* closure) {
!   const auto* map = SmallRegisterMap::instance_no_args();
    assert(!map->in_cont(), "");
  
    StackChunkFrameStream<frame_kind> f(this);
    bool should_continue = true;
  

*** 229,10 ***
--- 238,13 ---
      assert(!f.is_done(), "");
      assert(f.is_compiled(), "");
  
      should_continue = closure->do_frame(f, &full_map);
      f.next(map);
+   } else if (frame_kind == ChunkFrames::Mixed && f.is_interpreted() && has_args_at_top()) {
+     should_continue = closure->do_frame(f, SmallRegisterMap::instance_with_args());
+     f.next(map);
    }
    assert(!f.is_stub(), "");
  
    for(; should_continue && !f.is_done(); f.next(map)) {
      if (frame_kind == ChunkFrames::Mixed) {