/*
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "precompiled.hpp"
#include "code/codeCache.hpp"
#include "code/nativeInst.hpp"
#include "gc/shared/barrierSetNMethod.hpp"
#include "logging/log.hpp"
#include "memory/resourceArea.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/thread.hpp"
#include "utilities/align.hpp"
#include "utilities/debug.hpp"
class NativeNMethodCmpBarrier: public NativeInstruction {
public:
enum Intel_specific_constants {
instruction_code = 0x81,
instruction_size = 8,
imm_offset = 4,
instruction_rex_prefix = Assembler::REX | Assembler::REX_B,
instruction_modrm = 0x7f // [r15 + offset]
};
address instruction_address() const { return addr_at(0); }
address immediate_address() const { return addr_at(imm_offset); }
jint get_immedate() const { return int_at(imm_offset); }
void set_immediate(jint imm) { set_int_at(imm_offset, imm); }
void verify() const;
};
void NativeNMethodCmpBarrier::verify() const {
if (((uintptr_t) instruction_address()) & 0x7) {
fatal("Not properly aligned");
}
int prefix = ubyte_at(0);
if (prefix != instruction_rex_prefix) {
tty->print_cr("Addr: " INTPTR_FORMAT " Prefix: 0x%x", p2i(instruction_address()),
prefix);
fatal("not a cmp barrier");
}
int inst = ubyte_at(1);
if (inst != instruction_code) {
tty->print_cr("Addr: " INTPTR_FORMAT " Code: 0x%x", p2i(instruction_address()),
inst);
fatal("not a cmp barrier");
}
int modrm = ubyte_at(2);
if (modrm != instruction_modrm) {
tty->print_cr("Addr: " INTPTR_FORMAT " mod/rm: 0x%x", p2i(instruction_address()),
modrm);
fatal("not a cmp barrier");
}
}
void BarrierSetNMethod::deoptimize(nmethod* nm, address* return_address_ptr) {
/*
* [ callers frame ]
* [ callers return address ] <- callers rsp
* [ callers rbp ] <- callers rbp
* [ callers frame slots ]
* [ return_address ] <- return_address_ptr
* [ cookie ] <- used to write the new rsp (callers rsp)
* [ stub rbp ]
* [ stub stuff ]
*/
address* stub_rbp = return_address_ptr - 2;
address* callers_rsp = return_address_ptr + nm->frame_size(); /* points to callers return_address now */
address* callers_rbp = callers_rsp - 1; // 1 to move to the callers return address, 1 more to move to the rbp
address* cookie = return_address_ptr - 1;
LogTarget(Trace, nmethod, barrier) out;
if (out.is_enabled()) {
Thread* thread = Thread::current();
assert(thread->is_Java_thread(), "must be JavaThread");
JavaThread* jth = (JavaThread*) thread;
ResourceMark mark;
log_trace(nmethod, barrier)("deoptimize(nmethod: %p, return_addr: %p, osr: %d, thread: %p(%s), making rsp: %p) -> %p",
nm, (address *) return_address_ptr, nm->is_osr_method(), jth,
jth->get_thread_name(), callers_rsp, nm->verified_entry_point());
}
assert(nm->frame_size() >= 3, "invariant");
assert(*cookie == (address) -1, "invariant");
// Preserve caller rbp.
*stub_rbp = *callers_rbp;
// At the cookie address put the callers rsp.
*cookie = (address) callers_rsp; // should point to the return address
// In the slot that used to be the callers rbp we put the address that our stub needs to jump to at the end.
// Overwriting the caller rbp should be okay since our stub rbp has the same value.
address* jmp_addr_ptr = callers_rbp;
*jmp_addr_ptr = SharedRuntime::get_handle_wrong_method_stub();
}
// This is the offset of the entry barrier from where the frame is completed.
// If any code changes between the end of the verified entry where the entry
// barrier resides, and the completion of the frame, then
// NativeNMethodCmpBarrier::verify() will immediately complain when it does
// not find the expected native instruction at this offset, which needs updating.
// Note that this offset is invariant of PreserveFramePointer.
static const int entry_barrier_offset = -19;
static NativeNMethodCmpBarrier* native_nmethod_barrier(nmethod* nm) {
address barrier_address = nm->code_begin() + nm->frame_complete_offset() + entry_barrier_offset;
NativeNMethodCmpBarrier* barrier = reinterpret_cast<NativeNMethodCmpBarrier*>(barrier_address);
debug_only(barrier->verify());
return barrier;
}
void BarrierSetNMethod::disarm(nmethod* nm) {
if (!supports_entry_barrier(nm)) {
return;
}
NativeNMethodCmpBarrier* cmp = native_nmethod_barrier(nm);
cmp->set_immediate(disarmed_value());
}
bool BarrierSetNMethod::is_armed(nmethod* nm) {
if (!supports_entry_barrier(nm)) {
return false;
}
NativeNMethodCmpBarrier* cmp = native_nmethod_barrier(nm);
return (disarmed_value() != cmp->get_immedate());
}