--- old/src/cpu/ppc/vm/frame_ppc.cpp 2014-07-14 19:49:17.384304201 -0400 +++ new/src/cpu/ppc/vm/frame_ppc.cpp 2014-07-14 19:49:17.100304201 -0400 @@ -155,15 +155,6 @@ } } -void frame::pd_gc_epilog() { - if (is_interpreted_frame()) { - // Set constant pool cache entry for interpreter. - Method* m = interpreter_frame_method(); - - *interpreter_frame_cpoolcache_addr() = m->constants()->cache(); - } -} - bool frame::is_interpreted_frame_valid(JavaThread* thread) const { // Is there anything to do? assert(is_interpreted_frame(), "Not an interpreted frame"); --- old/src/cpu/ppc/vm/frame_ppc.inline.hpp 2014-07-14 19:49:18.296304200 -0400 +++ new/src/cpu/ppc/vm/frame_ppc.inline.hpp 2014-07-14 19:49:18.036304200 -0400 @@ -134,12 +134,12 @@ return (intptr_t**)&istate->_locals; } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { +inline intptr_t* frame::interpreter_frame_bcp_addr() const { interpreterState istate = get_interpreterState(); return (intptr_t*)&istate->_bcp; } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { +inline intptr_t* frame::interpreter_frame_mdp_addr() const { interpreterState istate = get_interpreterState(); return (intptr_t*)&istate->_mdx; } @@ -209,10 +209,10 @@ inline intptr_t** frame::interpreter_frame_locals_addr() const { return (intptr_t**) &(get_ijava_state()->locals); } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { +inline intptr_t* frame::interpreter_frame_bcp_addr() const { return (intptr_t*) &(get_ijava_state()->bcp); } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { +inline intptr_t* frame::interpreter_frame_mdp_addr() const { return (intptr_t*) &(get_ijava_state()->mdx); } // Pointer beyond the "oldest/deepest" BasicObjectLock on stack. --- old/src/cpu/sparc/vm/frame_sparc.cpp 2014-07-14 19:49:19.184304199 -0400 +++ new/src/cpu/sparc/vm/frame_sparc.cpp 2014-07-14 19:49:18.916304199 -0400 @@ -593,17 +593,6 @@ return this->fp() == fp; } - -void frame::pd_gc_epilog() { - if (is_interpreted_frame()) { - // set constant pool cache entry for interpreter - Method* m = interpreter_frame_method(); - - *interpreter_frame_cpoolcache_addr() = m->constants()->cache(); - } -} - - bool frame::is_interpreted_frame_valid(JavaThread* thread) const { #ifdef CC_INTERP // Is there anything to do? @@ -641,10 +630,10 @@ return false; } - // validate bci/bcx + // validate bci/bcp - intptr_t bcx = interpreter_frame_bcx(); - if (m->validate_bci_from_bcx(bcx) < 0) { + address bcp = interpreter_frame_bcp(); + if (m->validate_bci_from_bcp(bcp) < 0) { return false; } --- old/src/cpu/sparc/vm/frame_sparc.hpp 2014-07-14 19:49:20.076304198 -0400 +++ new/src/cpu/sparc/vm/frame_sparc.hpp 2014-07-14 19:49:19.808304198 -0400 @@ -78,7 +78,6 @@ // Lesp first free element of expression stack // (which grows towards __higher__ addresses) // Lbcp is set to address of bytecode to execute -// It is accessed in the frame under the name "bcx". // It may at times (during GC) be an index instead. // Lmethod the method being interpreted // Llocals the base pointer for accessing the locals array --- old/src/cpu/sparc/vm/frame_sparc.inline.hpp 2014-07-14 19:49:20.952304197 -0400 +++ new/src/cpu/sparc/vm/frame_sparc.inline.hpp 2014-07-14 19:49:20.696304198 -0400 @@ -98,12 +98,12 @@ return (intptr_t**) &istate->_locals; } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { +inline intptr_t* frame::interpreter_frame_bcp_addr() const { interpreterState istate = get_interpreterState(); return (intptr_t*) &istate->_bcp; } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { +inline intptr_t* frame::interpreter_frame_mdp_addr() const { interpreterState istate = get_interpreterState(); return (intptr_t*) &istate->_mdx; } @@ -165,12 +165,11 @@ return (intptr_t**) sp_addr_at( Llocals->sp_offset_in_saved_window()); } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { - // %%%%% reinterpreting Lbcp as a bcx +inline intptr_t* frame::interpreter_frame_bcp_addr() const { return (intptr_t*) sp_addr_at( Lbcp->sp_offset_in_saved_window()); } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { +inline intptr_t* frame::interpreter_frame_mdp_addr() const { // %%%%% reinterpreting ImethodDataPtr as a mdx return (intptr_t*) sp_addr_at( ImethodDataPtr->sp_offset_in_saved_window()); } --- old/src/cpu/sparc/vm/macroAssembler_sparc.hpp 2014-07-14 19:49:21.860304196 -0400 +++ new/src/cpu/sparc/vm/macroAssembler_sparc.hpp 2014-07-14 19:49:21.596304197 -0400 @@ -186,8 +186,7 @@ // the interpreter to work right // (These assignments must be compatible with L7_thread_cache; see above.) -// Since Lbcp points into the middle of the method object, -// it is temporarily converted into a "bcx" during GC. +// Lbcp points into the middle of the method object. // Exception processing // These registers are passed into exception handlers. --- old/src/cpu/sparc/vm/templateInterpreter_sparc.cpp 2014-07-14 19:49:22.736304196 -0400 +++ new/src/cpu/sparc/vm/templateInterpreter_sparc.cpp 2014-07-14 19:49:22.488304196 -0400 @@ -1785,7 +1785,7 @@ __ verify_thread(); // expression stack is undefined here // O0: exception, i.e. Oexception - // Lbcp: exception bcx + // Lbcp: exception bcp __ verify_oop(Oexception); --- old/src/cpu/x86/vm/frame_x86.cpp 2014-07-14 19:49:23.640304195 -0400 +++ new/src/cpu/x86/vm/frame_x86.cpp 2014-07-14 19:49:23.368304195 -0400 @@ -537,10 +537,6 @@ return _fp == (fp - diff); } -void frame::pd_gc_epilog() { - // nothing done here now -} - bool frame::is_interpreted_frame_valid(JavaThread* thread) const { // QQQ #ifdef CC_INTERP @@ -577,10 +573,10 @@ return false; } - // validate bci/bcx + // validate bci/bcp - intptr_t bcx = interpreter_frame_bcx(); - if (m->validate_bci_from_bcx(bcx) < 0) { + address bcp = interpreter_frame_bcp(); + if (m->validate_bci_from_bcp(bcp) < 0) { return false; } @@ -692,10 +688,10 @@ 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_mdp); DESCRIBE_FP_OFFSET(interpreter_frame_cache); DESCRIBE_FP_OFFSET(interpreter_frame_locals); - DESCRIBE_FP_OFFSET(interpreter_frame_bcx); + DESCRIBE_FP_OFFSET(interpreter_frame_bcp); DESCRIBE_FP_OFFSET(interpreter_frame_initial_sp); #endif } --- old/src/cpu/x86/vm/frame_x86.hpp 2014-07-14 19:49:24.524304194 -0400 +++ new/src/cpu/x86/vm/frame_x86.hpp 2014-07-14 19:49:24.256304194 -0400 @@ -40,7 +40,7 @@ // ... | monitor block size // [monitors ] / // [monitor block size ] -// [byte code index/pointr] = bcx() bcx_offset +// [byte code pointer ] = bcp() bcp_offset // [pointer to locals ] = locals() locals_offset // [constant pool cache ] = cache() cache_offset // [methodData ] = mdp() mdx_offset @@ -111,11 +111,11 @@ // outgoing sp before a call to an invoked method interpreter_frame_last_sp_offset = interpreter_frame_sender_sp_offset - 1, interpreter_frame_method_offset = interpreter_frame_last_sp_offset - 1, - interpreter_frame_mdx_offset = interpreter_frame_method_offset - 1, - interpreter_frame_cache_offset = interpreter_frame_mdx_offset - 1, + interpreter_frame_mdp_offset = interpreter_frame_method_offset - 1, + interpreter_frame_cache_offset = interpreter_frame_mdp_offset - 1, interpreter_frame_locals_offset = interpreter_frame_cache_offset - 1, - interpreter_frame_bcx_offset = interpreter_frame_locals_offset - 1, - interpreter_frame_initial_sp_offset = interpreter_frame_bcx_offset - 1, + interpreter_frame_bcp_offset = interpreter_frame_locals_offset - 1, + interpreter_frame_initial_sp_offset = interpreter_frame_bcp_offset - 1, interpreter_frame_monitor_block_top_offset = interpreter_frame_initial_sp_offset, interpreter_frame_monitor_block_bottom_offset = interpreter_frame_initial_sp_offset, --- old/src/cpu/x86/vm/frame_x86.inline.hpp 2014-07-14 19:49:25.412304193 -0400 +++ new/src/cpu/x86/vm/frame_x86.inline.hpp 2014-07-14 19:49:25.140304193 -0400 @@ -168,7 +168,7 @@ return &(get_interpreterState()->_locals); } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { +inline intptr_t* frame::interpreter_frame_bcp_addr() const { assert(is_interpreted_frame(), "must be interpreted"); return (intptr_t*) &(get_interpreterState()->_bcp); } @@ -188,7 +188,7 @@ return &(get_interpreterState()->_method); } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { +inline intptr_t* frame::interpreter_frame_mdp_addr() const { assert(is_interpreted_frame(), "must be interpreted"); return (intptr_t*) &(get_interpreterState()->_mdx); } @@ -210,13 +210,13 @@ return *(intptr_t**)addr_at(interpreter_frame_last_sp_offset); } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { - return (intptr_t*)addr_at(interpreter_frame_bcx_offset); +inline intptr_t* frame::interpreter_frame_bcp_addr() const { + return (intptr_t*)addr_at(interpreter_frame_bcp_offset); } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { - return (intptr_t*)addr_at(interpreter_frame_mdx_offset); +inline intptr_t* frame::interpreter_frame_mdp_addr() const { + return (intptr_t*)addr_at(interpreter_frame_mdp_offset); } --- old/src/cpu/x86/vm/interp_masm_x86.cpp 2014-07-14 19:49:26.312304192 -0400 +++ new/src/cpu/x86/vm/interp_masm_x86.cpp 2014-07-14 19:49:26.040304192 -0400 @@ -134,7 +134,7 @@ shll(tmp, exact_log2(DataLayout::cell_size)); addptr(mdp, tmp); } - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp); } else { assert(MethodData::profile_return(), "either profile call args or call ret"); update_mdp_by_constant(mdp, in_bytes(TypeEntriesAtCall::return_only_size())); --- old/src/cpu/x86/vm/interp_masm_x86_32.cpp 2014-07-14 19:49:27.180304191 -0400 +++ new/src/cpu/x86/vm/interp_masm_x86_32.cpp 2014-07-14 19:49:26.928304192 -0400 @@ -826,7 +826,7 @@ // Test ImethodDataPtr. If it is null, continue at the specified label void InterpreterMacroAssembler::test_method_data_pointer(Register mdp, Label& zero_continue) { assert(ProfileInterpreter, "must be profiling interpreter"); - movptr(mdp, Address(rbp, frame::interpreter_frame_mdx_offset * wordSize)); + movptr(mdp, Address(rbp, frame::interpreter_frame_mdp_offset * wordSize)); testptr(mdp, mdp); jcc(Assembler::zero, zero_continue); } @@ -853,7 +853,7 @@ addptr(rbx, in_bytes(MethodData::data_offset())); addptr(rax, rbx); bind(set_mdp); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), rax); pop(rbx); pop(rax); } @@ -975,7 +975,7 @@ assert(ProfileInterpreter, "must be profiling interpreter"); Address disp_address(mdp_in, offset_of_disp); addptr(mdp_in,disp_address); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp_in); } @@ -983,14 +983,14 @@ assert(ProfileInterpreter, "must be profiling interpreter"); Address disp_address(mdp_in, reg, Address::times_1, offset_of_disp); addptr(mdp_in, disp_address); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp_in); } void InterpreterMacroAssembler::update_mdp_by_constant(Register mdp_in, int constant) { assert(ProfileInterpreter, "must be profiling interpreter"); addptr(mdp_in, constant); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp_in); } --- old/src/cpu/x86/vm/interp_masm_x86_32.hpp 2014-07-14 19:49:28.064304191 -0400 +++ new/src/cpu/x86/vm/interp_masm_x86_32.hpp 2014-07-14 19:49:27.796304191 -0400 @@ -61,8 +61,8 @@ #else - void save_bcp() { movptr(Address(rbp, frame::interpreter_frame_bcx_offset * wordSize), rsi); } - void restore_bcp() { movptr(rsi, Address(rbp, frame::interpreter_frame_bcx_offset * wordSize)); } + void save_bcp() { movptr(Address(rbp, frame::interpreter_frame_bcp_offset * wordSize), rsi); } + void restore_bcp() { movptr(rsi, Address(rbp, frame::interpreter_frame_bcp_offset * wordSize)); } void restore_locals() { movptr(rdi, Address(rbp, frame::interpreter_frame_locals_offset * wordSize)); } // Helpers for runtime call arguments/results --- old/src/cpu/x86/vm/interp_masm_x86_64.cpp 2014-07-14 19:49:28.952304190 -0400 +++ new/src/cpu/x86/vm/interp_masm_x86_64.cpp 2014-07-14 19:49:28.680304190 -0400 @@ -841,7 +841,7 @@ void InterpreterMacroAssembler::test_method_data_pointer(Register mdp, Label& zero_continue) { assert(ProfileInterpreter, "must be profiling interpreter"); - movptr(mdp, Address(rbp, frame::interpreter_frame_mdx_offset * wordSize)); + movptr(mdp, Address(rbp, frame::interpreter_frame_mdp_offset * wordSize)); testptr(mdp, mdp); jcc(Assembler::zero, zero_continue); } @@ -868,7 +868,7 @@ addptr(rbx, in_bytes(MethodData::data_offset())); addptr(rax, rbx); bind(set_mdp); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), rax); pop(rbx); pop(rax); } @@ -991,7 +991,7 @@ assert(ProfileInterpreter, "must be profiling interpreter"); Address disp_address(mdp_in, offset_of_disp); addptr(mdp_in, disp_address); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp_in); } @@ -1001,7 +1001,7 @@ assert(ProfileInterpreter, "must be profiling interpreter"); Address disp_address(mdp_in, reg, Address::times_1, offset_of_disp); addptr(mdp_in, disp_address); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp_in); } @@ -1009,7 +1009,7 @@ int constant) { assert(ProfileInterpreter, "must be profiling interpreter"); addptr(mdp_in, constant); - movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); + movptr(Address(rbp, frame::interpreter_frame_mdp_offset * wordSize), mdp_in); } --- old/src/cpu/x86/vm/interp_masm_x86_64.hpp 2014-07-14 19:49:29.876304189 -0400 +++ new/src/cpu/x86/vm/interp_masm_x86_64.hpp 2014-07-14 19:49:29.608304189 -0400 @@ -58,11 +58,11 @@ // Interpreter-specific registers void save_bcp() { - movptr(Address(rbp, frame::interpreter_frame_bcx_offset * wordSize), r13); + movptr(Address(rbp, frame::interpreter_frame_bcp_offset * wordSize), r13); } void restore_bcp() { - movptr(r13, Address(rbp, frame::interpreter_frame_bcx_offset * wordSize)); + movptr(r13, Address(rbp, frame::interpreter_frame_bcp_offset * wordSize)); } void restore_locals() { --- old/src/cpu/x86/vm/templateInterpreter_x86_32.cpp 2014-07-14 19:49:30.756304188 -0400 +++ new/src/cpu/x86/vm/templateInterpreter_x86_32.cpp 2014-07-14 19:49:30.484304188 -0400 @@ -51,7 +51,7 @@ #ifndef CC_INTERP const int method_offset = frame::interpreter_frame_method_offset * wordSize; -const int bci_offset = frame::interpreter_frame_bcx_offset * wordSize; +const int bcp_offset = frame::interpreter_frame_bcp_offset * wordSize; const int locals_offset = frame::interpreter_frame_locals_offset * wordSize; //------------------------------------------------------------------------------------------------------------------------ --- old/src/cpu/x86/vm/templateInterpreter_x86_64.cpp 2014-07-14 19:49:31.668304187 -0400 +++ new/src/cpu/x86/vm/templateInterpreter_x86_64.cpp 2014-07-14 19:49:31.396304187 -0400 @@ -51,7 +51,7 @@ #ifndef CC_INTERP const int method_offset = frame::interpreter_frame_method_offset * wordSize; -const int bci_offset = frame::interpreter_frame_bcx_offset * wordSize; +const int bcp_offset = frame::interpreter_frame_bcp_offset * wordSize; const int locals_offset = frame::interpreter_frame_locals_offset * wordSize; //----------------------------------------------------------------------------- --- old/src/cpu/zero/vm/frame_zero.cpp 2014-07-14 19:49:32.564304186 -0400 +++ new/src/cpu/zero/vm/frame_zero.cpp 2014-07-14 19:49:32.296304187 -0400 @@ -119,9 +119,6 @@ return false; } -void frame::pd_gc_epilog() { -} - bool frame::is_interpreted_frame_valid(JavaThread *thread) const { ShouldNotCallThis(); return false; --- old/src/cpu/zero/vm/frame_zero.inline.hpp 2014-07-14 19:49:33.440304185 -0400 +++ new/src/cpu/zero/vm/frame_zero.inline.hpp 2014-07-14 19:49:33.172304186 -0400 @@ -101,7 +101,7 @@ return &(get_interpreterState()->_locals); } -inline intptr_t* frame::interpreter_frame_bcx_addr() const { +inline intptr_t* frame::interpreter_frame_bcp_addr() const { return (intptr_t*) &(get_interpreterState()->_bcp); } @@ -113,7 +113,7 @@ return &(get_interpreterState()->_method); } -inline intptr_t* frame::interpreter_frame_mdx_addr() const { +inline intptr_t* frame::interpreter_frame_mdp_addr() const { return (intptr_t*) &(get_interpreterState()->_mdx); } --- old/src/os/bsd/dtrace/generateJvmOffsets.cpp 2014-07-14 19:49:34.308304185 -0400 +++ new/src/os/bsd/dtrace/generateJvmOffsets.cpp 2014-07-14 19:49:34.056304185 -0400 @@ -202,11 +202,11 @@ GEN_VALUE(OFFSET_interpreter_frame_method, 2 * pointer_size); /* L2 in saved window */ GEN_VALUE(OFFSET_interpreter_frame_sender_sp, 13 * pointer_size); /* I5 in saved window */ // Fake value for consistency. It is not going to be used. - GEN_VALUE(OFFSET_interpreter_frame_bcx_offset, 0xFFFF); + GEN_VALUE(OFFSET_interpreter_frame_bcp_offset, 0xFFFF); #elif defined(i386) || defined(__i386) || defined(__amd64) GEN_VALUE(OFFSET_interpreter_frame_sender_sp, -1 * pointer_size); GEN_VALUE(OFFSET_interpreter_frame_method, -3 * pointer_size); - GEN_VALUE(OFFSET_interpreter_frame_bcx_offset, -7 * pointer_size); + GEN_VALUE(OFFSET_interpreter_frame_bcp_offset, -7 * pointer_size); #endif GEN_OFFS(Klass, _name); --- old/src/os/bsd/dtrace/libjvm_db.c 2014-07-14 19:49:35.172304184 -0400 +++ new/src/os/bsd/dtrace/libjvm_db.c 2014-07-14 19:49:34.912304184 -0400 @@ -164,7 +164,7 @@ int32_t SIZE_CodeCache_log2_segment; uint64_t methodPtr; - uint64_t bcx; + uint64_t bcp; Nmethod_t *N; /*Inlined methods support */ Frame_t prev_fr; @@ -1068,19 +1068,9 @@ return err; } -int is_bci(intptr_t bcx) { - switch (DATA_MODEL) { - case PR_MODEL_LP64: - return ((uintptr_t) bcx) <= ((uintptr_t) MAX_METHOD_CODE_SIZE) ; - case PR_MODEL_ILP32: - default: - return 0 <= bcx && bcx <= MAX_METHOD_CODE_SIZE; - } -} - static int name_for_imethod(jvm_agent_t* J, - uint64_t bcx, + uint64_t bcp, uint64_t method, char *result, size_t size, @@ -1095,7 +1085,7 @@ err = read_pointer(J, method + OFFSET_Method_constMethod, &constMethod); CHECK_FAIL(err); - bci = is_bci(bcx) ? bcx : bcx - (constMethod + (uint64_t) SIZE_ConstMethod); + bci = bcp - (constMethod + (uint64_t) SIZE_ConstMethod); if (debug) fprintf(stderr, "\t name_for_imethod: BEGIN: method: %#llx\n", method); @@ -1169,7 +1159,7 @@ if (err == PS_OK && strncmp(name, "Interpreter", 11) == 0) { *is_interpreted = 1; if (is_method(J, J->methodPtr)) { - return name_for_imethod(J, J->bcx, J->methodPtr, result, size, jframe); + return name_for_imethod(J, J->bcp, J->methodPtr, result, size, jframe); } } @@ -1326,7 +1316,7 @@ /* arguments given to read_pointer need to be worst case sized */ uint64_t methodPtr = 0; uint64_t sender_sp; - uint64_t bcx = 0; + uint64_t bcp = 0; int is_interpreted = 0; int result = PS_OK; int err = PS_OK; @@ -1357,7 +1347,7 @@ * regs[R_PC] contains a CALL instruction pc offset. */ pc += 8; - bcx = (uintptr_t) regs[R_L1]; + bcp = (uintptr_t) regs[R_L1]; methodPtr = (uintptr_t) regs[R_L2]; sender_sp = regs[R_I5]; if (debug > 2) { @@ -1385,13 +1375,13 @@ if (read_pointer(J, fp + OFFSET_interpreter_frame_sender_sp, &sender_sp) != PS_OK) { sender_sp = 0; } - if (read_pointer(J, fp + OFFSET_interpreter_frame_bcx_offset, &bcx) != PS_OK) { - bcx = 0; + if (read_pointer(J, fp + OFFSET_interpreter_frame_bcp_offset, &bcp) != PS_OK) { + bcp = 0; } #endif /* i386 */ J->methodPtr = methodPtr; - J->bcx = bcx; + J->bcp = bcp; /* On x86 with C2 JVM: native frame may have wrong regs[R_FP] * For example: JVM_SuspendThread frame poins to the top interpreted frame. @@ -1402,7 +1392,7 @@ */ #ifndef X86_COMPILER2 if (is_method(J, J->methodPtr)) { - result = name_for_imethod(J, bcx, J->methodPtr, name, size, jframe); + result = name_for_imethod(J, bcp, J->methodPtr, name, size, jframe); /* If the methodPtr is a method then this is highly likely to be an interpreter frame */ if (result >= 0) { @@ -1416,7 +1406,7 @@ } #ifdef X86_COMPILER2 else if (is_method(J, J->methodPtr)) { - result = name_for_imethod(J, bcx, J->methodPtr, name, size, jframe); + result = name_for_imethod(J, bcp, J->methodPtr, name, size, jframe); /* If the methodPtr is a method then this is highly likely to be an interpreter frame */ if (result >= 0) { --- old/src/os/solaris/dtrace/generateJvmOffsets.cpp 2014-07-14 19:49:36.048304183 -0400 +++ new/src/os/solaris/dtrace/generateJvmOffsets.cpp 2014-07-14 19:49:35.796304183 -0400 @@ -197,11 +197,11 @@ GEN_VALUE(OFFSET_interpreter_frame_method, 2 * pointer_size); /* L2 in saved window */ GEN_VALUE(OFFSET_interpreter_frame_sender_sp, 13 * pointer_size); /* I5 in saved window */ // Fake value for consistency. It is not going to be used. - GEN_VALUE(OFFSET_interpreter_frame_bcx_offset, 0xFFFF); + GEN_VALUE(OFFSET_interpreter_frame_bcp_offset, 0xFFFF); #elif defined(i386) || defined(__i386) || defined(__amd64) GEN_VALUE(OFFSET_interpreter_frame_sender_sp, -1 * pointer_size); GEN_VALUE(OFFSET_interpreter_frame_method, -3 * pointer_size); - GEN_VALUE(OFFSET_interpreter_frame_bcx_offset, -7 * pointer_size); + GEN_VALUE(OFFSET_interpreter_frame_bcp_offset, -7 * pointer_size); #endif GEN_OFFS(Klass, _name); --- old/src/os/solaris/dtrace/libjvm_db.c 2014-07-14 19:49:36.936304182 -0400 +++ new/src/os/solaris/dtrace/libjvm_db.c 2014-07-14 19:49:36.672304182 -0400 @@ -164,7 +164,7 @@ int32_t SIZE_CodeCache_log2_segment; uint64_t methodPtr; - uint64_t bcx; + uint64_t bcp; Nmethod_t *N; /*Inlined methods support */ Frame_t prev_fr; @@ -1068,19 +1068,9 @@ return err; } -int is_bci(intptr_t bcx) { - switch (DATA_MODEL) { - case PR_MODEL_LP64: - return ((uintptr_t) bcx) <= ((uintptr_t) MAX_METHOD_CODE_SIZE) ; - case PR_MODEL_ILP32: - default: - return 0 <= bcx && bcx <= MAX_METHOD_CODE_SIZE; - } -} - static int name_for_imethod(jvm_agent_t* J, - uint64_t bcx, + uint64_t bcp, uint64_t method, char *result, size_t size, @@ -1095,7 +1085,7 @@ err = read_pointer(J, method + OFFSET_Method_constMethod, &constMethod); CHECK_FAIL(err); - bci = is_bci(bcx) ? bcx : bcx - (constMethod + (uint64_t) SIZE_ConstMethod); + bci = bcp - (constMethod + (uint64_t) SIZE_ConstMethod); if (debug) fprintf(stderr, "\t name_for_imethod: BEGIN: method: %#llx\n", method); @@ -1169,7 +1159,7 @@ if (err == PS_OK && strncmp(name, "Interpreter", 11) == 0) { *is_interpreted = 1; if (is_method(J, J->methodPtr)) { - return name_for_imethod(J, J->bcx, J->methodPtr, result, size, jframe); + return name_for_imethod(J, J->bcp, J->methodPtr, result, size, jframe); } } @@ -1326,7 +1316,7 @@ /* arguments given to read_pointer need to be worst case sized */ uint64_t methodPtr = 0; uint64_t sender_sp; - uint64_t bcx = 0; + uint64_t bcp = 0; int is_interpreted = 0; int result = PS_OK; int err = PS_OK; @@ -1357,7 +1347,7 @@ * regs[R_PC] contains a CALL instruction pc offset. */ pc += 8; - bcx = (uintptr_t) regs[R_L1]; + bcp = (uintptr_t) regs[R_L1]; methodPtr = (uintptr_t) regs[R_L2]; sender_sp = regs[R_I5]; if (debug > 2) { @@ -1385,13 +1375,13 @@ if (read_pointer(J, fp + OFFSET_interpreter_frame_sender_sp, &sender_sp) != PS_OK) { sender_sp = 0; } - if (read_pointer(J, fp + OFFSET_interpreter_frame_bcx_offset, &bcx) != PS_OK) { - bcx = 0; + if (read_pointer(J, fp + OFFSET_interpreter_frame_bcp_offset, &bcp) != PS_OK) { + bcp = 0; } #endif /* i386 */ J->methodPtr = methodPtr; - J->bcx = bcx; + J->bcp = bcp; /* On x86 with C2 JVM: native frame may have wrong regs[R_FP] * For example: JVM_SuspendThread frame poins to the top interpreted frame. @@ -1402,7 +1392,7 @@ */ #ifndef X86_COMPILER2 if (is_method(J, J->methodPtr)) { - result = name_for_imethod(J, bcx, J->methodPtr, name, size, jframe); + result = name_for_imethod(J, bcp, J->methodPtr, name, size, jframe); /* If the methodPtr is a method then this is highly likely to be an interpreter frame */ if (result >= 0) { @@ -1416,7 +1406,7 @@ } #ifdef X86_COMPILER2 else if (is_method(J, J->methodPtr)) { - result = name_for_imethod(J, bcx, J->methodPtr, name, size, jframe); + result = name_for_imethod(J, bcp, J->methodPtr, name, size, jframe); /* If the methodPtr is a method then this is highly likely to be an interpreter frame */ if (result >= 0) { --- old/src/share/vm/classfile/javaClasses.cpp 2014-07-14 19:49:37.860304181 -0400 +++ new/src/share/vm/classfile/javaClasses.cpp 2014-07-14 19:49:37.588304182 -0400 @@ -1639,9 +1639,9 @@ if (fr.is_first_frame()) break; address pc = fr.pc(); if (fr.is_interpreted_frame()) { - intptr_t bcx = fr.interpreter_frame_bcx(); + address bcp = fr.interpreter_frame_bcp(); method = fr.interpreter_frame_method(); - bci = fr.is_bci(bcx) ? bcx : method->bci_from((address)bcx); + bci = method->bci_from(bcp); fr = fr.sender(&map); } else { CodeBlob* cb = fr.cb(); --- old/src/share/vm/classfile/verifier.cpp 2014-07-14 19:49:38.816304180 -0400 +++ new/src/share/vm/classfile/verifier.cpp 2014-07-14 19:49:38.548304181 -0400 @@ -439,7 +439,7 @@ if (_bci != -1 && method != NULL) { streamIndentor si(ss); const char* bytecode_name = ""; - if (method->validate_bci_from_bcx(_bci) != -1) { + if (method->validate_bci(_bci) != -1) { Bytecodes::Code code = Bytecodes::code_or_bp_at(method->bcp_from(_bci)); if (Bytecodes::is_defined(code)) { bytecode_name = Bytecodes::name(code); --- old/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp 2014-07-14 19:49:39.756304179 -0400 +++ new/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp 2014-07-14 19:49:39.480304180 -0400 @@ -76,7 +76,6 @@ // When collecting the permanent generation Method*s may be moving, // so we either have to flush all bcp data or convert it into bci. CodeCache::gc_prologue(); - Threads::gc_prologue(); bool marked_for_unloading = false; @@ -106,7 +105,6 @@ // Universe::set_heap_capacity_at_last_gc(Universe::heap()->capacity()); // Universe::set_heap_used_at_last_gc(Universe::heap()->used()); - Threads::gc_epilogue(); CodeCache::gc_epilogue(); JvmtiExport::gc_epilogue(); --- old/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp 2014-07-14 19:49:40.628304179 -0400 +++ new/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp 2014-07-14 19:49:40.368304179 -0400 @@ -180,7 +180,6 @@ size_policy->major_collection_begin(); CodeCache::gc_prologue(); - Threads::gc_prologue(); BiasedLocking::preserve_marks(); // Capture heap size before collection for printing. @@ -251,7 +250,6 @@ MetaspaceAux::verify_metrics(); BiasedLocking::restore_marks(); - Threads::gc_epilogue(); CodeCache::gc_epilogue(); JvmtiExport::gc_epilogue(); --- old/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp 2014-07-14 19:49:41.520304178 -0400 +++ new/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp 2014-07-14 19:49:41.248304178 -0400 @@ -1066,7 +1066,6 @@ ClassLoaderDataGraph::purge(); MetaspaceAux::verify_metrics(); - Threads::gc_epilogue(); CodeCache::gc_epilogue(); JvmtiExport::gc_epilogue(); @@ -2068,7 +2067,6 @@ size_policy->major_collection_begin(); CodeCache::gc_prologue(); - Threads::gc_prologue(); COMPILER2_PRESENT(DerivedPointerTable::clear()); --- old/src/share/vm/memory/genMarkSweep.cpp 2014-07-14 19:49:42.432304177 -0400 +++ new/src/share/vm/memory/genMarkSweep.cpp 2014-07-14 19:49:42.180304177 -0400 @@ -76,7 +76,6 @@ // When collecting the permanent generation Method*s may be moving, // so we either have to flush all bcp data or convert it into bci. CodeCache::gc_prologue(); - Threads::gc_prologue(); // Increment the invocation count _total_invocations++; @@ -132,7 +131,6 @@ rs->invalidate_or_clear(old_gen); } - Threads::gc_epilogue(); CodeCache::gc_epilogue(); JvmtiExport::gc_epilogue(); --- old/src/share/vm/oops/method.cpp 2014-07-14 19:49:43.428304176 -0400 +++ new/src/share/vm/oops/method.cpp 2014-07-14 19:49:43.168304176 -0400 @@ -240,6 +240,9 @@ int Method::bci_from(address bcp) const { + if (is_native() && bcp == 0) { + return 0; + } #ifdef ASSERT { ResourceMark rm; assert(is_native() && bcp == code_base() || contains(bcp) || is_error_reported(), @@ -250,24 +253,23 @@ } -// Return (int)bcx if it appears to be a valid BCI. -// Return bci_from((address)bcx) if it appears to be a valid BCP. +int Method::validate_bci(int bci) const { + return (bci == 0 || bci < code_size()) ? bci : -1; +} + +// Return bci if it appears to be a valid bcp // Return -1 otherwise. // Used by profiling code, when invalid data is a possibility. // The caller is responsible for validating the Method* itself. -int Method::validate_bci_from_bcx(intptr_t bcx) const { +int Method::validate_bci_from_bcp(address bcp) const { // keep bci as -1 if not a valid bci int bci = -1; - if (bcx == 0 || (address)bcx == code_base()) { + if (bcp == 0 || bcp == code_base()) { // code_size() may return 0 and we allow 0 here // the method may be native bci = 0; - } else if (frame::is_bci(bcx)) { - if (bcx < code_size()) { - bci = (int)bcx; - } - } else if (contains((address)bcx)) { - bci = (address)bcx - code_base(); + } else if (contains(bcp)) { + bci = bcp - code_base(); } // Assert that if we have dodged any asserts, bci is negative. assert(bci == -1 || bci == bci_from(bcp_from(bci)), "sane bci if >=0"); --- old/src/share/vm/oops/method.hpp 2014-07-14 19:49:44.316304175 -0400 +++ new/src/share/vm/oops/method.hpp 2014-07-14 19:49:44.064304175 -0400 @@ -649,7 +649,8 @@ // Returns the byte code index from the byte code pointer int bci_from(address bcp) const; address bcp_from(int bci) const; - int validate_bci_from_bcx(intptr_t bcx) const; + int validate_bci_from_bcp(address bcp) const; + int validate_bci(int bci) const; // Returns the line number for a bci if debugging information for the method is prowided, // -1 is returned otherwise. --- old/src/share/vm/oops/methodData.hpp 2014-07-14 19:49:45.228304174 -0400 +++ new/src/share/vm/oops/methodData.hpp 2014-07-14 19:49:44.956304175 -0400 @@ -2338,10 +2338,6 @@ return dp - ((address)_data); } - address di_to_dp(int di) { - return (address)data_layout_at(di); - } - // bci to di/dp conversion. address bci_to_dp(int bci); int bci_to_di(int bci) { --- old/src/share/vm/prims/forte.cpp 2014-07-14 19:49:46.164304173 -0400 +++ new/src/share/vm/prims/forte.cpp 2014-07-14 19:49:45.892304174 -0400 @@ -234,9 +234,8 @@ *method_p = method; if (!method->is_valid_method()) return false; - intptr_t bcx = fr->interpreter_frame_bcx(); - - int bci = method->validate_bci_from_bcx(bcx); + address bcp = fr->interpreter_frame_bcp(); + int bci = method->validate_bci_from_bcp(bcp); // note: bci is set to -1 if not a valid bci *bci_p = bci; --- old/src/share/vm/runtime/frame.cpp 2014-07-14 19:49:47.064304173 -0400 +++ new/src/share/vm/runtime/frame.cpp 2014-07-14 19:49:46.780304173 -0400 @@ -412,91 +412,32 @@ *interpreter_frame_method_addr() = method; } -void frame::interpreter_frame_set_bcx(intptr_t bcx) { - assert(is_interpreted_frame(), "Not an interpreted frame"); - if (ProfileInterpreter) { - bool formerly_bci = is_bci(interpreter_frame_bcx()); - bool is_now_bci = is_bci(bcx); - *interpreter_frame_bcx_addr() = bcx; - - intptr_t mdx = interpreter_frame_mdx(); - - if (mdx != 0) { - if (formerly_bci) { - if (!is_now_bci) { - // The bcx was just converted from bci to bcp. - // Convert the mdx in parallel. - MethodData* mdo = interpreter_frame_method()->method_data(); - assert(mdo != NULL, ""); - int mdi = mdx - 1; // We distinguish valid mdi from zero by adding one. - address mdp = mdo->di_to_dp(mdi); - interpreter_frame_set_mdx((intptr_t)mdp); - } - } else { - if (is_now_bci) { - // The bcx was just converted from bcp to bci. - // Convert the mdx in parallel. - MethodData* mdo = interpreter_frame_method()->method_data(); - assert(mdo != NULL, ""); - int mdi = mdo->dp_to_di((address)mdx); - interpreter_frame_set_mdx((intptr_t)mdi + 1); // distinguish valid from 0. - } - } - } - } else { - *interpreter_frame_bcx_addr() = bcx; - } -} - jint frame::interpreter_frame_bci() const { assert(is_interpreted_frame(), "interpreted frame expected"); - intptr_t bcx = interpreter_frame_bcx(); - return is_bci(bcx) ? bcx : interpreter_frame_method()->bci_from((address)bcx); -} - -void frame::interpreter_frame_set_bci(jint bci) { - assert(is_interpreted_frame(), "interpreted frame expected"); - assert(!is_bci(interpreter_frame_bcx()), "should not set bci during GC"); - interpreter_frame_set_bcx((intptr_t)interpreter_frame_method()->bcp_from(bci)); + address bcp = interpreter_frame_bcp(); + return interpreter_frame_method()->bci_from(bcp); } address frame::interpreter_frame_bcp() const { assert(is_interpreted_frame(), "interpreted frame expected"); - intptr_t bcx = interpreter_frame_bcx(); - return is_bci(bcx) ? interpreter_frame_method()->bcp_from(bcx) : (address)bcx; + return (address)*interpreter_frame_bcp_addr(); } void frame::interpreter_frame_set_bcp(address bcp) { assert(is_interpreted_frame(), "interpreted frame expected"); - assert(!is_bci(interpreter_frame_bcx()), "should not set bcp during GC"); - interpreter_frame_set_bcx((intptr_t)bcp); -} - -void frame::interpreter_frame_set_mdx(intptr_t mdx) { - assert(is_interpreted_frame(), "Not an interpreted frame"); - assert(ProfileInterpreter, "must be profiling interpreter"); - *interpreter_frame_mdx_addr() = mdx; + *interpreter_frame_bcp_addr() = (intptr_t)bcp; } address frame::interpreter_frame_mdp() const { assert(ProfileInterpreter, "must be profiling interpreter"); assert(is_interpreted_frame(), "interpreted frame expected"); - intptr_t bcx = interpreter_frame_bcx(); - intptr_t mdx = interpreter_frame_mdx(); - - assert(!is_bci(bcx), "should not access mdp during GC"); - return (address)mdx; + return (address)*interpreter_frame_mdp_addr(); } void frame::interpreter_frame_set_mdp(address mdp) { assert(is_interpreted_frame(), "interpreted frame expected"); - if (mdp == NULL) { - // Always allow the mdp to be cleared. - interpreter_frame_set_mdx((intptr_t)mdp); - } - intptr_t bcx = interpreter_frame_bcx(); - assert(!is_bci(bcx), "should not set mdp during GC"); - interpreter_frame_set_mdx((intptr_t)mdp); + assert(ProfileInterpreter, "must be profiling interpreter"); + *interpreter_frame_mdp_addr() = (intptr_t)mdp; } BasicObjectLock* frame::next_monitor_in_interpreter_frame(BasicObjectLock* current) const { @@ -1182,24 +1123,6 @@ } } -void frame::gc_prologue() { - if (is_interpreted_frame()) { - // set bcx to bci to become Method* position independent during GC - interpreter_frame_set_bcx(interpreter_frame_bci()); - } -} - - -void frame::gc_epilogue() { - if (is_interpreted_frame()) { - // set bcx back to bcp for interpreter - interpreter_frame_set_bcx((intptr_t)interpreter_frame_bcp()); - } - // call processor specific epilog function - pd_gc_epilog(); -} - - # ifdef ENABLE_ZAP_DEAD_LOCALS void frame::CheckValueClosure::do_oop(oop* p) { --- old/src/share/vm/runtime/frame.hpp 2014-07-14 19:49:47.960304172 -0400 +++ new/src/share/vm/runtime/frame.hpp 2014-07-14 19:49:47.688304172 -0400 @@ -241,8 +241,8 @@ private: intptr_t** interpreter_frame_locals_addr() const; - intptr_t* interpreter_frame_bcx_addr() const; - intptr_t* interpreter_frame_mdx_addr() const; + intptr_t* interpreter_frame_bcp_addr() const; + intptr_t* interpreter_frame_mdp_addr() const; public: // Locals @@ -252,23 +252,13 @@ void interpreter_frame_set_locals(intptr_t* locs); - // byte code index/pointer (use these functions for unchecked frame access only!) - intptr_t interpreter_frame_bcx() const { return *interpreter_frame_bcx_addr(); } - void interpreter_frame_set_bcx(intptr_t bcx); - // byte code index jint interpreter_frame_bci() const; - void interpreter_frame_set_bci(jint bci); // byte code pointer address interpreter_frame_bcp() const; void interpreter_frame_set_bcp(address bcp); - // Unchecked access to the method data index/pointer. - // Only use this if you know what you are doing. - intptr_t interpreter_frame_mdx() const { return *interpreter_frame_mdx_addr(); } - void interpreter_frame_set_mdx(intptr_t mdx); - // method data pointer address interpreter_frame_mdp() const; void interpreter_frame_set_mdp(address dp); @@ -437,10 +427,6 @@ // RedefineClasses support for finding live interpreted methods on the stack void metadata_do(void f(Metadata*)); - void gc_prologue(); - void gc_epilogue(); - void pd_gc_epilog(); - # ifdef ENABLE_ZAP_DEAD_LOCALS private: class CheckValueClosure: public OopClosure { @@ -477,7 +463,6 @@ // Verification void verify(const RegisterMap* map); static bool verify_return_pc(address x); - static bool is_bci(intptr_t bcx); // Usage: // assert(frame::verify_return_pc(return_address), "must be a return pc"); --- old/src/share/vm/runtime/frame.inline.hpp 2014-07-14 19:49:48.840304171 -0400 +++ new/src/share/vm/runtime/frame.inline.hpp 2014-07-14 19:49:48.576304171 -0400 @@ -55,26 +55,6 @@ #endif #endif -// This file holds platform-independent bodies of inline functions for frames. - -// Note: The bcx usually contains the bcp; however during GC it contains the bci -// (changed by gc_prologue() and gc_epilogue()) to be Method* position -// independent. These accessors make sure the correct value is returned -// by testing the range of the bcx value. bcp's are guaranteed to be above -// max_method_code_size, since methods are always allocated in OldSpace and -// Eden is allocated before OldSpace. -// -// The bcp is accessed sometimes during GC for ArgumentDescriptors; than -// the correct translation has to be performed (was bug). - -inline bool frame::is_bci(intptr_t bcx) { -#ifdef _LP64 - return ((uintptr_t) bcx) <= ((uintptr_t) max_method_code_size) ; -#else - return 0 <= bcx && bcx <= max_method_code_size; -#endif -} - inline bool frame::is_entry_frame() const { return StubRoutines::returns_to_call_stub(pc()); } --- old/src/share/vm/runtime/thread.cpp 2014-07-14 19:49:49.716304170 -0400 +++ new/src/share/vm/runtime/thread.cpp 2014-07-14 19:49:49.444304170 -0400 @@ -2647,20 +2647,6 @@ } -// GC support -static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); } - -void JavaThread::gc_epilogue() { - frames_do(frame_gc_epilogue); -} - - -static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); } - -void JavaThread::gc_prologue() { - frames_do(frame_gc_prologue); -} - // If the caller is a NamedThread, then remember, in the current scope, // the given JavaThread in its _processed_thread field. class RememberProcessedThread: public StackObj { @@ -4149,18 +4135,6 @@ } } -void Threads::gc_epilogue() { - ALL_JAVA_THREADS(p) { - p->gc_epilogue(); - } -} - -void Threads::gc_prologue() { - ALL_JAVA_THREADS(p) { - p->gc_prologue(); - } -} - void Threads::deoptimized_wrt_marked_nmethods() { ALL_JAVA_THREADS(p) { p->deoptimized_wrt_marked_nmethods(); --- old/src/share/vm/runtime/thread.hpp 2014-07-14 19:49:50.664304169 -0400 +++ new/src/share/vm/runtime/thread.hpp 2014-07-14 19:49:50.388304169 -0400 @@ -1416,10 +1416,6 @@ // RedefineClasses Support void metadata_do(void f(Metadata*)); - // Memory management operations - void gc_epilogue(); - void gc_prologue(); - // Misc. operations char* name() const { return (char*)get_thread_name(); } void print_on(outputStream* st) const; @@ -1899,8 +1895,6 @@ // RedefineClasses support static void metadata_do(void f(Metadata*)); - static void gc_epilogue(); - static void gc_prologue(); #ifdef ASSERT static bool is_vm_complete() { return _vm_complete; } #endif --- old/src/share/vm/runtime/vframe.hpp 2014-07-14 19:49:51.564304168 -0400 +++ new/src/share/vm/runtime/vframe.hpp 2014-07-14 19:49:51.312304168 -0400 @@ -511,8 +511,8 @@ inline void vframeStreamCommon::fill_from_interpreter_frame() { Method* method = _frame.interpreter_frame_method(); - intptr_t bcx = _frame.interpreter_frame_bcx(); - int bci = method->validate_bci_from_bcx(bcx); + address bcp = _frame.interpreter_frame_bcp(); + int bci = method->validate_bci_from_bcp(bcp); // 6379830 AsyncGetCallTrace sometimes feeds us wild frames. if (bci < 0) { found_bad_method_frame(); --- old/src/share/vm/runtime/vframeArray.cpp 2014-07-14 19:49:52.472304167 -0400 +++ new/src/share/vm/runtime/vframeArray.cpp 2014-07-14 19:49:52.172304168 -0400 @@ -296,9 +296,9 @@ src->lock()->move_to(src->obj(), top->lock()); } if (ProfileInterpreter) { - iframe()->interpreter_frame_set_mdx(0); // clear out the mdp. + iframe()->interpreter_frame_set_mdp(0); // clear out the mdp. } - iframe()->interpreter_frame_set_bcx((intptr_t)bcp); // cannot use bcp because frame is not initialized yet + iframe()->interpreter_frame_set_bcp(bcp); if (ProfileInterpreter) { MethodData* mdo = method()->method_data(); if (mdo != NULL) {