inline methodOop frame::interpreter_frame_method() const {
assert(is_interpreted_frame(), "interpreted frame expected");
methodOop m = lvb_methodRef(interpreter_frame_method_addr()).as_methodOop();
assert(m->is_perm(), "bad methodOop in interpreter frame");
assert(m->is_method(), "not a methodOop");
return m;
}
void frame::follow_roots() {
if (is_interpreted_frame()) {
if (has_interpreted_float_marker() && follow_roots_interpreted_float_frame()) return;
// Follow the roots of the frame
for (oop* p = sp(); p <= temp_addr(0); p++) {
MarkSweep::follow_root(p);
}
MarkSweep::follow_root((oop*)hp_addr());
MarkSweep::follow_root(receiver_addr());
return;
}
if (is_compiled_frame()) {
if (has_compiled_float_marker() && follow_roots_compiled_float_frame()) return;
for (oop* p = sp(); p < (oop*)fp(); p++) MarkSweep::follow_root(p);
return;
}
if (is_entry_frame()) {
for (oop* p = sp(); p < (oop*)fp(); p++) MarkSweep::follow_root(p);
return;
}
if (is_deoptimized_frame()) {
// Expression stack
oop* end = (oop*)fp() + frame_real_sender_sp_offset;
for (oop* p = sp(); p < end; p++) MarkSweep::follow_root(p);
MarkSweep::follow_root((oop*)frame_array_addr());
return;
}
}
intptr_t* frame::interpreter_frame_sender_sp() const {
assert(is_interpreted_frame(), "interpreted frame expected");
// QQQ why does this specialize method exist if frame::sender_sp() does same thing?
// seems odd and if we always know interpreted vs. non then sender_sp() is really
// doing too much work.
return get_interpreterState()->sender_sp();
}
void frame::describe_pd(FrameValues& values, int frame_no) {
for (int w = 0; w < frame::register_save_words; w++) {
values.describe(frame_no, sp() + w, err_msg("register save area word %d", w), 1);
}
if (is_ricochet_frame()) {
MethodHandles::RicochetFrame::describe(this, values, frame_no);
} else if (is_interpreted_frame()) {
DESCRIBE_FP_OFFSET(interpreter_frame_d_scratch_fp);
DESCRIBE_FP_OFFSET(interpreter_frame_l_scratch_fp);
DESCRIBE_FP_OFFSET(interpreter_frame_padding);
DESCRIBE_FP_OFFSET(interpreter_frame_oop_temp);
// esp, according to Lesp (e.g. not depending on bci), if seems valid
intptr_t* esp = *interpreter_frame_esp_addr();
if ((esp >= sp()) && (esp < fp())) {
values.describe(-1, esp, "*Lesp");
}
}
if (!is_compiled_frame()) {
if (frame::callee_aggregate_return_pointer_words != 0) {
values.describe(frame_no, sp() + frame::callee_aggregate_return_pointer_sp_offset, "callee_aggregate_return_pointer_word");
}
for (int w = 0; w < frame::callee_register_argument_save_area_words; w++) {
values.describe(frame_no, sp() + frame::callee_register_argument_save_area_sp_offset + w,
err_msg("callee_register_argument_save_area_words %d", w));
}
}
}
void frame::restore_hcode_pointer() {
if (!is_interpreted_frame()) return;
// Readjust hcode pointer
u_char* obj = hp();
int offset = MarkSweep::next_hcode_offset();
// if (WizardMode) lprintf("[0x%lx+%d]\n", obj, offset);
set_hp(obj + offset);
}
void frame::pd_gc_epilog() {
if (is_interpreted_frame()) {
// set constant pool cache entry for interpreter
methodOop m = interpreter_frame_method();
*interpreter_frame_cpoolcache_addr() = m->constants()->cache();
}
}
bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
// QQQ
#ifdef CC_INTERP
#else
assert(is_interpreted_frame(), "Not an interpreted frame");
// These are reasonable sanity checks
if (fp() == 0 || (intptr_t(fp()) & (wordSize-1)) != 0) {
return false;
}
if (sp() == 0 || (intptr_t(sp()) & (wordSize-1)) != 0) {
return false;
}
if (fp() + interpreter_frame_initial_sp_offset < sp()) {
return false;
}
// These are hacks to keep us out of trouble.
// The problem with these is that they mask other problems
if (fp() <= sp()) { // this attempts to deal with unsigned comparison above
return false;
}
// do some validation of frame elements
// first the method
Method* m = *interpreter_frame_method_addr();
// validate the method we'd find in this potential sender
if (!m->is_valid_method()) return false;
// stack frames shouldn't be much larger than max_stack elements
if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) {
return false;
}
// validate bci/bcx
intptr_t bcx = interpreter_frame_bcx();
if (m->validate_bci_from_bcx(bcx) < 0) {
return false;
}
// validate ConstantPoolCache*
ConstantPoolCache* cp = *interpreter_frame_cache_addr();
if (cp == NULL || !cp->is_metaspace_object()) return false;
// validate locals
address locals = (address) *interpreter_frame_locals_addr();
if (locals > thread->stack_base() || locals < (address) fp()) return false;
// We'd have to be pretty unlucky to be mislead at this point
#endif // CC_INTERP
return true;
}
inline intptr_t* frame::sender_sp() const {
// Hmm this seems awfully expensive QQQ, is this really called with interpreted frames?
if (is_interpreted_frame()) {
assert(false, "should never happen");
return get_interpreterState()->sender_sp();
} else {
return addr_at(sender_sp_offset);
}
}
bool frame::interpreter_frame_equals_unpacked_fp(intptr_t* fp) {
assert(is_interpreted_frame(), "must be interpreter frame");
methodOop method = interpreter_frame_method();
// When unpacking an optimized frame the frame pointer is
// adjusted with:
int diff = (method->max_locals() - method->size_of_parameters()) *
Interpreter::stackElementWords;
return _fp == (fp - diff);
}
void frame::convert_hcode_pointer() {
if (!is_interpreted_frame()) return;
// Adjust hcode pointer to object start
u_char* h = hp();
u_char* obj = (u_char*) as_memOop(Universe::object_start((oop*) h));
set_hp(obj);
// Save the offset
MarkSweep::add_hcode_offset(h - obj);
// if (WizardMode) lprintf("[0x%lx+%d]\n", obj, h - obj);
}
BasicType frame::interpreter_frame_result(oop* oop_result,
jvalue* value_result) {
assert(is_interpreted_frame(), "interpreted frame expected");
Method* method = interpreter_frame_method();
BasicType type = method->result_type();
intptr_t* tos_addr = (intptr_t *) interpreter_frame_tos_address();
oop obj;
switch (type) {
case T_VOID:
break;
case T_BOOLEAN:
value_result->z = *(jboolean *) tos_addr;
break;
case T_BYTE:
value_result->b = *(jbyte *) tos_addr;
break;
case T_CHAR:
value_result->c = *(jchar *) tos_addr;
break;
case T_SHORT:
value_result->s = *(jshort *) tos_addr;
break;
case T_INT:
value_result->i = *(jint *) tos_addr;
break;
case T_LONG:
value_result->j = *(jlong *) tos_addr;
break;
case T_FLOAT:
value_result->f = *(jfloat *) tos_addr;
break;
case T_DOUBLE:
value_result->d = *(jdouble *) tos_addr;
break;
case T_OBJECT:
case T_ARRAY:
if (method->is_native()) {
obj = get_interpreterState()->oop_temp();
}
else {
oop* obj_p = (oop *) tos_addr;
obj = (obj_p == NULL) ? (oop) NULL : *obj_p;
}
assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");
*oop_result = obj;
break;
default:
ShouldNotReachHere();
}
return type;
}
void frame::layout_iterate(FrameLayoutClosure* blk) {
if (is_interpreted_frame()){
oop* eos = temp_addr(0);
for (oop* p = sp(); p <= eos; p++)
blk->do_stack(eos-p, p);
blk->do_hp(hp_addr());
blk->do_receiver(receiver_addr());
blk->do_link(link_addr());
blk->do_return_addr(return_addr_addr());
}
}
frame frame::sender(RegisterMap* map) const {
assert(map != NULL, "map must be set");
assert(CodeCache::find_blob_unsafe(_pc) == _cb, "inconsistent");
// Default is not to follow arguments; update it accordingly below
map->set_include_argument_oops(false);
if (is_entry_frame()) return sender_for_entry_frame(map);
intptr_t* younger_sp = sp();
intptr_t* sp = sender_sp();
// Note: The version of this operation on any platform with callee-save
// registers must update the register map (if not null).
// In order to do this correctly, the various subtypes of
// of frame (interpreted, compiled, glue, native),
// must be distinguished. There is no need on SPARC for
// such distinctions, because all callee-save registers are
// preserved for all frames via SPARC-specific mechanisms.
//
// *** HOWEVER, *** if and when we make any floating-point
// registers callee-saved, then we will have to copy over
// the RegisterMap update logic from the Intel code.
// The constructor of the sender must know whether this frame is interpreted so it can set the
// sender's _sp_adjustment_by_callee field. An osr adapter frame was originally
// interpreted but its pc is in the code cache (for c1 -> osr_frame_return_id stub), so it must be
// explicitly recognized.
if (is_ricochet_frame()) return sender_for_ricochet_frame(map);
bool frame_is_interpreted = is_interpreted_frame();
if (frame_is_interpreted) {
map->make_integer_regs_unsaved();
map->shift_window(sp, younger_sp);
} else if (_cb != NULL) {
// Update the locations of implicitly saved registers to be their
// addresses in the register save area.
// For %o registers, the addresses of %i registers in the next younger
// frame are used.
map->shift_window(sp, younger_sp);
if (map->update_map()) {
// Tell GC to use argument oopmaps for some runtime stubs that need it.
// For C1, the runtime stub might not have oop maps, so set this flag
// outside of update_register_map.
map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread()));
if (_cb->oop_maps() != NULL) {
OopMapSet::update_register_map(this, map);
}
}
}
return frame(sp, younger_sp, frame_is_interpreted);
}
methodOop frame::method() const {
assert(is_interpreted_frame(), "must be interpreter frame");
// First we will check the interpreter frame is valid by checking the frame size.
// The interpreter guarantees hp is valid if the frame is at least 4 in size.
// (return address, link, receiver, hcode pointer)
if (frame_size() < minimum_size_for_deoptimized_frame) return NULL;
u_char* h = hp();
if (!Universe::old_gen.contains(h)) return NULL;
memOop obj = as_memOop(Universe::object_start((oop*) h));
return obj->is_method() ? methodOop(obj) : NULL;
}
void frame::describe_pd(FrameValues& values, int frame_no) {
if (is_interpreted_frame()) {
DESCRIBE_FP_OFFSET(interpreter_frame_sender_sp);
DESCRIBE_FP_OFFSET(interpreter_frame_last_sp);
DESCRIBE_FP_OFFSET(interpreter_frame_method);
DESCRIBE_FP_OFFSET(interpreter_frame_mdx);
DESCRIBE_FP_OFFSET(interpreter_frame_cache);
DESCRIBE_FP_OFFSET(interpreter_frame_locals);
DESCRIBE_FP_OFFSET(interpreter_frame_bcx);
DESCRIBE_FP_OFFSET(interpreter_frame_initial_sp);
}
}
BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) {
assert(is_interpreted_frame(), "interpreted frame expected");
Method* method = interpreter_frame_method();
BasicType type = method->result_type();
if (method->is_native()) {
// Prior to calling into the runtime to notify the method exit the possible
// result value is saved into the interpreter frame.
address lresult = (address)&(get_ijava_state()->lresult);
address fresult = (address)&(get_ijava_state()->fresult);
switch (method->result_type()) {
case T_OBJECT:
case T_ARRAY: {
*oop_result = JNIHandles::resolve(*(jobject*)lresult);
break;
}
// We use std/stfd to store the values.
case T_BOOLEAN : value_result->z = (jboolean) *(unsigned long*)lresult; break;
case T_INT : value_result->i = (jint) *(long*)lresult; break;
case T_CHAR : value_result->c = (jchar) *(unsigned long*)lresult; break;
case T_SHORT : value_result->s = (jshort) *(long*)lresult; break;
case T_BYTE : value_result->z = (jbyte) *(long*)lresult; break;
case T_LONG : value_result->j = (jlong) *(long*)lresult; break;
case T_FLOAT : value_result->f = (jfloat) *(double*)fresult; break;
case T_DOUBLE : value_result->d = (jdouble) *(double*)fresult; break;
case T_VOID : /* Nothing to do */ break;
default : ShouldNotReachHere();
}
} else {
intptr_t* tos_addr = interpreter_frame_tos_address();
switch (method->result_type()) {
case T_OBJECT:
case T_ARRAY: {
oop obj = *(oop*)tos_addr;
assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");
*oop_result = obj;
}
case T_BOOLEAN : value_result->z = (jboolean) *(jint*)tos_addr; break;
case T_BYTE : value_result->b = (jbyte) *(jint*)tos_addr; break;
case T_CHAR : value_result->c = (jchar) *(jint*)tos_addr; break;
case T_SHORT : value_result->s = (jshort) *(jint*)tos_addr; break;
case T_INT : value_result->i = *(jint*)tos_addr; break;
case T_LONG : value_result->j = *(jlong*)tos_addr; break;
case T_FLOAT : value_result->f = *(jfloat*)tos_addr; break;
case T_DOUBLE : value_result->d = *(jdouble*)tos_addr; break;
case T_VOID : /* Nothing to do */ break;
default : ShouldNotReachHere();
}
}
return type;
}
void frame::print() const {
std->print("[%s frame: fp = %#lx, sp = %#lx, pc = %#lx", print_name(), fp(), sp(), pc());
if (is_compiled_frame()) {
std->print(", nm = %#x", findNMethod(pc()));
} else if (is_interpreted_frame()) {
std->print(", hp = %#x, method = %#x", hp(), method());
}
std->print_cr("]");
if (PrintLongFrames) {
for (oop* p = sp(); p < (oop*)fp(); p++)
std->print_cr(" - 0x%lx: 0x%lx", p, *p);
}
}
inline intptr_t* frame::sender_sp() const {
if (is_interpreted_frame()) {
return (intptr_t*) (*register_addr(GR_Lsave_SP));
} else {
#ifndef CORE
CodeBlob* cb = CodeCache::find_blob(pc());
assert(cb != NULL, "Didn't find code");
return compiled_sender_sp(cb);
#else
ShouldNotReachHere();
return NULL;
#endif
}
}
//------------------------------------------------------------------------------
// frame::sender
frame frame::sender(RegisterMap* map) const {
// Default is we done have to follow them. The sender_for_xxx will
// update it accordingly
map->set_include_argument_oops(false);
if (is_entry_frame()) return sender_for_entry_frame(map);
if (is_interpreted_frame()) return sender_for_interpreter_frame(map);
assert(_cb == CodeCache::find_blob(pc()),"Must be the same");
if (_cb != NULL) {
return sender_for_compiled_frame(map);
}
// Must be native-compiled frame, i.e. the marshaling code for native
// methods that exists in the core system.
return frame(sender_sp(), link(), sender_pc());
}
void frame::oop_iterate(OopClosure* blk) {
if (is_interpreted_frame()) {
if (has_interpreted_float_marker() && oop_iterate_interpreted_float_frame(blk)) return;
// lprintf("Frame: fp = %#lx, sp = %#lx]\n", fp(), sp());
for (oop* p = sp(); p <= temp_addr(0); p++) {
// lprintf("\t[%#lx]: ", p);
// (*p)->short_print();
// lprintf("\n");
blk->do_oop(p);
}
// lprintf("\t{%#lx}: ", receiver_addr());
// (*receiver_addr())->short_print();
// lprintf("\n");
blk->do_oop(receiver_addr());
return;
}
if (is_compiled_frame()) {
if (has_compiled_float_marker() && oop_iterate_compiled_float_frame(blk)) return;
// All oops are [sp..fp[
for (oop* p = sp(); p < (oop*)fp(); p++) {
blk->do_oop(p);
}
return;
}
if (is_entry_frame()) {
// All oops are [sp..fp[
for (oop* p = sp(); p < (oop*)fp(); p++) {
blk->do_oop(p);
}
return;
}
if (is_deoptimized_frame()) {
// Expression stack
oop* end = (oop*)fp() + frame_real_sender_sp_offset;
// All oops are [sp..end[
for (oop* p = sp(); p < end; p++) {
blk->do_oop(p);
}
blk->do_oop((oop*)frame_array_addr());
return;
}
}
InterpretedIC* frame::current_interpretedIC() const {
if (is_interpreted_frame()) {
methodOop m = method();
int bci = m->bci_from(hp());
u_char* codeptr = m->codes(bci);
if (Bytecodes::is_send_code(Bytecodes::Code(*codeptr))) {
InterpretedIC* ic = as_InterpretedIC((char*)hp());
assert(ic->send_code_addr() == codeptr, "found wrong ic");
return ic;
} else {
return NULL; // perform, dll call, etc.
}
}
return NULL; // doesn't have InterpretedIC
}
void frame::describe_pd(FrameValues& values, int frame_no) {
if (is_interpreted_frame()) {
#ifdef CC_INTERP
interpreterState istate = get_interpreterState();
values.describe(frame_no, (intptr_t*)istate, "istate");
values.describe(frame_no, (intptr_t*)&(istate->_thread), " thread");
values.describe(frame_no, (intptr_t*)&(istate->_bcp), " bcp");
values.describe(frame_no, (intptr_t*)&(istate->_locals), " locals");
values.describe(frame_no, (intptr_t*)&(istate->_constants), " constants");
values.describe(frame_no, (intptr_t*)&(istate->_method), err_msg(" method = %s", istate->_method->name_and_sig_as_C_string()));
values.describe(frame_no, (intptr_t*)&(istate->_mdx), " mdx");
values.describe(frame_no, (intptr_t*)&(istate->_stack), " stack");
values.describe(frame_no, (intptr_t*)&(istate->_msg), err_msg(" msg = %s", BytecodeInterpreter::C_msg(istate->_msg)));
values.describe(frame_no, (intptr_t*)&(istate->_result), " result");
values.describe(frame_no, (intptr_t*)&(istate->_prev_link), " prev_link");
values.describe(frame_no, (intptr_t*)&(istate->_oop_temp), " oop_temp");
values.describe(frame_no, (intptr_t*)&(istate->_stack_base), " stack_base");
values.describe(frame_no, (intptr_t*)&(istate->_stack_limit), " stack_limit");
values.describe(frame_no, (intptr_t*)&(istate->_monitor_base), " monitor_base");
values.describe(frame_no, (intptr_t*)&(istate->_frame_bottom), " frame_bottom");
values.describe(frame_no, (intptr_t*)&(istate->_last_Java_pc), " last_Java_pc");
values.describe(frame_no, (intptr_t*)&(istate->_last_Java_fp), " last_Java_fp");
values.describe(frame_no, (intptr_t*)&(istate->_last_Java_sp), " last_Java_sp");
values.describe(frame_no, (intptr_t*)&(istate->_self_link), " self_link");
values.describe(frame_no, (intptr_t*)&(istate->_native_fresult), " native_fresult");
values.describe(frame_no, (intptr_t*)&(istate->_native_lresult), " native_lresult");
#else
#define DESCRIBE_ADDRESS(name) \
values.describe(frame_no, (intptr_t*)&(get_ijava_state()->name), #name);
DESCRIBE_ADDRESS(method);
DESCRIBE_ADDRESS(locals);
DESCRIBE_ADDRESS(monitors);
DESCRIBE_ADDRESS(cpoolCache);
DESCRIBE_ADDRESS(bcp);
DESCRIBE_ADDRESS(esp);
DESCRIBE_ADDRESS(mdx);
DESCRIBE_ADDRESS(top_frame_sp);
DESCRIBE_ADDRESS(sender_sp);
DESCRIBE_ADDRESS(oop_tmp);
DESCRIBE_ADDRESS(lresult);
DESCRIBE_ADDRESS(fresult);
#endif
}
}
IC_Iterator* frame::current_ic_iterator() const {
if (is_interpreted_frame()) {
InterpretedIC* ic = current_interpretedIC();
if (ic && !Bytecodes::is_send_code(ic->send_code())) return NULL;
return ic ? new InterpretedIC_Iterator(ic) : NULL;
}
if (is_compiled_frame()) {
CompiledIC* ic = current_compiledIC();
return ic->inlineCache()
? new CompiledIC_Iterator(ic)
: NULL; // a perform, not a send
}
// entry or deoptimized frame
return NULL;
}
void frame::describe_pd(FrameValues& values, int frame_no) {
if (is_interpreted_frame()) {
DESCRIBE_FP_OFFSET(interpreter_frame_sender_sp);
DESCRIBE_FP_OFFSET(interpreter_frame_last_sp);
DESCRIBE_FP_OFFSET(interpreter_frame_method);
DESCRIBE_FP_OFFSET(interpreter_frame_mdx);
DESCRIBE_FP_OFFSET(interpreter_frame_cache);
DESCRIBE_FP_OFFSET(interpreter_frame_locals);
DESCRIBE_FP_OFFSET(interpreter_frame_bcx);
DESCRIBE_FP_OFFSET(interpreter_frame_initial_sp);
} else if (is_entry_frame()) {
// This could be more descriptive if we use the enum in
// stubGenerator to map to real names but it's most important to
// claim these frame slots so the error checking works.
for (int i = 0; i < entry_frame_after_call_words; i++) {
values.describe(frame_no, fp() - i, err_msg("call_stub word fp - %d", i));
}
}
}
void frame::describe_pd(FrameValues& values, int frame_no) {
if (is_interpreted_frame()) {
#define DESCRIBE_ADDRESS(name) \
values.describe(frame_no, (intptr_t*)&(get_ijava_state()->name), #name);
DESCRIBE_ADDRESS(method);
DESCRIBE_ADDRESS(mirror);
DESCRIBE_ADDRESS(locals);
DESCRIBE_ADDRESS(monitors);
DESCRIBE_ADDRESS(cpoolCache);
DESCRIBE_ADDRESS(bcp);
DESCRIBE_ADDRESS(esp);
DESCRIBE_ADDRESS(mdx);
DESCRIBE_ADDRESS(top_frame_sp);
DESCRIBE_ADDRESS(sender_sp);
DESCRIBE_ADDRESS(oop_tmp);
DESCRIBE_ADDRESS(lresult);
DESCRIBE_ADDRESS(fresult);
}
}
BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) {
#ifdef CC_INTERP
// Needed for JVMTI. The result should always be in the
// interpreterState object
interpreterState istate = get_interpreterState();
#endif // CC_INTERP
assert(is_interpreted_frame(), "interpreted frame expected");
methodOop method = interpreter_frame_method();
BasicType type = method->result_type();
intptr_t* tos_addr;
if (method->is_native()) {
// Prior to calling into the runtime to report the method_exit the possible
// return value is pushed to the native stack. If the result is a jfloat/jdouble
// then ST0 is saved before EAX/EDX. See the note in generate_native_result
tos_addr = (intptr_t*)sp();
if (type == T_FLOAT || type == T_DOUBLE) {
// QQQ seems like this code is equivalent on the two platforms
#ifdef AMD64
// This is times two because we do a push(ltos) after pushing XMM0
// and that takes two interpreter stack slots.
tos_addr += 2 * Interpreter::stackElementWords;
#else
tos_addr += 2;
#endif // AMD64
}
} else {
tos_addr = (intptr_t*)interpreter_frame_tos_address();
}
switch (type) {
case T_OBJECT :
case T_ARRAY : {
oop obj;
if (method->is_native()) {
#ifdef CC_INTERP
obj = istate->_oop_temp;
#else
obj = (oop) at(interpreter_frame_oop_temp_offset);
#endif // CC_INTERP
} else {
oop* obj_p = (oop*)tos_addr;
obj = (obj_p == NULL) ? (oop)NULL : *obj_p;
}
assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");
*oop_result = obj;
break;
}
case T_BOOLEAN : value_result->z = *(jboolean*)tos_addr; break;
case T_BYTE : value_result->b = *(jbyte*)tos_addr; break;
case T_CHAR : value_result->c = *(jchar*)tos_addr; break;
case T_SHORT : value_result->s = *(jshort*)tos_addr; break;
case T_INT : value_result->i = *(jint*)tos_addr; break;
case T_LONG : value_result->j = *(jlong*)tos_addr; break;
case T_FLOAT : {
#ifdef AMD64
value_result->f = *(jfloat*)tos_addr;
#else
if (method->is_native()) {
jdouble d = *(jdouble*)tos_addr; // Result was in ST0 so need to convert to jfloat
value_result->f = (jfloat)d;
} else {
value_result->f = *(jfloat*)tos_addr;
}
#endif // AMD64
break;
}
case T_DOUBLE : value_result->d = *(jdouble*)tos_addr; break;
case T_VOID : /* Nothing to do */ break;
default : ShouldNotReachHere();
}
return type;
}
bool frame::safe_for_sender(JavaThread *thread) {
address sp = (address)_sp;
address fp = (address)_fp;
address unextended_sp = (address)_unextended_sp;
// consider stack guards when trying to determine "safe" stack pointers
static size_t stack_guard_size = os::uses_stack_guard_pages() ? (StackYellowPages + StackRedPages) * os::vm_page_size() : 0;
size_t usable_stack_size = thread->stack_size() - stack_guard_size;
// sp must be within the usable part of the stack (not in guards)
bool sp_safe = (sp < thread->stack_base()) &&
(sp >= thread->stack_base() - usable_stack_size);
if (!sp_safe) {
return false;
}
// unextended sp must be within the stack and above or equal sp
bool unextended_sp_safe = (unextended_sp < thread->stack_base()) &&
(unextended_sp >= sp);
if (!unextended_sp_safe) {
return false;
}
// an fp must be within the stack and above (but not equal) sp
// second evaluation on fp+ is added to handle situation where fp is -1
bool fp_safe = (fp < thread->stack_base() && (fp > sp) && (((fp + (return_addr_offset * sizeof(void*))) < thread->stack_base())));
// We know sp/unextended_sp are safe only fp is questionable here
// If the current frame is known to the code cache then we can attempt to
// to construct the sender and do some validation of it. This goes a long way
// toward eliminating issues when we get in frame construction code
if (_cb != NULL ) {
// First check if frame is complete and tester is reliable
// Unfortunately we can only check frame complete for runtime stubs and nmethod
// other generic buffer blobs are more problematic so we just assume they are
// ok. adapter blobs never have a frame complete and are never ok.
if (!_cb->is_frame_complete_at(_pc)) {
if (_cb->is_nmethod() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
return false;
}
}
// Could just be some random pointer within the codeBlob
if (!_cb->code_contains(_pc)) {
return false;
}
// Entry frame checks
if (is_entry_frame()) {
// an entry frame must have a valid fp.
if (!fp_safe) return false;
// Validate the JavaCallWrapper an entry frame must have
address jcw = (address)entry_frame_call_wrapper();
bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > fp);
return jcw_safe;
}
intptr_t* sender_sp = NULL;
address sender_pc = NULL;
if (is_interpreted_frame()) {
// fp must be safe
if (!fp_safe) {
return false;
}
sender_pc = (address) this->fp()[return_addr_offset];
sender_sp = (intptr_t*) addr_at(sender_sp_offset);
} else {
// must be some sort of compiled/runtime frame
// fp does not have to be safe (although it could be check for c1?)
// check for a valid frame_size, otherwise we are unlikely to get a valid sender_pc
if (_cb->frame_size() <= 0) {
return false;
}
sender_sp = _unextended_sp + _cb->frame_size();
// On Intel the return_address is always the word on the stack
sender_pc = (address) *(sender_sp-1);
}
// If the potential sender is the interpreter then we can do some more checking
if (Interpreter::contains(sender_pc)) {
// ebp is always saved in a recognizable place in any code we generate. However
// only if the sender is interpreted/call_stub (c1 too?) are we certain that the saved ebp
// is really a frame pointer.
intptr_t *saved_fp = (intptr_t*)*(sender_sp - frame::sender_sp_offset);
bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
if (!saved_fp_safe) {
return false;
}
// construct the potential sender
frame sender(sender_sp, saved_fp, sender_pc);
return sender.is_interpreted_frame_valid(thread);
}
// We must always be able to find a recognizable pc
CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc);
if (sender_pc == NULL || sender_blob == NULL) {
return false;
}
// Could be a zombie method
if (sender_blob->is_zombie() || sender_blob->is_unloaded()) {
return false;
}
// Could just be some random pointer within the codeBlob
if (!sender_blob->code_contains(sender_pc)) {
return false;
}
// We should never be able to see an adapter if the current frame is something from code cache
if (sender_blob->is_adapter_blob()) {
return false;
}
// Could be the call_stub
if (StubRoutines::returns_to_call_stub(sender_pc)) {
intptr_t *saved_fp = (intptr_t*)*(sender_sp - frame::sender_sp_offset);
bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
if (!saved_fp_safe) {
return false;
}
// construct the potential sender
frame sender(sender_sp, saved_fp, sender_pc);
// Validate the JavaCallWrapper an entry frame must have
address jcw = (address)sender.entry_frame_call_wrapper();
bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > (address)sender.fp());
return jcw_safe;
}
if (sender_blob->is_nmethod()) {
nmethod* nm = sender_blob->as_nmethod_or_null();
if (nm != NULL) {
if (nm->is_deopt_mh_entry(sender_pc) || nm->is_deopt_entry(sender_pc)) {
return false;
}
}
}
// If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
// because the return address counts against the callee's frame.
if (sender_blob->frame_size() <= 0) {
assert(!sender_blob->is_nmethod(), "should count return address at least");
return false;
}
// We should never be able to see anything here except an nmethod. If something in the
// code cache (current frame) is called by an entity within the code cache that entity
// should not be anything but the call stub (already covered), the interpreter (already covered)
// or an nmethod.
if (!sender_blob->is_nmethod()) {
return false;
}
// Could put some more validation for the potential non-interpreted sender
// frame we'd create by calling sender if I could think of any. Wait for next crash in forte...
// One idea is seeing if the sender_pc we have is one that we'd expect to call to current cb
// We've validated the potential sender that would be created
return true;
}
// Must be native-compiled frame. Since sender will try and use fp to find
// linkages it must be safe
if (!fp_safe) {
return false;
}
// Will the pc we fetch be non-zero (which we'll find at the oldest frame)
if ( (address) this->fp()[return_addr_offset] == NULL) return false;
// could try and do some more potential verification of native frame if we could think of some...
return true;
}
void frame::set_interpreter_frame_sender_sp(intptr_t* sender_sp) {
assert(is_interpreted_frame(), "interpreted frame expected");
ptr_at_put(interpreter_frame_sender_sp_offset, (intptr_t) sender_sp);
}
intptr_t* frame::interpreter_frame_sender_sp() const {
assert(is_interpreted_frame(), "interpreted frame expected");
return (intptr_t*) at(interpreter_frame_sender_sp_offset);
}
bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
// Is there anything to do?
assert(is_interpreted_frame(), "Not an interpreted frame");
return true;
}
