--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/cpu/x86/gc/shared/barrierSetNMethod_x86.cpp Tue Oct 16 13:18:22 2018 +0200
@@ -0,0 +1,155 @@
+/*
+ * 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());
+}