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(); }
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); } }
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::patch_pc(Thread* thread, address pc) { if (pc != NULL) { _cb = CodeCache::find_blob(pc); SharkFrame* sharkframe = zeroframe()->as_shark_frame(); sharkframe->set_pc(pc); _pc = pc; _deopt_state = is_deoptimized; } else { // We borrow this call to set the thread pointer in the interpreter // state; the hook to set up deoptimized frames isn't supplied it. assert(pc == NULL, "should be"); get_interpreterState()->set_thread((JavaThread *) thread); } }
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 } }
inline intptr_t* frame::interpreter_frame_mdx_addr() const { assert(is_interpreted_frame(), "must be interpreted"); return (intptr_t*) &(get_interpreterState()->_mdx); }
BasicObjectLock* frame::interpreter_frame_monitor_end() const { return (BasicObjectLock*) get_interpreterState()->stack_base(); }
inline methodOop* frame::interpreter_frame_method_addr() const { interpreterState istate = get_interpreterState(); return &istate->_method; }
inline intptr_t* frame::interpreter_frame_mdx_addr() const { return (intptr_t*) &(get_interpreterState()->_mdx); }
// top of expression stack (lowest address) inline intptr_t* frame::interpreter_frame_tos_address() const { interpreterState istate = get_interpreterState(); return istate->_stack + 1; // Is this off by one? QQQ }
inline methodOop* frame::interpreter_frame_method_addr() const { return &(get_interpreterState()->_method); }
inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const { return &(get_interpreterState()->_constants); }
inline intptr_t* frame::interpreter_frame_tos_address() const { return get_interpreterState()->_stack + 1; }
// top of expression stack inline intptr_t* frame::interpreter_frame_tos_address() const { assert(is_interpreted_frame(), "wrong frame type"); return get_interpreterState()->_stack + 1; }
// where LcpoolCache is saved: inline constantPoolCacheOop* frame::interpreter_frame_cpoolcache_addr() const { interpreterState istate = get_interpreterState(); return &istate->_constants; // should really use accessor }
BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) { assert(is_interpreted_frame(), "interpreted frame expected"); methodOop method = interpreter_frame_method(); BasicType type = method->result_type(); if (method->is_native()) { // Prior to notifying the runtime of the method_exit the possible result // value is saved to l_scratch and d_scratch. #ifdef CC_INTERP interpreterState istate = get_interpreterState(); intptr_t* l_scratch = (intptr_t*) &istate->_native_lresult; intptr_t* d_scratch = (intptr_t*) &istate->_native_fresult; #else /* CC_INTERP */ intptr_t* l_scratch = fp() + interpreter_frame_l_scratch_fp_offset; intptr_t* d_scratch = fp() + interpreter_frame_d_scratch_fp_offset; #endif /* CC_INTERP */ address l_addr = (address)l_scratch; #ifdef _LP64 // On 64-bit the result for 1/8/16/32-bit result types is in the other // word half l_addr += wordSize/2; #endif switch (type) { case T_OBJECT: case T_ARRAY: { #ifdef CC_INTERP *oop_result = istate->_oop_temp; #else oop obj = (oop) at(interpreter_frame_oop_temp_offset); assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check"); *oop_result = obj; #endif // CC_INTERP break; } case T_BOOLEAN : { jint* p = (jint*)l_addr; value_result->z = (jboolean)((*p) & 0x1); break; } case T_BYTE : { jint* p = (jint*)l_addr; value_result->b = (jbyte)((*p) & 0xff); break; } case T_CHAR : { jint* p = (jint*)l_addr; value_result->c = (jchar)((*p) & 0xffff); break; } case T_SHORT : { jint* p = (jint*)l_addr; value_result->s = (jshort)((*p) & 0xffff); break; } case T_INT : value_result->i = *(jint*)l_addr; break; case T_LONG : value_result->j = *(jlong*)l_scratch; break; case T_FLOAT : value_result->f = *(jfloat*)d_scratch; break; case T_DOUBLE : value_result->d = *(jdouble*)d_scratch; break; case T_VOID : /* Nothing to do */ break; default : ShouldNotReachHere(); } } else { intptr_t* tos_addr = interpreter_frame_tos_address(); switch(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; break; } case T_BOOLEAN : { jint* p = (jint*)tos_addr; value_result->z = (jboolean)((*p) & 0x1); break; } case T_BYTE : { jint* p = (jint*)tos_addr; value_result->b = (jbyte)((*p) & 0xff); break; } case T_CHAR : { jint* p = (jint*)tos_addr; value_result->c = (jchar)((*p) & 0xffff); break; } case T_SHORT : { jint* p = (jint*)tos_addr; value_result->s = (jshort)((*p) & 0xffff); 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; }
inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const { interpreterState istate = get_interpreterState(); return &istate->_constants; }
BasicObjectLock* frame::interpreter_frame_monitor_begin() const { return get_interpreterState()->monitor_base(); }
inline intptr_t* frame::interpreter_frame_mdx_addr() const { interpreterState istate = get_interpreterState(); return (intptr_t*) &istate->_mdx; }
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; }
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. #ifdef CC_INTERP interpreterState istate = get_interpreterState(); address lresult = (address)istate + in_bytes(BytecodeInterpreter::native_lresult_offset()); address fresult = (address)istate + in_bytes(BytecodeInterpreter::native_fresult_offset()); #else address lresult = (address)&(get_ijava_state()->lresult); address fresult = (address)&(get_ijava_state()->fresult); #endif switch (method->result_type()) { case T_OBJECT: case T_ARRAY: { oop* obj_p = *(oop**)lresult; oop obj = (obj_p == NULL) ? (oop)NULL : *obj_p; assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check"); *oop_result = obj; 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; }