src/hotspot/share/runtime/thread.hpp

*** 310,319 ****
--- 310,329 ----
   public:
    enum {
      is_definitely_current_thread = true
    };
  
+  private:
+   friend class BufferedValuesDealiaser;
+ 
+   BufferedValuesDealiaser* _buffered_values_dealiaser;
+  public:
+   BufferedValuesDealiaser* buffered_values_dealiaser() {
+     assert(Thread::current() == this, "Should only be accessed locally");
+     return _buffered_values_dealiaser;
+   }
+ 
    // Constructor
    Thread();
    virtual ~Thread();
  
    // Manage Thread::current()
*** 788,797 ****
--- 798,808 ----
  
  class JavaThread: public Thread {
    friend class VMStructs;
    friend class JVMCIVMStructs;
    friend class WhiteBox;
+   friend class VTBuffer;
   private:
    JavaThread*    _next;                          // The next thread in the Threads list
    oop            _threadObj;                     // The Java level thread object
  
  #ifdef ASSERT
*** 847,856 ****
--- 858,868 ----
    Method*       _callee_target;
  
    // Used to pass back results to the interpreter or generated code running Java code.
    oop           _vm_result;    // oop result is GC-preserved
    Metadata*     _vm_result_2;  // non-oop result
+   oop           _return_buffered_value; // buffered value being returned
  
    // See ReduceInitialCardMarks: this holds the precise space interval of
    // the most recent slow path allocation for which compiled code has
    // elided card-marks for performance along the fast-path.
    MemRegion     _deferred_card_mark;
*** 999,1008 ****
--- 1011,1021 ----
  
    // Buffered value types support
    void* _vt_alloc_ptr;
    void* _vt_alloc_limit;
    VTBufferChunk* _local_free_chunk;
+   VTBuffer::Mark _current_vtbuffer_mark;
    // Next 4 fields are used to monitor VT buffer memory consumption
    // We may want to not support them in PRODUCT builds
    jint _vtchunk_in_use;
    jint _vtchunk_max;
    jint _vtchunk_total_returned;
*** 1330,1339 ****
--- 1343,1355 ----
    void set_vm_result  (oop x)                    { _vm_result   = x; }
  
    Metadata*    vm_result_2() const               { return _vm_result_2; }
    void set_vm_result_2  (Metadata* x)          { _vm_result_2   = x; }
  
+   oop return_buffered_value() const              { return _return_buffered_value; }
+   void set_return_buffered_value(oop val)        { _return_buffered_value = val; }
+ 
    MemRegion deferred_card_mark() const           { return _deferred_card_mark; }
    void set_deferred_card_mark(MemRegion mr)      { _deferred_card_mark = mr;   }
  
  #if INCLUDE_JVMCI
    int  pending_deoptimization() const             { return _pending_deoptimization; }
*** 1569,1578 ****
--- 1585,1595 ----
      return byte_offset_of(JavaThread, _anchor);
    }
    static ByteSize callee_target_offset()         { return byte_offset_of(JavaThread, _callee_target); }
    static ByteSize vm_result_offset()             { return byte_offset_of(JavaThread, _vm_result); }
    static ByteSize vm_result_2_offset()           { return byte_offset_of(JavaThread, _vm_result_2); }
+   static ByteSize return_buffered_value_offset() { return byte_offset_of(JavaThread, _return_buffered_value); }
    static ByteSize thread_state_offset()          { return byte_offset_of(JavaThread, _thread_state); }
    static ByteSize saved_exception_pc_offset()    { return byte_offset_of(JavaThread, _saved_exception_pc); }
    static ByteSize osthread_offset()              { return byte_offset_of(JavaThread, _osthread); }
  #if INCLUDE_JVMCI
    static ByteSize pending_deoptimization_offset() { return byte_offset_of(JavaThread, _pending_deoptimization); }
*** 1883,1892 ****
--- 1900,1911 ----
      VTBufferChunk* chunk = VTBufferChunk::chunk(_vt_alloc_ptr);
      assert(chunk->owner() == this, "Sanity check");
      return chunk;
      // return _vt_alloc_ptr == NULL ? NULL : VTBufferChunk::chunk(_vt_alloc_ptr);
    }
+   VTBuffer::Mark current_vtbuffer_mark() const { return _current_vtbuffer_mark; }
+   void set_current_vtbuffer_mark(VTBuffer::Mark m) { _current_vtbuffer_mark = m ; }
  
    void increment_vtchunk_in_use() {
      _vtchunk_in_use++;
      if (_vtchunk_in_use > _vtchunk_max) _vtchunk_max = _vtchunk_in_use;
    }