--- old/src/share/vm/runtime/frame.cpp	2017-06-26 12:31:53.098308079 -0400
+++ new/src/share/vm/runtime/frame.cpp	2017-06-26 12:31:52.394304588 -0400
@@ -443,6 +443,16 @@
   *interpreter_frame_mdp_addr() = (intptr_t)mdp;
 }
 
+intptr_t* frame::interpreter_frame_vt_alloc_ptr() const {
+  assert(is_interpreted_frame(), "interpreted frame expected");
+  return (intptr_t*)*interpreter_frame_vt_alloc_ptr_addr();
+}
+
+void frame::interpreter_frame_set_vt_alloc_ptr(intptr_t* ptr) {
+  assert(is_interpreted_frame(), "interpreted frame expected");
+  *interpreter_frame_vt_alloc_ptr_addr() = ptr;
+}
+
 BasicObjectLock* frame::next_monitor_in_interpreter_frame(BasicObjectLock* current) const {
   assert(is_interpreted_frame(), "Not an interpreted frame");
 #ifdef ASSERT
@@ -747,16 +757,18 @@
  private:
   frame* _fr;
   OopClosure* _f;
+  BufferedValueClosure* _bvt_f;
   int    _max_locals;
   int    _max_stack;
 
  public:
   InterpreterFrameClosure(frame* fr, int max_locals, int max_stack,
-                          OopClosure* f) {
+                          OopClosure* f, BufferedValueClosure* bvt_f) {
     _fr         = fr;
     _max_locals = max_locals;
     _max_stack  = max_stack;
     _f          = f;
+    _bvt_f      = bvt_f;
   }
 
   void offset_do(int offset) {
@@ -764,7 +776,19 @@
     if (offset < _max_locals) {
       addr = (oop*) _fr->interpreter_frame_local_at(offset);
       assert((intptr_t*)addr >= _fr->sp(), "must be inside the frame");
-      _f->do_oop(addr);
+      if (Universe::heap()->is_in_reserved_or_null(*addr)) {
+        if (_f != NULL) {
+          _f->do_oop(addr);
+        }
+      } else { // Buffered value types case
+        if (_f != NULL) {
+          oop* addr_mirror = (oop*)(*addr)->mark_addr();
+          _f->do_oop(addr_mirror);
+        }
+        if (_bvt_f != NULL) {
+          _bvt_f->do_buffered_value(addr);
+        }
+      }
     } else {
       addr = (oop*) _fr->interpreter_frame_expression_stack_at((offset - _max_locals));
       // In case of exceptions, the expression stack is invalid and the esp will be reset to express
@@ -776,7 +800,19 @@
         in_stack = (intptr_t*)addr >= _fr->interpreter_frame_tos_address();
       }
       if (in_stack) {
-        _f->do_oop(addr);
+        if (Universe::heap()->is_in_reserved_or_null(*addr)) {
+          if (_f != NULL) {
+            _f->do_oop(addr);
+          }
+        } else { // Buffered value types case
+          if (_f != NULL) {
+            oop* addr_mirror = (oop*)(*addr)->mark_addr();
+            _f->do_oop(addr_mirror);
+          }
+          if (_bvt_f != NULL) {
+            _bvt_f->do_buffered_value(addr);
+          }
+        }
       }
     }
   }
@@ -949,7 +985,7 @@
     }
   }
 
-  InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f);
+  InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f, NULL);
 
   // process locals & expression stack
   InterpreterOopMap mask;
@@ -961,6 +997,23 @@
   mask.iterate_oop(&blk);
 }
 
+void frame::buffered_values_interpreted_do(BufferedValueClosure* f) {
+  assert(is_interpreted_frame(), "Not an interpreted frame");
+  Thread *thread = Thread::current();
+  methodHandle m (thread, interpreter_frame_method());
+  jint      bci = interpreter_frame_bci();
+
+  assert(m->is_method(), "checking frame value");
+  assert(!m->is_native() && bci >= 0 && bci < m->code_size(),
+         "invalid bci value");
+
+  InterpreterFrameClosure blk(this, m->max_locals(), m->max_stack(), NULL, f);
+
+  // process locals & expression stack
+  InterpreterOopMap mask;
+  m->mask_for(bci, &mask);
+  mask.iterate_oop(&blk);
+}
 
 void frame::oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f) {
   InterpretedArgumentOopFinder finder(signature, has_receiver, this, f);