< prev index next >

src/share/vm/runtime/frame.cpp

Print this page

        

@@ -441,10 +441,20 @@
   assert(is_interpreted_frame(), "interpreted frame expected");
   assert(ProfileInterpreter, "must be profiling interpreter");
   *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
   interpreter_frame_verify_monitor(current);
 #endif

@@ -745,28 +755,42 @@
 */
 class InterpreterFrameClosure : public OffsetClosure {
  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) {
     oop* addr;
     if (offset < _max_locals) {
       addr = (oop*) _fr->interpreter_frame_local_at(offset);
       assert((intptr_t*)addr >= _fr->sp(), "must be inside the frame");
+      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
       // this condition. Therefore, we call f only if addr is 'inside' the stack (i.e., addr >= esp for Intel).
       bool in_stack;

@@ -774,12 +798,24 @@
         in_stack = (intptr_t*)addr <= _fr->interpreter_frame_tos_address();
       } else {
         in_stack = (intptr_t*)addr >= _fr->interpreter_frame_tos_address();
       }
       if (in_stack) {
+        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);
+          }
+        }
+      }
     }
   }
 
   int max_locals()  { return _max_locals; }
   frame* fr()       { return _fr; }

@@ -947,11 +983,11 @@
         oops_interpreted_arguments_do(signature, has_receiver, f);
       }
     }
   }
 
-  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;
   if (query_oop_map_cache) {
     m->mask_for(bci, &mask);

@@ -959,10 +995,27 @@
     OopMapCache::compute_one_oop_map(m, bci, &mask);
   }
   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);
   finder.oops_do();
 }
< prev index next >