< 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 >