< prev index next >
src/hotspot/share/runtime/frame.cpp
Print this page
*** 444,463 ****
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
--- 444,453 ----
*** 759,803 ****
*/
class InterpreterFrameClosure : public OffsetClosure {
private:
frame* _fr;
OopClosure* _f;
- BufferedValueClosure* _bvt_f;
int _max_locals;
int _max_stack;
- BufferedValuesDealiaser* _dealiaser;
public:
InterpreterFrameClosure(frame* fr, int max_locals, int max_stack,
OopClosure* f, BufferedValueClosure* bvt_f) {
_fr = fr;
_max_locals = max_locals;
_max_stack = max_stack;
_f = f;
- _bvt_f = bvt_f;
- _dealiaser = NULL;
}
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 (!VTBuffer::is_in_vt_buffer(*addr)) {
if (_f != NULL) {
_f->do_oop(addr);
}
- } else { // Buffered value types case
- assert(ValueTypesBufferMaxMemory > 0, "Sanity check");
- assert((*addr)->is_value(), "Only values can be buffered");
- if (_f != NULL) {
- dealiaser()->oops_do(_f, *addr);
- }
- 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;
--- 749,778 ----
*** 805,869 ****
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 (!VTBuffer::is_in_vt_buffer(*addr)) {
if (_f != NULL) {
_f->do_oop(addr);
}
- } else { // Buffered value types case
- assert(ValueTypesBufferMaxMemory > 0, "Sanity check");
- assert((*addr)->is_value(), "Only values can be buffered");
- if (_f != NULL) {
- dealiaser()->oops_do(_f, *addr);
- }
- if (_bvt_f != NULL) {
- _bvt_f->do_buffered_value(addr);
- }
- }
}
}
}
int max_locals() { return _max_locals; }
frame* fr() { return _fr; }
-
- private:
- BufferedValuesDealiaser* dealiaser() {
- if (_dealiaser == NULL) {
- _dealiaser = Thread::current()->buffered_values_dealiaser();
- assert(_dealiaser != NULL, "Must not be NULL");
- }
- return _dealiaser;
- }
};
class InterpretedArgumentOopFinder: public SignatureInfo {
private:
OopClosure* _f; // Closure to invoke
int _offset; // TOS-relative offset, decremented with each argument
bool _has_receiver; // true if the callee has a receiver
frame* _fr;
- BufferedValuesDealiaser* _dealiaser;
void set(int size, BasicType type) {
_offset -= size;
if (type == T_OBJECT || type == T_ARRAY || type == T_VALUETYPE) oop_offset_do();
}
void oop_offset_do() {
oop* addr;
addr = (oop*)_fr->interpreter_frame_tos_at(_offset);
- if (!VTBuffer::is_in_vt_buffer(*addr)) {
_f->do_oop(addr);
- } else { // Buffered value types case
- assert((*addr)->is_value(), "Only values can be buffered");
- oop value = *addr;
- dealiaser()->oops_do(_f, value);
- }
}
public:
InterpretedArgumentOopFinder(Symbol* signature, bool has_receiver, frame* fr, OopClosure* f) : SignatureInfo(signature), _has_receiver(has_receiver) {
// compute size of arguments
--- 780,817 ----
*** 873,891 ****
"args cannot be on stack anymore");
// initialize InterpretedArgumentOopFinder
_f = f;
_fr = fr;
_offset = args_size;
- _dealiaser = NULL;
- }
-
- BufferedValuesDealiaser* dealiaser() {
- if (_dealiaser == NULL) {
- _dealiaser = Thread::current()->buffered_values_dealiaser();
- assert(_dealiaser != NULL, "Must not be NULL");
- }
- return _dealiaser;
}
void oops_do() {
if (_has_receiver) {
--_offset;
--- 821,830 ----
*** 912,956 ****
private:
bool _is_static;
int _offset;
frame* _fr;
OopClosure* _f;
- BufferedValuesDealiaser* _dealiaser;
-
- BufferedValuesDealiaser* dealiaser() {
- if (_dealiaser == NULL) {
- _dealiaser = Thread::current()->buffered_values_dealiaser();
- assert(_dealiaser != NULL, "Must not be NULL");
- }
- return _dealiaser;
- }
void set(int size, BasicType type) {
assert (_offset >= 0, "illegal offset");
if (type == T_OBJECT || type == T_ARRAY || type == T_VALUETYPE) oop_at_offset_do(_offset);
_offset -= size;
}
void oop_at_offset_do(int offset) {
assert (offset >= 0, "illegal offset");
oop* addr = (oop*) _fr->entry_frame_argument_at(offset);
- if (!VTBuffer::is_in_vt_buffer(*addr)) {
_f->do_oop(addr);
- } else { // Buffered value types case
- assert((*addr)->is_value(), "Only values can be buffered");
- oop value = *addr;
- dealiaser()->oops_do(_f, value);
- }
}
public:
EntryFrameOopFinder(frame* frame, Symbol* signature, bool is_static) : SignatureInfo(signature) {
_f = NULL; // will be set later
_fr = frame;
_is_static = is_static;
_offset = ArgumentSizeComputer(signature).size() - 1; // last parameter is at index 0
- _dealiaser = NULL;
}
void arguments_do(OopClosure* f) {
_f = f;
if (!_is_static) oop_at_offset_do(_offset+1); // do the receiver
--- 851,879 ----
*** 991,1001 ****
#endif
current->oops_do(f);
}
if (m->is_native()) {
- assert(!VTBuffer::is_in_vt_buffer((oopDesc*)*interpreter_frame_temp_oop_addr()), "Sanity check");
f->do_oop(interpreter_frame_temp_oop_addr());
}
// The method pointer in the frame might be the only path to the method's
// klass, and the klass needs to be kept alive while executing. The GCs
--- 914,923 ----
*** 1098,1116 ****
bool _has_appendix; // true if the call has an appendix
frame _fr;
RegisterMap* _reg_map;
int _arg_size;
VMRegPair* _regs; // VMReg list of arguments
- BufferedValuesDealiaser* _dealiaser;
-
- BufferedValuesDealiaser* dealiaser() {
- if (_dealiaser == NULL) {
- _dealiaser = Thread::current()->buffered_values_dealiaser();
- assert(_dealiaser != NULL, "Must not be NULL");
- }
- return _dealiaser;
- }
void set(int size, BasicType type) {
if (type == T_OBJECT || type == T_ARRAY || type == T_VALUETYPE) handle_oop_offset();
_offset += size;
}
--- 1020,1029 ----
*** 1119,1135 ****
// Extract low order register number from register array.
// In LP64-land, the high-order bits are valid but unhelpful.
assert(_offset < _arg_size, "out of bounds");
VMReg reg = _regs[_offset].first();
oop *loc = _fr.oopmapreg_to_location(reg, _reg_map);
- if (!VTBuffer::is_in_vt_buffer(*loc)) {
_f->do_oop(loc);
- } else { // Buffered value types case
- assert((*loc)->is_value(), "Only values can be buffered");
- oop value = *loc;
- dealiaser()->oops_do(_f, value);
- }
}
public:
CompiledArgumentOopFinder(Symbol* signature, bool has_receiver, bool has_appendix, OopClosure* f, frame fr, const RegisterMap* reg_map)
: SignatureInfo(signature) {
--- 1032,1042 ----
*** 1140,1150 ****
_has_receiver = has_receiver;
_has_appendix = has_appendix;
_fr = fr;
_reg_map = (RegisterMap*)reg_map;
_regs = SharedRuntime::find_callee_arguments(signature, has_receiver, has_appendix, &_arg_size);
- _dealiaser = NULL;
}
void oops_do() {
if (_has_receiver) {
handle_oop_offset();
--- 1047,1056 ----
< prev index next >