1 /*
  2  * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #include "precompiled.hpp"
 26 #include "code/compiledIC.hpp"
 27 #include "code/nmethod.hpp"
 28 #include "oops/method.inline.hpp"
 29 #include "runtime/continuation.hpp"
 30 #include "runtime/continuationEntry.inline.hpp"
 31 #include "runtime/continuationHelper.inline.hpp"
 32 #include "runtime/frame.inline.hpp"
 33 #include "runtime/javaThread.hpp"
 34 #include "runtime/stackFrameStream.inline.hpp"
 35 #include "runtime/stackWatermarkSet.inline.hpp"
 36 #include "runtime/stubRoutines.hpp"
 37 
 38 int ContinuationEntry::_return_pc_offset = 0;
 39 int ContinuationEntry::_thaw_call_pc_offset = 0;
 40 address ContinuationEntry::_return_pc = nullptr;
 41 address ContinuationEntry::_thaw_call_pc = nullptr;
 42 CompiledMethod* ContinuationEntry::_enter_special = nullptr;
 43 int ContinuationEntry::_interpreted_entry_offset = 0;
 44 
 45 void ContinuationEntry::set_enter_code(CompiledMethod* cm, int interpreted_entry_offset) {
 46   assert(_return_pc_offset != 0, "");
 47   _return_pc = cm->code_begin() + _return_pc_offset;
 48   _thaw_call_pc = cm->code_begin() + _thaw_call_pc_offset;
 49 
 50   _enter_special = cm;
 51   _interpreted_entry_offset = interpreted_entry_offset;
 52 
 53   assert(_enter_special->code_contains(compiled_entry()),    "entry not in enterSpecial");
 54   assert(_enter_special->code_contains(interpreted_entry()), "entry not in enterSpecial");
 55   assert(interpreted_entry() < compiled_entry(), "unexpected code layout");
 56 }
 57 
 58 address ContinuationEntry::compiled_entry() {
 59   return _enter_special->verified_entry_point();
 60 }
 61 
 62 address ContinuationEntry::interpreted_entry() {
 63   return _enter_special->code_begin() + _interpreted_entry_offset;
 64 }
 65 
 66 bool ContinuationEntry::is_interpreted_call(address call_address) {
 67   assert(_enter_special->code_contains(call_address), "call not in enterSpecial");
 68   assert(call_address >= interpreted_entry(), "unexpected location");
 69   return call_address < compiled_entry();
 70 }
 71 
 72 ContinuationEntry* ContinuationEntry::from_frame(const frame& f) {
 73   assert(Continuation::is_continuation_enterSpecial(f), "");
 74   return (ContinuationEntry*)f.unextended_sp();
 75 }
 76 
 77 NOINLINE static void flush_stack_processing(JavaThread* thread, intptr_t* sp) {
 78   log_develop_trace(continuations)("flush_stack_processing");
 79   for (StackFrameStream fst(thread, true, true); fst.current()->sp() <= sp; fst.next()) {
 80     ;
 81   }
 82 }
 83 
 84 inline void maybe_flush_stack_processing(JavaThread* thread, intptr_t* sp) {
 85   StackWatermark* sw;
 86   uintptr_t watermark;
 87   if ((sw = StackWatermarkSet::get(thread, StackWatermarkKind::gc)) != nullptr
 88         && (watermark = sw->watermark()) != 0
 89         && watermark <= (uintptr_t)sp) {
 90     flush_stack_processing(thread, sp);
 91   }
 92 }
 93 
 94 void ContinuationEntry::flush_stack_processing(JavaThread* thread) const {
 95   maybe_flush_stack_processing(thread, (intptr_t*)((uintptr_t)entry_sp() + ContinuationEntry::size()));
 96 }
 97 
 98 #ifndef PRODUCT
 99 void ContinuationEntry::describe(FrameValues& values, int frame_no) const {
100   address usp = (address)this;
101   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::parent_offset())),    "parent");
102   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::cont_offset())),      "continuation");
103   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::flags_offset())),     "flags");
104   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::chunk_offset())),     "chunk");
105   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::argsize_offset())),   "argsize");
106   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::pin_count_offset())), "pin_count");
107   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::parent_cont_fastpath_offset())),      "parent fastpath");
108   values.describe(frame_no, (intptr_t*)(usp + in_bytes(ContinuationEntry::parent_held_monitor_count_offset())), "parent held monitor count");
109 }
110 #endif
111 
112 #ifdef ASSERT
113 bool ContinuationEntry::assert_entry_frame_laid_out(JavaThread* thread) {
114   assert(thread->has_last_Java_frame(), "Wrong place to use this assertion");
115 
116   ContinuationEntry* entry = thread->last_continuation();
117   assert(entry != nullptr, "");
118 
119   intptr_t* unextended_sp = entry->entry_sp();
120   intptr_t* sp;
121   if (entry->argsize() > 0) {
122     sp = entry->bottom_sender_sp();
123   } else {
124     sp = unextended_sp;
125     bool interpreted_bottom = false;
126     RegisterMap map(thread,
127                     RegisterMap::UpdateMap::skip,
128                     RegisterMap::ProcessFrames::skip,
129                     RegisterMap::WalkContinuation::skip);
130     frame f;
131     for (f = thread->last_frame();
132          !f.is_first_frame() && f.sp() <= unextended_sp && !Continuation::is_continuation_enterSpecial(f);
133          f = f.sender(&map)) {
134       interpreted_bottom = f.is_interpreted_frame();
135     }
136     assert(Continuation::is_continuation_enterSpecial(f), "");
137     sp = interpreted_bottom ? f.sp() : entry->bottom_sender_sp();
138   }
139 
140   assert(sp != nullptr, "");
141   assert(sp <= entry->entry_sp(), "");
142   address pc = ContinuationHelper::return_address_at(
143                  sp - frame::sender_sp_ret_address_offset());
144 
145   if (pc != StubRoutines::cont_returnBarrier()) {
146     CodeBlob* cb = pc != nullptr ? CodeCache::find_blob(pc) : nullptr;
147     assert(cb != nullptr, "sp: " INTPTR_FORMAT " pc: " INTPTR_FORMAT, p2i(sp), p2i(pc));
148     assert(cb->as_compiled_method()->method()->is_continuation_enter_intrinsic(), "");
149   }
150 
151   return true;
152 }
153 #endif // ASSERT